c#多態

　　多態是物件導向編程中三大機制之一,其原理建立在"從父類繼承而來的子類可以轉換為其父類"這個規則之上,換句話說,能用父類的地方,就能用該類的子類.當從父類派生了很多子類時,由於每個子類都有其不同的代碼實現,所以當用父類來引用這些子類時,同樣的操作而可以表現出不同的操作結果,這就是所謂的多態. 

　　多態允許將子類的對象當作父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。比如，你的老闆讓所有員工在九點鐘開始工作, 他只要在九點鐘的時候說：“開始工作”即可，而不需要對銷售人員說：“開始銷售工作”，對技術人員說：“開始技術工作”, 因為“員工”是一個抽象的事物, 只要是員工就可以開始工作，他知道這一點就行了。至於每個員工，當然會各司其職，做各自的工作。

　　物件導向程式設計中的另外一個重要概念是多態性。在運行時，可以通過指向基類的指標，來調用實現衍生類別中的方法。 可以把一組對象放到一個數組中，然後調用它們的方法，在這種場合下，多態性作用就體現出來了，這些對象不必是相同類型的對象。當然，如果它們都繼承自某個類，你可以把這些衍生類別，都放到一個數組中。 如果這些對象都有同名方法，就可以調用每個對象的同名方法。本節課將向你介紹如何完成這些事情。

1.清單9-1. 帶有虛方法的基類：DrawingObject.cs

using System; 
public class DrawingObject 
{ 
public virtual void Draw() 
{ 
Console.WriteLine("I'm just a generic drawing object."); 
} 
}

說明

　　清單9-1 定義了DrawingObject類。這是個可以讓其他對象繼承的基類。該類有一個名為Draw()的方法。Draw()方法帶有一個virtual修飾符，該修飾符表明：該基類的衍生類別可以重載該方法。DrawingObject類的 Draw()方法完成如下事情：輸出語句"I'm just a generic drawing object."到控制台。

2.清單9-2. 帶有重載方法的衍生類別：Line.cs, Circle.cs, and Square.cs

using System; 
public class Line : DrawingObject 
{ 
public override void Draw() 
{ 
Console.WriteLine("I'm a Line."); 
} 
}

public class Circle : DrawingObject 
{ 
public override void Draw() 
{ 
Console.WriteLine("I'm a Circle."); 
} 
}

public class Square : DrawingObject 
{ 
public override void Draw() 
{ 
Console.WriteLine("I'm a Square."); 
} 
}

說明

　　清單9-2定義了三個類。這三個類都派生自DrawingObject類。每個類都有一個同名Draw()方法，這些Draw()方法中的每一個都有一個重載修飾符。重載修飾符可讓該方法在運行時重載其基類的虛方法，實現這個功能的條件是：通過基類類型的指標變數來引用該類。

3.清單9-3. 實現多態性的程式：DrawDemo.cs

using System; 
public class DrawDemo 
{ 
public static int Main(string[] args) 
{ 
DrawingObject[] dObj = new DrawingObject[4]; 
dObj[0] = new Line(); 
dObj[1] = new Circle(); 
dObj[2] = new Square(); 
dObj[3] = new DrawingObject(); 
foreach (DrawingObject drawObj in dObj) 
{ 
drawObj.Draw(); 
} 
return 0; 
} 
}

說明

　　清單9-3示範了多態性的實現，該程式使用了在清單 9-1 和清單9-2中定義的類。在DrawDemo類中的Main()方法中，建立了一個數組， 數組元素是DrawingObject 類的對象。該數組名為dObj，是由四個DrawingObject類型的對象組成。

　　接下來， 初始化dObj數組， 由於Line， Circle和Square類都是DrawingObject類的衍生類別，所以這些類可以作為dObj數組元素的類型。 如果C#沒有這種功能，你得為每個類建立一個數組。繼承的性質可以讓派生對象當作基類成員一樣用，這樣就節省了編程工作量。

　　一旦數組初始化之後，接著是執行foreach迴圈，尋找數組中的每個元素。在每次迴圈中， dObj 數組的每個元素（對象）調用其Draw()方法。多態性體現在：在運行時，各自調用每個對象的Draw()方法。儘管dObj 數組中的引用物件類型是DrawingObject，這並不影響衍生類別重載DrawingObject 類的虛方法Draw()。 在dObj 數組中，通過指向DrawingObject 基類的指標來調用衍生類別中的重載的Draw()方法。

輸出結果是：

I'm a Line. 
I'm a Circle. 
I'm a Square. 
I'm just a generic drawing object.

