C# 我對多態的理解

物件導向三大寶，繼承，封裝和多態。

 

多態，是物件導向裡面比較難理解的基礎部分。聽完老蔣的課後，我有一些自己對多態的理解，寫在這裡。

  提到多態，就不得不說物件導向。那麼什麼是物件導向呢？

 
照我的理解，物件導向就是描述和封裝我們所處世界的一種方法，簡單的說，就是映射世界，萬物皆對象。

 
而物件導向的偉大這時候就得以顯現了一些，一個連世界都能映射出的方法，還有什麼是不能做的？

 
物件導向把我們所能看到的一切東西都看做執行個體，而我們給這些東西起的名字就是對這些東西的抽象，就是類。籠統點的名字就是抽象類別，比如動物；具體一點的就
是繼承自抽象類別的父類，比如貓；而再具體一點就是繼承父類的子類，比如波斯貓；注意了，到現在為止，我們所說的類都是抽象類別（或者是沒有執行個體化的類，隨
你），這個抽象類別包含著異常複雜的屬性（每一個屬性都是一個枚舉變數）和人們所能理解的方法。那麼好了，這時候，你就可以有一個活生生的自波斯貓類執行個體話
的小貓了，我們給它的名字這個屬性賦值：“小花”。

 
而至於你的小花的眼睛是什麼顏色，毛髮什麼顏色這些就取決於上帝給它對應的屬性賦什麼值了，由於這些屬性都是枚舉變數，所以沒辦法，你的小花怎麼也個性不
起來，因為這些枚舉變數的值都是根據人們的經驗所總結出來的。而至於你的小花喜歡尿床，可以認字什麼的，就看你讓它實現什麼介面了。這些都不屬於今天想寫
的內容，所以就此略過了。

 
多態的語義看似複雜，其實說起來不外乎兩種方式，一個是隱藏方法（new），一個是重寫方法（override）。

1.隱藏方法
 
隱藏方法指的是通過在子類中用new關鍵字，對父類的同簽名方法實現隱藏，實現當子類執行個體賦值給父類執行個體後，通過父類執行個體調用該方法實際調用的是父類實現的方法這一功能。

  例子：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test
{
    class
MyBase
    {
       
public void Func()
       
{
           
Console.WriteLine("我是父類方法");
       
}
    }
    class
MyDerive:MyBase
    {
       
public new void Func()
       
{
           
Console.WriteLine("我是子類方法");
       
}
    }

    class
Test
    {
       
static void Main(string[] args)
       
{
           
MyBase mybase = new MyBase();
           
mybase.Func();

           
MyDerive myderive = new MyDerive();
           
myderive.Func();

           
mybase = myderive;
           
mybase.Func();

           
Console.ReadLine();
       
}
    }
}

輸出：
    
我是父類方法
    
我是子類方法
    
我是父類方法
   
 

2.重寫方法
 
重寫方法指的是通過在子類中使用override關鍵字對，對父類使用virtual關鍵字修飾的同簽名方法進行重寫
，實現當子類執行個體賦值給父類執行個體後，通過父類執行個體調用該方法實際是調用子類實現的方法這一功能。

  例子：注意這兩個例子代碼的區別很小，但是結果卻很不一樣
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test
{
    class
MyBase
    {
       
public virtual void Func()
       
{
           
Console.WriteLine("我是父類方法");
       
}
    }
    class
MyDerive:MyBase
    {
       
public override void Func()
       
{
           
Console.WriteLine("我是子類方法");
       
}
    }

    class
Test
    {
       
static void Main(string[] args)
       
{
           
MyBase mybase = new MyBase();
           
mybase.Func();

           
MyDerive myderive = new MyDerive();
           
myderive.Func();

           
mybase = myderive;
           
mybase.Func();

           
Console.ReadLine();
       
}
    }
}

輸出：
    我是父類函數
    我是子類函數
    我是子類函數

你看，多態，就是這麼簡單。

   
或許又要納悶多態在編程上的使用，我就再舉個不恰當的例子吧。

   
現在大學不都開學麼，我們把大學裡的每個人都看做從“人”這個抽象類別繼承的子類。這些子類通過實現不同介面又分為 學生類 和
教官類。

   
好了，軍訓開始了。

   
軍訓訓誰，誰訓呢？於是我們new了一個 教官對象 “小張”  和 一群 學生對象
“愣頭青們”。

   
然後軍訓先訓站姿，一開始“愣頭青們”都由著自己的性子，也就是自己實現stand（）方法，隨便站著。這時候“小張”一看不願意了，於是說：“每個人都
給我站好了”。於是，“愣頭青們”開始按照原始的站姿站好了。軍訓到中午了，“小張”又叫每個人實現Eat()方法，也就是都去吃飯了。

    看懂
Eat()和Stand()方法哪個應該用重寫，哪個應該用隱藏了嗎？
   
還不明白的話，我就寫段虛擬碼，來解釋下我上面的這段大白話。
   
   class Person
   {
     
public virtual void Eat();
     
public  void Stand()
     
{
           
//標準站法
     
}
   }
   class
Student:Person,IStudentAble
   {
     
public new void Stand()
    
{
       
//每個人站姿不一樣
    
}
    
public override void Eat()
    
{
       
//每個人吃飯口味不一樣
    
}
   }
   class
Master:Person,IMasterAble
   {
   }
    class
大學生活
   {
     
public void 軍訓()
    
{
       
Master 小張=new Master();
       
Student[] 愣頭青們={"張三"，"李四","王五"};

       
//教官小張沒來前，大家隨便站
       
for(int i=0;i<愣頭青們.Length,i++)
       
{
    
    
  愣頭青們[i].Stand();
       
}

      
//教官小張來了，要求每個人都站好了
       
Person[] per=愣頭青們;
       
for(int i=0;i<per.Length,i++)
       
{
    
    
  per們[i].Stand();
       
}
       

       
//到中午了，教官小張說，每個人去吃飯
       
Person[] per2=愣頭青們;
       
for(int i=0;i<per2.Length,i++)
       
{
    
    
  per2[i].Eat();
       
}
    
}
   }