C#面向对象之继承(超详细)

布满荆棘的人生 2023-02-16 04:06 24阅读 0赞

**前言**：继承是面向对象程序设计的主要特征之一，是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用已存在的类的功能。

### 目录： ###

*   *  一、什么是继承？
     *  二、继承有什么用？
     *  三、继承有什么特点？
     *  四、简单的基础实现
     *  五、隐藏基类成员
     *  六、抽象类、密封类、抽象方法和虚方法
     *  七、有参数构造函数的继承

## 一、什么是继承？ ##

继承是在类之间建立一种相交关系，使得新定义的派生类（子类）的实例可以继承已有基类（父类）的特征和能力，而且还可以加入新的特性或者修改已有的特性建立起类的新层次。  
基类（父类）：被继承的类  
派生类（子类）：继承的类

--------------------

## 二、继承有什么用？ ##

*  在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段
 *  简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
 *  提供了软件复用功能，如果说类B继承类A，那么只需要在类B中添加类A中没有的类成员即可,这样能减小代码和数据的冗余度,大大的增加了程序的复用性。
 *  继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。

--------------------

## 三、继承有什么特点？ ##

*  派生类是对基类的扩展，派生类可以添加新的成员，但不能移除已经继承的成员的定义。
 *  继承可以传递。比如说类C继承类B，类B又继承类A，那么类C不但继承了类B声明的成员，同时也继承了类A声明的成员。
 *  构造函数和析构函数不能直接被继承，除此之外其他成员可以直接被继承。基类中成员的访问方式只能决定派生类中能否访问它们。
 *  派生类如果定义了与基类成员名相同的新成员，那么就可以覆盖基类中的成员。但是这并不是删除了这些成员，而是不能访问再它们而已。
 *  基类可以定义虚方法、虚属性及虚索引指示器，它的派生类可以重载这些成员,从而展示出它们的多态性。
 *  派生类中能从一个类中继承，可以通过接口来实现多重继承。

--------------------

## 四、简单的基础实现 ##

class Program
        {
        
        	//从运行结果可以看到很重要的一点，继承时先执行父类构造函数，接着再执行子类构造函数，最后再执行方法
            static void Main(string[] args)
            {
        
                Man man = new Man();
                //派生类调用基类中的成员方法有三种方式:
                //第一种:实例化派生类后直接  对象.基类成员方法
                //第二种:在派生类成员中 base.基类成员方法 然后实例化派生类, 对象.派生类成员方法(这里就是说先在派生类成员方法中调用基类中的成员方法,然后再调用派生类成员方法)
                //第三种:将派生类显式转化为基类, 先将派生类实例化  ((基类)派生类对象).基类成员方法
                //man.Eat();//第一种方式
                man.Eat1();//第二种方式
                //((Peopole)man).Eat();//第三种方式
                Console.ReadLine();
            }
        }
        public class Peopole 
        {
        
            public Peopole()
            {
        
                Console.WriteLine("基类的无参构造函数");
            }
            public void Eat()
            {
        
                Console.WriteLine("基类中吃的方法");    
            }
        }
        
        public class Man : Peopole
        {
        
            //因为基类中的构造函数没有参数,所以这里的:base()可以省略,但是实际是默认调用了父类的构造函数
            public Man():base()
            {
        
                Console.WriteLine("派生类的无参构造函数");
            }
            public void Eat1()
            {
        
                base.Eat();//这就是派生类调用基类中成员方法的第二种方式的第一步
            }
        }

--------------------

## 五、隐藏基类成员 ##

//当派生类需要覆盖基类的方法时，使用new修饰符来实现隐藏基类成员
        class Program
        {
        
            static void Main(string[] args)
            {
        
                Man man = new Man();
                man.Eat();
                Console.ReadLine();
            }
        }
        public class Peopole 
        {
        
            public Peopole()
            {
        
                Console.WriteLine("基类的无参构造函数");
            }
            public void Eat()
            {
        
                Console.WriteLine("基类中吃的方法");    
            }
        }
        
        public class Man : Peopole
        {
        
            
            public Man():base()
            {
        
                Console.WriteLine("派生类的无参构造函数");
            }
            public new void Eat()//new实现基类方法的隐藏
            {
        
                Console.WriteLine("派生类中的吃法");
            }
        }

--------------------

## 六、抽象类、密封类、抽象方法和虚方法 ##

如果说我们对类不作任何约束，所有类都可以被继承，这种继承的滥用会导致类的层次结构十分庞  
大，类与类之间的关系会变得很乱导致无法理解，所以我们需要密封类。

密封类的使用方法：在基类前加上sealed修饰符，则基类将不能被继承了。密封方法也是在方法前加上sealed修饰符。

抽象类和密封类刚好相反，它是为继承而生的。抽象类不能实例化，抽象方法没有具体执行代码，必须在非抽象的派生类中重写。也就是基类并不实现任何执行代码，只是进行定义。这一点和接口有相同的地方。

class Program
        {
        
            static void Main(string[] args)
            {
        
                Man man = new Man();
                man.Eat();
                man.Say();
                Console.ReadLine();
            }
        }
        public abstract class Peopole 
        {
        
            public Peopole()
            {
        
                Console.WriteLine("基类的无参构造函数");
            }
            //注意：如果类中有抽象方法，则类必须声明为抽象类。
            public abstract void Eat();
            //有时候不想把类声明为抽象类，但又想实现方法在基类里不具体实现，而是想实现方法由派生类重写。遇到这种情况时可使用virtual关键字将方法声明为虚方法
            public virtual void Say()
            {
        
                //注意虚方法必须声明方法主体，抽象方法则不需要
                Console.WriteLine("基类虚方法");
            }
        }
        
        public class Man : Peopole
        {
        
            public Man():base()
            {
        
                Console.WriteLine("派生类的无参构造函数");
            }
            public override void Eat()
            {
        
                Console.WriteLine("派生类中的吃法");
            }
            public override void Say()
            {
        
                Console.WriteLine("派生类中的说方法");
            }
        }

--------------------

## 七、有参数构造函数的继承 ##

class Program
        {
        
            static void Main(string[] args)
            {
        
                Man man = new Man("JUGG",18);
                Console.ReadLine();
            }
        }
        public abstract class Peopole 
        {
        
            public Peopole(string r,int age)
            {
        
                Console.WriteLine($"基类的有参构造函数:{r},{age}");
            }
        }
        
        public class Man : Peopole
        {
        
            
            public Man(string d,int age1):base(d,age1)
            {
        
                Console.WriteLine($"派生类的有参构造函数:{d},{age1}");
            }
        }

**派生类调用基类构造函数详解请阅读文章[C\#base关键字调用基类构造函数][C_base]**

--------------------

# 如有不足之处评论出来,谢谢!!! #

[C_base]: https://blog.csdn.net/liu991029/article/details/106618602