把new、virtual、override說透

我們先看下面一段程序：

1.     /// <summary>
2.     /// 父類
3. /// 作者：周公
4. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
5. /// 日期：2008-09-01
6.     /// </summary>
7.     public class Father
8.     {
9.         public void Run0()
10.         {
11.             Console.WriteLine("Father.Run0");
12.         }
13.      }
14.     /// <summary>
15. /// 子類
16. /// 作者：周公
17. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
18. /// 日期：2008-09-01
19.     /// </summary>
20.     public class Son:Father
21.     {
22.         public void Run0()
23.         {
24.             Console.WriteLine("Son.Run0");
25.         }
26. }
27. class Program
28.     {
29.         static void Main(string[] args)
30.         {
31.         Father[] fatherList = new Father[2];
32.             fatherList[0] = new Father();
33.             fatherList[1] = new Son();
34.             fatherList[0].Run0();
35.             fatherList[1].Run0();
36.     }
37. }

 

程序的運行結果是：
Father.Run0

Father.Run0

 

稍微細心的朋友可能發現在Son類的Run0方法下面有一段棕色的波浪線，當我們把鼠標放到該下劃線上時，會看到下面的提示（編譯程序時在程序的“輸出”窗口也能看到這個警告）：

“MethodDemo.Son.Run0()”隱藏了繼承的成員“MethodDemo.Father.Run0()”。如果是有意隱藏，請使用關鍵字new。

如圖：

 

然後我們再來第二個版本的Run方法，我們稱之爲Run1()，，與第一個版本的區別是在子類的同名同參（方法名相同，參數個數和參數順序相同，下同）方法前面加上了一個new關鍵字，代碼如下：

1.     /// <summary>
2.     /// 父類
3.  /// 作者：周公
4. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
5. /// 日期：2008-09-01    
6. /// </summary>
7.     public class Father
8.     {
9.         public void Run1()
10.         {
11.             Console.WriteLine("Father.Run1");
12.         }
13.      }
14.     /// <summary>
15. /// 子類
16. /// 作者：周公
17. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
18. /// 日期：2008-09-01
19.     /// </summary>
20.     public class Son:Father
21.     {
22.         public new void Run1()
23.         {
24.             Console.WriteLine("Son.Run1");
25.         }
26. }
27. class Program
28.     {
29.         static void Main(string[] args)
30.         {
31.         Father[] fatherList = new Father[2];
32.             fatherList[0] = new Father();
33.             fatherList[1] = new Son();
34.             fatherList[0].Run1();
35.             fatherList[1].Run1();
36.     }
37. }

運行結果如下：

Father.Run1

Father.Run1

 

我們發現加上new關鍵字之後，程序的運行結果沒有發生改變。也就是在C#中，如果在子類中有與父類同名同參的方法時，C#會隱式幫你在子類的方法前面添加一個new關鍵字。

 

我們再寫第三個版本的Run方法，即Run2()，與第一個版本不同的是父類的Run2()方面前面加了一個virtual關鍵字，表示這是一個虛方法，子類的Run2()除了與第一個版本號不同之外（Run0()改成Run2()）沒有什麼不同。

程序代碼如下：

1.     /// <summary>
2.     /// 父類
3. /// 作者：周公
4. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
5. /// 日期：2008-09-01
6.     /// </summary>
7.     public class Father
8.     {
9.         public virtual void Run2()
10.         {
11.             Console.WriteLine("Father.Run2");
12.         }
13.      }
14.     /// <summary>
15. /// 子類
16. /// 作者：周公
17. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
18. /// 日期：2008-09-01
19.     /// </summary>
20.     public class Son:Father
21.     {
22.         public void Run2()
23.         {
24.             Console.WriteLine("Son.Run2");
25.         }
26. }
27. class Program
28.     {
29.         static void Main(string[] args)
30.         {
31.         Father[] fatherList = new Father[2];
32.             fatherList[0] = new Father();
33.             fatherList[1] = new Son();
34.             fatherList[0].Run2();
35.             fatherList[1].Run2();
36.     }
37. }

我們看看程序的運行效果：

Father.Run2

Father.Run2

 

程序運行效果與第一個仍然沒有什麼區別，不過這次子類(Son) 的Run2()方法又出現了與Run方法的第一個版本（Run0()）一樣的警告：“MethodDemo.Son.Run2()”將隱藏繼承的成員“MethodDemo.Father.Run2()”。若要使當前成員重寫該實現，請添加關鍵字override。否則，添加關鍵字new。

 

