面向对象3大特性之一：继承

继承

继承表示一个类型（子类）派生自（继承于）一个基类型（父类），该类型将拥有基类型的所有成员字段和函数（不包括构造函数和析构函数）。

注意：

• 派生类继承基类的所有成员，不管是public、private、protected还是其他的，不管是静态的还是非静态的；但是，虽然派生类继承类基类所有的成员，基类却只能访问由public和protected修饰的成员（派生类继承了基类所有的字段，但是只能访问基类中public和protected修饰的成员）

    class Person
    {
        private string name = "张三";
        protected int age = 20;
        public bool gender = true;

        public void ShowInfo_Person()
        {
            Console.WriteLine(this.name + ":" + this.age + ":" + this.gender);
        }
    }

    class Chinese : Person
    {
        public void ShowInfo_Chinese()
        {
            Chinese chinese = new Chinese();
            Console.WriteLine(chinese.age);
            Console.WriteLine(chinese.gender);
            //Console.WriteLine(chinese.name);//由于基类中name用private修饰，所以在派生类中无法访问
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Chinese chinese = new Chinese();
            chinese.ShowInfo_Person();//输出结果：张三：20：True  此处通过派生类对象chinese可以调用基类中的ShowInfo_Person()方法，可以说明派生类也继承了private修饰的name字段
            Console.ReadKey();
        }
    }

• 派生类（子类）只能有一个直接基类（父类）；但是继承是可以传递的，例如ClassB派生自ClassA，同时ClassC派生自ClassB，那么ClassC会继承ClassB和ClassA中声明的成员。

    class Animal
    {
        public void Method_Animal()
        {
            Console.WriteLine("Animal:---------------");
        }
    }

    class Dog : Animal
    {
        public void Method_Dog()
        {
            Console.WriteLine("Dog:***************");
        }
    }

    class ErHa : Dog
    {
        public void Method_ErHa()
        {
            Console.WriteLine("ErHa:...............");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ErHa eh = new ErHa();
            eh.Method_Animal();
            eh.Method_Dog();
            eh.Method_ErHa();
            Console.ReadKey();
        }
    }

• C#不支持多重继承，派生类只能有一个直接基类，但是可以实现多个接口，并通过实现多个接口达到多重继承的目的

    interface IAnimal
    {
        void Method_Animal();
    }

    interface IDog
    {
        void Method_Dog();
    }
    //实现多重继承
    class ErHa : IAnimal, IDog
    {
        public void Method_ErHa()
        {
            Console.WriteLine("ErHa:...............");
        }

        public void Method_Animal()
        {
            Console.WriteLine("Animal:************");
        }

        public void Method_Dog()
        {
            Console.WriteLine("Dog:---------------");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ErHa eh = new ErHa();
            eh.Method_Animal();
            eh.Method_Dog();
            eh.Method_ErHa();
            Console.ReadKey();
        }
    }

• 结构不支持继承
• 派生类是对基类的扩展，派生类可以对基类进行成员的添加、重写、覆盖操作

构造函数

• 派生类无法继承基类的构造函数
• 当调用派生类的构造函数时，默认先调用基类的无参构造函数，当基类没有无参构造，需要派生类通过base关键字指定要调用的基类构造函数

    class Person
    {
        public Person()
        {
            Console.WriteLine("父类的无参构造函数被调用");
        }
    }

    class Student:Person
    {
        public Student()
        {
            Console.WriteLine("子类的无参构造函数被调用");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            Console.ReadKey();
        }
    }

 执行结果：

 当基类中不存在无参的构造函数时，需要通过base关键字派生类指定其要调用的基类的构造函数

    class Person
    {
        public Person(string name)
        {
            Console.WriteLine(name);
        }
    }

    class Student : Person
    {
        public Student()
        {
            Console.WriteLine();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            Console.ReadKey();
        }
    }

 以上代码执行时会出现以下错误：

如果我们想要使派生类调用基类的有参构造函数，而不是无参构造函数，就可以在派生类中通过base为其要调用的基类构造函数

    class Person
    {
        public Person(string name)
        {
            Console.WriteLine("姓名："+name);
        }
    }

    class Student : Person
    {
        public Student(string name, string num)
            : base(name)
        {
            Console.WriteLine("学号："+num);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student("张三", "0002");
            Console.ReadKey();
        }
    }

接下来我们通过以下代码，了解一下子类对象的初始化过程

    class Person
    {
        public string name = "默认值：张三";
        public string gender = "默认值：男";
        public Person(string name, string gender)
        {
            this.name = name;
            this.gender = gender;
        }
    }

    class Student : Person
    {
        public string num = "默认值：0002";
        public Student(string name, string gender, string num)
            : base(name, gender)
        {
            this.num = num;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student("李四", "女", "0004");
            Console.WriteLine(stu.name);
            Console.WriteLine(stu.gender);
            Console.WriteLine(stu.num);
            Console.ReadKey();
        }
    }

 当在Main方法中实例化Student的对象时，首先在内存中分配了空间，内存中的初始状态如下图：

 调用派生类的构造函数，首先会调用基类的构造函数，由于我们在派生类Student中通过base关键字指定了派生类要调用的基类构造函数为public Person(string name,string gender)，所以首先会用传入的参数替换掉基类中成员的默认值，执行完成后，内存中的情况如下：

 执行完指定的基类构造函数后，执行派生类自身的构造函数，执行完成后，内存中的情况如下：

至此，派生类对象实例化完成。