谈谈C#的继承机制(“子承父业”)

迈不过友情╰ 2021-12-21 04:35 133阅读 0赞

我们经常谈到面向对象的重要特性之一：**继承**，需要理解继承的重要机制：

1. **可传递性**。C-->B，B-->A ==> C-->A，即C继承A中所有非私有成员。

2. **对基类进行扩展**。即派生类在拥有基类成员的同时可添加新的成员，但不能移除已继承的成员。

3. **对基类的构造函数和析构函数不能继承**。则实例化派生类对象时，将先执行基类的构造函数，再执行自身的构造函数。

析构函数正好相反。

class Parent
    {
        
    public Parent()
        {
        
            Console.WriteLine("Parent Construtor");
        }
        ~Parent()//不建议定义，因为.NET有GC机制
        {
        
            Console.WriteLine("Parent Deconstrutor");
        }
    public void Say()
        {
        
            Console.WriteLine("I'm Parent");
        }
    }
    class Child : Parent
    {
        
    public Child()
        {
        
            Console.WriteLine("Child Construtor");
        }
        ~Child()
        {
        
            Console.WriteLine("Child Deconstrutor");
        }
    public void SayHello()
        {
        
    base.Say();//通过base访问
        }
    }
    //以如下方式调用：
    Child c = new Child();
    c.Say();
    c.SayHello();//通过base.成员名访问
    ((Parent)c).Say();//通过显式转化
    /* Parent Construtor
     * Child Construtor
     * I'm Parent
     * I'm Parent
     * I'm Parent
     * Child Deconstrutor
     * Parent Deconstrutor */

4. **可覆盖(new)已继承的基类(接口不支持)同名成员，使之在派生类中隐藏**。但并不会删除该同名成员，能通过**base.成员名**访问。

5. **可重写(override)在基类(可为抽象类)中定义的虚成员(virtual)**，从而表现出面向对象另一特性：多态性。

class Parent
    {
        
    public void Say()
        {
        
            Console.WriteLine("I'm Parent");
        }
    public virtual void SayHello()
        {
        
            Console.WriteLine("Hello: Parent");
        }
    }
    class Child : Parent
    {
        
    public new void Say()
        {
        
            Console.WriteLine("I'm Child");
        }
    public override void SayHello()
        {
        
            Console.WriteLine("Hello: Child");
        }
    }
    //以如下方式调用：
    Child c1 = new Child();
    c1.Say();//I'm Child
    c1.SayHello();//Hello: Child
    Parent c2 = new Child();
    c2.Say();//I'm Parent
    c2.SayHello();//Hello: Child

new与override的区别：new是**编译时多态**(根据对象定义时确定类型并调用相应类的方法)，override是**运行时多态**(根据对象分配内存时确定类型并调用相应的方法)。

6. **只能从一个基类继承，可以通过实现多接口来模拟多重继承**。注意：如果实现的接口不止一个且接口之间包含同名成员时，

则实现接口时不能用任何访问修饰符(public也不行)，只能通过**接口名.成员名**来实现。对其他非同名成员实现时必须加public。

interface ITestA
    {
        
    void Say();
    void TestA();
    }
    interface ITestB
    {
        
    void Say();
    void TestB();
    }
    class Test : ITestA, ITestB
    {
        
    //实现ITestA
        void ITestA.Say()
        {
        
            Console.WriteLine("I'm ITestA");
        }
    public void TestA()
        {
        
            Console.WriteLine("TestA");
        }
    //实现ITestB
        void ITestB.Say()
        {
        
            Console.WriteLine("I'm ITestB");
        }
    public void TestB()
        {
        
            Console.WriteLine("TestB");
        }
    }
    //以如下方式调用：
    Test t = new Test();
    ((ITestA)t).Say();//I'm ITestA
    ((ITestB)t).Say();//I'm ITestB
    t.TestA();//TestA
    t.TestB();//TestB

注：对继承的类之间，public, protected(internal)可以在基类与派生类中之间访问。而private仅能当前的类(以及内部类)中访问。internal可在同一应用程序集中的类访问。

转载于:https://www.cnblogs.com/hmiinyu/archive/2011/11/08/2241661.html