我們再寫第四個版本的Run 方法，我們稱之爲Run3()，這次父類中Run3()的修飾符與第三個版本相比沒有變化（依然是virtual，虛方法），而子類Son中的 Run3()方法與第三個版本相比多了一個override修飾符（這次我們熟悉的那個棕色的波浪線警告沒有了）。代碼如下：

1.     /// <summary>
2.     /// 父類
3. /// 作者：周公
4. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
5. /// 日期：2008-09-01
6.     /// </summary>
7.     public class Father
8.     {
9.         public virtual void Run3()
10.         {
11.             Console.WriteLine("Father.Run3");
12.         }
13.      }
14.     /// <summary>
15. /// 子類
16. /// 作者：周公
17. /// 首發地址：http://blog.csdn.net/zhoufoxcn/archive/2008/09/02/2864429.aspx
18. /// 日期：2008-09-01
19.     /// </summary>
20.     public class Son:Father
21.     {
22.         public override void Run3()
23.         {
24.             Console.WriteLine("Son.Run3");
25.         }
26. }
27. class Program
28.     {
29.         static void Main(string[] args)
30.         {
31.         Father[] fatherList = new Father[2];
32.             fatherList[0] = new Father();
33.             fatherList[1] = new Son();
34.             fatherList[0].Run3();
35.             fatherList[1].Run3();
36.     }
37. }

程序的運行結果如下：

Father.Run3

Son.Run3

 

這次我們發現程序的運行結果與前面三次不一樣了，這次儘管我們聲明的對象類型都是Father類(Father數組裝的自然都是Father類型的引用)，但是因爲實例化數組中第二個元素的時候調用了Son類的構造函數，也就是實例化了一個Father類的子類（我們知道子類可以當作父類來看待，他們之間是is a的關係，反之則不行），也就是說fatherList數組中的第二個元素的引用類型是Father類型，但它的實例類型確實Son類型。而在運行的時候，並不是根據我們的引用類型（引用類型是Father類型的）去調用該引用類型的方法，而是調用該引用類型所指向的實例的方法。

 

爲什麼會發生這些現象呢？這裏要提到兩個概念：早綁定（early binding）和晚綁定（Late binding）。這個術語出現在存在繼承關係的基類和派生類中，它們同時定義了一個同名同參的方法。

早綁定：在編譯的時候就已經確定了將來程序運行基類或是派生類的哪個方法。在編譯代碼的時候根據引用類型就決定了運行該引用類型中定義的方法，即基類的方法。這種方法運行效率高。

晚綁定：只有在運行的時候才能決定運行基類或者派生類中的哪個方法。運行的時候將根據該實際類型而不是引用類型來調用相關方法，即取決於我們new了什麼樣對象。也就是即使我們new一個Father類的子類Son的實例，而不管我們是用Father類的引用指向這個Son的實例，方法調用的時候依然是調用Son的方法，而不是Father類的同名方法。

如我們上面所見，爲了實現晚綁定，C# 引入了兩個關鍵詞virtual和override。和Java中不同，Java中一切方法都是虛方法，也就是在運行的時候，JVM會自動檢測該引用的類型與實際類型是否一致（無論如何，該引用類型與實際類型之間存在着相等或者繼承關係，這樣才滿足is a的關係），如果一致執行該類型中定義的方法；如果不一致則會檢查該引用的實際類型是否具有同名同參方法，如果有則運行該實際類型的同名同參方法。這樣會帶來一個問題：每次運行的時候都會進行類型檢查，這樣會帶來一定的性能消耗。而在C#中一切方法如果沒有顯示指明，都是非虛的。對於非虛的方法，CLR運行的時候並不會進行類型檢查，而是直接運行該引用的類型中所定義的方法，即使這個引用所指向的實際類型是該引用類型的派生類，並且在派生類中存在着同名同參的方法，也不會運行派生類中定義的方法。這時，派生類中的方法隱藏了基類中的方法。

但是如果在基類中顯示聲明方法爲虛方法，那麼CLR在運行的時候會進行類型檢查，如果發現引用類型和實際的對象類型不一致，就會檢查派生類中是否覆蓋(override)了基類中的方法，如果是，則會運行派生類中的方法，而不是引用類型中的方法。

本文出自 “周公的專欄” 博客，請務必保留此出處http://zhoufoxcn.blog.51cto.com/792419/162950

本文出自 51CTO.COM技術博客