若一個實例方法聲明前帶有virtual關鍵字，那麽這個方法就是虛方法。
虛方法與非虛方法的最大不同是，虛方法的實現可以由派生類所取代，這種取代是通過方法的重寫實現的（以後再講）
虛方法的特點:
虛方法前不允許有static,abstract,或override修飾符
虛方法不能是私有的，因此不能使用private修飾符
虛方法的執行：
我們知道一般函數在編譯時就靜態地編譯到了執行文件中，其相對地址在程序運行期間是不發生變化的，
而虛函數在編譯期間是不被靜態編譯的，它的相對地址是不確定的，它會根據運行時期對象實例來動態判斷要調用的函數，
其中那個申明時定義的類叫申明類，那個執行時實例化的類叫實例類。
如：A a =new B(); 其中A是申明類，B是實例類。
1.當調用一個對象的函數時，系統會直接去檢查這個對象申明定義的類，即申明類，看所調用的函數是否為虛函數；
2.如果不是虛函數，那麽它就直接執行該函數。而如果是一個虛函數，那麽這個時候它就不會立刻執行該函數了，而是開始檢查對象的實例類。
3.在這個實例類裏，他會檢查這個實例類的定義中是否有實現該虛函數或者重新實現該虛函數（通過override關鍵字）的方法，
如果有，它就不會再找了，而是馬上執行該實例類中實現的虛函數的方法。而如果沒有的話，系統就會不停地往上找實例類的父類，
並對父類重復剛才在實例類裏的檢查，直到找到第一個重載了該虛函數的父類為止，然後執行該父類裏重載後的函數。
例1：

    class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new A();   // 定義一個a這個A類的對象.這個A就是a的申明類，實例化a對象,A是a的實例類   
             a.Sum();
             Console.Read();
        }
    }
 

執行a.Sum：
1.先檢查申明類A 2.檢查到是sum是虛擬方法 3.轉去檢查實例類A，結果是題本身
4.執行實例類A中實現Sum的方法 5.輸出結果 I am A Class,I am virtual sum().
例2：

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public override void Sum() // 重新實現了虛函數   
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();  // 定義一個a這個A類的對象.這個A就是a的申明類，實例化a對象,B是a的實例類              
             a.Sum();
             Console.Read();
        }
    }
 

執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類B，有重寫的方法 4.執行實例類B中的方法 5.輸出結果 I am B Class,I am override sum().
例3：

    class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public override void Sum() // 重新實現了虛函數   
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class C : B
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new C();// 定義一個a這個A類的對象.這個A就是a的申明類，實例化a對象,C是a的實例類              
             a.Sum();
             Console.Read();
        }
    }

執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類C，無重寫的方法 4.轉去檢查類C的父類B，有重寫的方法
5.執行父類B中的Sum方法 6.輸出結果 I am B Class,I am override sum().
例4：

   class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public new void Sum() //覆蓋父類裏的同名函數，而不是重新實現  
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();
             a.Sum();
             Console.Read();
        }
    }

執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類B，無重寫的（這個地方要註意了，雖然B裏有實現Sum()，但沒有使用override關鍵字，所以不會被認為是重寫） 4.轉去檢查類B的父類A，就為本身 5.執行父類A中的Sum方法 6.輸出結果 I am A Class,I am virtual sum().
那麽如果在例4裏，申明的是類B呢？

    class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public new void Sum() //覆蓋父類裏的同名函數，而不是重新實現  
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             B b=new B();
             b.Sum();
             Console.Read();
        }
    }

執行B類裏的Sum()，輸出結果I am B Class,I am new sum().
可以使用抽象函數重寫基類中的虛函數嗎？
答案是可以的。

    class A
    {
        public virtual void PrintFriends()
        {
            Console.WriteLine("A.PrintFriends()");   
        }  
    }
    abstract class B : A    
    {
        public abstract override void PrintFriends();   //使用override 修飾符，表示抽象重寫了基類中該函數的實現
    }
    abstract class C : A
    {
        public abstract new void PrintFriends();        //使用 new 修飾符顯式聲明，表示隱藏了基類中該函數的實現
    }

密封類可以有虛函數嗎？
可以，基類中的虛函數將隱式的轉化為非虛函數，但密封類本身不能再增加新的虛函數

    class A
    {
        public virtual void Fun()
        {
            Console.WriteLine("I am A.");
        }
    }
    sealed class Program:A
    {
        public override void Fun()
        {
            Console.WriteLine("I am B.");
        }
        static void Main(string[] args)
        {
            Program p = new Program();
            p.Fun();
            Console.Read();
        }
    }

C#基礎(七）虛函數