　　在DrawDemo 程式中，調用了每個衍生類別的重載的Draw()方法。 最後一行中，執行的是DrawingObject類的虛方法Draw()。這是因為運行到最後，數組的第四個元素是DrawingObject類的對象。

小結 
　　現在對多態性有所瞭解之後，你可以在衍生類別中，實現一個重載基類虛方法的方法。虛方法和重載的衍生類別方法之間的關係就體現出C#的多態性。 

 

同種意義的直觀理解：
　　1、基類中定義虛方法，衍生類別中可以用override 來覆蓋基類中的方法。只有基類的方法加上關鍵字virtual後才可以被override,從而實現物件導向最重要的特徵--多態性，即基類可以使用衍生類別的方法
　　2、簡單一點說就是子類中override的方法能夠覆蓋積累中的virtual方法，當你把一個子類的執行個體轉換為基類時，調用該方法時還是調用的子類的override的方法

　　虛擬函數從C#的程式編譯的角度來看，它和其它一般的函數有什麼區別呢？一般函數在編譯時間就靜態地編譯到了執行檔案中，其相對位址在程式運行期間是不發生變化的，也就是寫死了的！而虛函數在編譯期間是不被靜態編譯的，它的相對位址是不確定的，它會根據運行時期對象執行個體來動態判斷要調用的函數，其中那個申明時定義的類叫申明類，那個執行時執行個體化的類叫執行個體類。

　　如：飛禽 bird = new 麻雀();
　　那麼飛禽就是申明類，麻雀是執行個體類。

具體的檢查的流程如下

　　1、當調用一個對象的函數時，系統會直接去檢查這個對象申明定義的類，即申明類，看所調用的函數是否為虛函數；

　　2、如果不是虛函數，那麼它就直接執行該函數。而如果有virtual關鍵字，也就是一個虛函數，那麼這個時候它就不會立刻執行該函數了，而是轉去檢查對象的執行個體類。

　　3、在這個執行個體類裡，他會檢查這個執行個體類的定義中是否有重新實現該虛函數（通過override關鍵字），如果是有，那麼OK，它就不會再找了，而馬上執行該執行個體類中的這個重新實現的函數。而如果沒有的話，系統就會不停地往上找執行個體類的父類，並對父類重複剛才在執行個體類裡的檢查，直到找到第一個重載了該虛函數的父類為止，然後執行該父類裡重載後的函數。

　　知道這點，就可以理解下面代碼的運行結果了：

using System;

namespace Zhisi.Net
{
    class A
    {
        public virtual void Func() // 注意virtual,表明這是一個虛擬函數
        {
            Console.WriteLine("Func In A");
        }
    }

    class B : A // 注意B是從A類繼承,所以A是父類,B是子類
    {
        public override void Func() // 注意override ,表明重新實現了虛函數
        {
            Console.WriteLine("Func In B");
        }
    }

    class C : B // 注意C是從B類繼承,所以B是父類,C是子類
    {
    }

    class D : A // A是父類,D是子類
    {
        public new void Func() // 注意new ，表明覆蓋父類裡的同名類，而不是重新實現
        {
            Console.WriteLine("Func In B");
        }
    }

    class program
    {
        static void Main()
        {
            A a;         // 定義一個a這個A類的對象.這個A就是a的申明類
            A b;         // 定義一個b這個A類的對象.這個A就是b的申明類
            A c;         // 定義一個c這個A類的對象.這個A就是b的申明類
            A d;         // 定義一個d這個A類的對象.這個A就是b的申明類

            a = new A(); // 執行個體化a對象,A是a的執行個體類
            b = new B(); // 執行個體化b對象,B是b的執行個體類
            c = new C(); // 執行個體化b對象,C是b的執行個體類
            d = new D(); // 執行個體化b對象,D是b的執行個體類

            a.Func();    // 執行a.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查執行個體類A，就為本身 4.執行執行個體類A中的方法 5.輸出結果 Func In A
            b.Func();    // 執行b.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查執行個體類B，有重載的 4.執行執行個體類B中的方法 5.輸出結果 Func In B
            c.Func();    // 執行c.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查執行個體類C，無重載的 4.轉去檢查類C的父類B，有重載的 5.執行父類B中的Func方法 5.輸出結果 Func In B
            d.Func();    // 執行d.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查執行個體類D，無重載的（這個地方要注意了，雖然D裡有實現Func()，但沒有使用override關鍵字，所以不會被認為是重載） 4.轉去檢查類D的父類A，就為本身 5.執行父類A中的Func方法 5.輸出結果 Func In A
            D d1 = new D();
            d1.Func(); // 執行D類裡的Func()，輸出結果 Func In D
            Console.ReadLine();
        }
    }
}