C#中Abstract和Virtual

一、Abstract 的用法

1、abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。

2、abstract关键字只能用在抽象类中修饰方法，并且没有具体的实现。抽象方法的实现必须在派生类中使用override关键字来实现。

3、在类声明中使用 abstract 修饰符以指示类只能是其他类的基类，并且被abstract 修饰的类不能实例化；可以包含抽象方法和抽象访问器；不能用 sealed 修饰符修改抽象类，意味着该类不能被继承；从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现；在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现等等。

二、Virtual 的用法

1、Virtual 不能用来修饰类
看到virtual关键字的时候，产生了一个疑问："virtual"关键字只能修饰方法和属性，却不能修饰类~但清楚记得以前上大学老师讲c++的时候有一个概念，叫虚基类。难道c#把virtual的这个特性去掉了？然后我到google找答案~看到了两篇文章“c++虚基类”和“深入剖析c#继承机制”，终于明白了原来是由于这两者的继承机制不同而决定的。c++允许多重继承，而c#只允许派生类从一个类中继承，由于多重继承产生的二义性问题需要虚基类来解决，所以c++有虚基类的概念，而c#类由于单继承的原因不会产生继承而带来的二义性问题，所以不需要virtual关键修饰

2、c# virtual 可以用于修饰一个实现的类方法（待重写，override），而abstract 修饰的方法没有实现（待实现，override）

3、virtual和非virtual关键是在运行时候，而不是在编译时候

• 如果方法不是virtual的，编译器就使用声明的类对应的类型，也就是说，不是virtual的，在编译时候，就定了。
• 如果方法是Virtual的，然后子类使用了override, 编译器就生产代码。然后，在运行的时候，进行检测，看对象属于哪个类，然后调用这个类的方法。
• new 的用法： new与virtual并没有必然的联系。从字面上看，new声明的方法是一个“新”方法，与基类完全没有关系（虽然不幸与基类的某个方法同名同参）。也即：通过向上转型（如：基类 引用名=new 子类（））得到的引用将无法看到子类中new出来的方法。

4、实际流程
在C++、Java等众多OOP语言里都可以看到virtual的身影，而C#作为一个完全面向对象的语言当然也不例外。
那么飞禽就是申明类，麻雀是实例类。

虚拟函数从C#的程序编译的角度来看，它和其它一般的函数有什么区别呢？一般函数在编译时就静态地编译到了执行文件中，其相对地址在程序运行期间是不发生变化的，也就是写死了的！而虚函数在编译期间是不被静态编译的，它的相对地址是不确定的，它会根据运行时期对象实例来动态判断要调用的函数，其中那个申明时定义的类叫申明类，那个执行时实例化的类叫实例类。

如：飞禽 bird = new 麻雀();

具体的检查的流程如下：

• 当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即申明类，看所调用的函数是否为虚函数；
• 如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。
• 在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重载了该虚函数的父类为止，然后执行该父类里重载后的函数。

知道这点，就可以理解下面代码的运行结果了：

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A(); // 实例化a对象,A是a的实例类,A是a的申明类     
            A b = new B(); // 实例化b对象,B是b的实例类,A是b的申明类     
            A c = new C(); // 实例化b对象,C是b的实例类,A是c的申明类     
            A d = new D(); // 实例化b对象,D是b的实例类,A是d的申明类  

            // 执行a.Func：
            // 1.先检查申明类A 
            // 2.检查到是虚拟方法 
            // 3.转去检查实例类A，就为本身 
            // 4.执行实例类A中的方法 
            // 5.输出结果 Func In A
            a.Func();

            // 执行b.Func：
            // 1.先检查申明类A 
            // 2.检查到是虚拟方法 
            // 3.转去检查实例类B，有重载的 
            // 4.执行实例类B中的方法 
            // 5.输出结果 Func In B   
            b.Func();  
  
            // 执行c.Func：
            // 1.先检查申明类A 
            // 2.检查到是虚拟方法 
            // 3.转去检查实例类C，无重载的
            // 4.转去检查类C的父类B，有重载的 
            // 5.执行父类B中的Func方法
            // 6.输出结果 Func In B
            c.Func();

            // 执行d.Func：
            // 1.先检查申明类A
            // 2.检查到是虚拟方法 
            // 3.转去检查实例类D，无重载的（这个地方要注意了，虽然D里有实现Func()，但没有使用override关键字，所以不会被认为是重载） 
            // 4.转去检查类D的父类A，就为本身
            // 5.执行父类A中的Func方法 
            // 6.输出结果 Func In A   
            d.Func(); 
   
            D d1 = new D();
            d1.Func(); // 执行D类里的Func()，输出结果 Func In D   
            Console.ReadKey();
        }
    }

    class A
    {
        public virtual void Func() // 注意virtual,表明这是一个虚拟函数   
        {
            Console.WriteLine("Func In A");
        }
    }
    class B : A   
    {
        public override void Func() // 注意override ,表明重新实现了虚函数   
        {
            Console.WriteLine("Func In B");
        }
    }
    class C : B   
    {}
    class D : A 
    {
        public new void Func() // 注意new ，表明覆盖父类里的同名类，而不是重新实现   
        {
            Console.WriteLine("Func In D");
        }
    }
}