C#之虛函數

若一個實例方法宣告前面有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.轉
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();
        }
    }

🎜