[原创]C#中的继承、重写、覆盖、多态、virtual override 以及其他

参考：《C#本质论》

例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

    public class BaseClass    {
        public virtual void displayName()
        {
            Console.WriteLine("BaseClass");
        }
    }

    public class DerivedClass : BaseClass
    {
        public virtual void displayName()
        {
            Console.WriteLine("DerivedClass");
        }     
    }

    public class SubDerivedClass:DerivedClass
    {
        public override void displayName()
        {
            Console.WriteLine("SubDerivedClass");
        }   
    }

    public class SuperDerivedClass:SubDerivedClass
    {
        public void displayName()
        {
            Console.WriteLine("SuperDerivedClass");
        }     
    }


    class Program
    {
        static void Main(string[] args)
        {
            SuperDerivedClass superDerivedClass = new SuperDerivedClass();
            SubDerivedClass subDerivedClass = superDerivedClass;
            DerivedClass derivedClass = superDerivedClass;
            BaseClass baseClass = superDerivedClass;

            superDerivedClass.displayName();
            subDerivedClass.displayName();
            derivedClass.displayName();
            baseClass.displayName();

        }
    }

执行结果

结果剖析：

superDerivedClass.displayName();

 

不需解释。没有子类，所以无多态。

 

subDerivedClass.displayName();

subDerivedClass重写了DerivedClass的方法，则subDerivedClass中的displayName也是虚方法，于是运行时要从继承链中尽量找派生得最远的虚方法，发现其子类SuperDerivedClass没有用override，这意味着SuperDerivedClass只是覆盖了displayName方法，没有重写它。所以并不执行SuperDerivedClass的displayName，而执subDerivedClass的displayName。

derivedClass.displayName();

DerivedClass覆盖了(是覆盖，不是重写，因为没有override标签)BaseClass的方法，但这个覆盖的方法被声明为virtual，于是运行时要从继承链中尽量找派生得最远的虚方法，发现其子类SubDerivedClass重写了这个方法，于是从SubDerivedClass继续往下找，找到SuperDerivedClass时，发现SuperDerivedClass覆盖了这个方法，没有重写，所以最终执行SubDerivedClass的displayName方法。

baseClass.displayName();

在BaseClass中displayName是个虚方法，于是它要试图找派生的最远的虚方法。但找到DerivedClass就发现，DerivedClass已经把displayName覆盖了，这条虚链于是就断了。所以就直接执行BaseClass的方法了。

注意：

如果把SubDerivedClass的override去掉，则试图在SuperDerivedClass中写public override void displayName()是编译不过的。因为虽然在DerivedClass中有虚的displayName可供子类override，但由于SubDerivedClass中的DerivedClass没有加override，这相当于SubDerivedClass覆盖了DerivedClass的displayName方法，而非override了它，于是在SuperDerivedClass看到的displayName，其实是SubDerivedClass的dislayName，是一个非虚的方法，而不是从DerivedClass传承下来的虚方法，所以不能override

 

总结

若一个类中有一个方法，则只在两种情况下该方法才会是一个虚方法。

1：该方法用virtual定义。

2：该类的父类中有一个同名的虚方法，在该类中用override关键字重写了父类的虚方法。

 

子类要想“重写”而非“覆盖”父类的方法，要满足两个条件。

一：“父类方法是虚方法。（这意味着该方法或者是有virtual标记的，或者是override它的父类的。）”。

二：“子类中有override标记”。

这二者缺一，则意味着子类是对父类的方法进行了“覆盖”，而非“重写”。

 

如果一个方法是虚方法()，则运行时从找那个“重写”得最远的方法来执行。一旦遇到“覆盖”，则继承链就断掉了。

6月23日新增内容

多态与abstract关键字

abstract方法默认是虚方法，子类必须显式地用override关键字来重写。并且子类中override的方法也默认为虚方法，可以供其他类进行重写

 

例子

using System;

public abstract class Father
{
    public abstract void doWork();
}

public class Child : Father
{
    public override void doWork()//该方法是虚方法，可供子类重写
    {
        Console.WriteLine("This is Child");
    }
}

public class GrandChild : Child
{
    public override void doWork()//该方法是虚方法，可供子类重写
    {
        Console.WriteLine("This is grandChild~");
    }
}

public class M
{
    public static void Main()
    {
        Father f = new GrandChild();
        f.doWork();
    }
}

由于多态的机制，运行结果是“This is grandChild~”

接口与多态

与接口有关的多态则不太适合上述分析方法。上述分析只对纯类之间的多态有效。

接口中的方法被默认编译为virtual的,而在接口的实现类中所实现的方法,也被默认编译为override的。但在接口的实现类中所实现的方法并不能显示地使用override关键字，也并不像类中override的方法那样自动成为虚方法，若要想让该方法为虚，需要显式加上virtual。

 

例子：

using System;

public class Father : MyInterface
{
    public void doWork()
    {
        Console.WriteLine("Father");
    }
}

public interface MyInterface
{
    void doWork();
}

public class Child : Father
{
    public void doWork()
    {
        Console.WriteLine("Child");
    }
}

public class M
{
    public static void Main()
    {
        MyInterface f = new Child();
        f.doWork();
    }
}

运行结果是 “Father”。

 

剖析：

以接口的身份来调用函数，却调用到了Father.doWork()，说明多态的机制生效了。但由于Father.doWork()并不默认为虚方法，所以Child并不能override这个方法，只能覆盖Father.doWork()方法，试图在Child.doWork()前边添 加override关键字会编译不过。

 

如果在Father.doWork()前添加virtual关键字并在Child.doWork()前添加override关键字，则运行结果就变成了Child，说明从接口发出的虚链，可以无限延伸，而不是只延伸到实现接口的那个类。