C#面向對象五(繼承、抽象類和抽象方法、多態、虛方法、is、as、new覆蓋關鍵字)

1.繼承的特色：

　　繼承順序的不可逆性：繼承是從上往下依此繼承，而不能逆序進行。

　　繼承的延續性：在繼承順序中，下一級具有上一級的屬性和特徵。

2.繼承的好處：

　　代碼複用，避免重複。

　　一處更新，到處更新。

3.繼承的步驟和使用要點：

　　抽取公共部分，放到一個特定的類中（父類）。

　　其餘類（子類）只須要繼承父類，便可擁有父類特徵（屬性和方法）。

　　根據子類的須要添加屬於本身的特徵和方法。

4.繼承的實現（和接口的實現形式相似）

　　在子類後面使用冒號「:」繼承父類，如  class Dog : Animal

5.概念解釋

　　子類繼承父類，父類派生子類。

　　子類又叫派生類，父類又叫基類（超類）。

　　子類繼承父類成員，也能夠有本身獨立的成員。

6.繼承的條件

　　繼承須要符合的關係：is-a 的關係　　Cat is an Animal。

7.繼承中的構造函數

　　this:可使用this關鍵字訪問父類成員（在構造函數中）。

　　base:調用父類的構造函數、調用父類的屬性和方法。

1 public Dog(string name,string color,string kind,string favorite):base(name,color,kind) 2 { 3     this.Favorite=favorite; 4 }

繼承中使用base關鍵字

 1 class Animal  2  {  3         //父類構造函數
 4         public Animal() { }  5         public Animal(string name, string color, string kind)  6  {  7             this.Color = color;  8             this.Name = name;  9             this.Kind = kind; 10  } 11        
12         public string Name { get; set; }//名字
13         public string Color { get; set; }//顏色
14         public string Kind { get; set; }//種類
15         public string Favorite { get; set; }//喜愛
16  } 17 
18 class Dog : Animal 19  { 20         public Dog(string name, string color, string kind, string favorite) 21             : base(name, color, kind) 22  { 23             this.Favorite = favorite; 24  } 25     }

繼承中base關鍵字(2)

8.protected關鍵字

　　protected訪問修飾符容許子類訪問，而不容許其餘非子類訪問。

 

修飾符	類內部	子類	其餘類
public	能夠	能夠	能夠
private	能夠	不能夠	不能夠
protected	能夠	能夠	不能夠

9子類調用父類構造函數總結

　　隱式調用：若是其餘子類的構造函數沒有使用base指明調用父類哪一個構造函數時，子類會默認調用父類的無參構造函數:base()。這時父類要提供無參的構造函數。

　　顯式調用：若是父類沒有無參的構造函數，子類構造函數必須指明調用父類哪一個構造函數。

10.繼承的特性

　　繼承的傳遞性：傳遞機制  A——>B 　　B——>C  　　C具備A的特性

　　繼承的單根性：一個類只能有一個父類

　　例如機器視覺技術與軟件學科又屬於光學學科，可否同時繼承兩種人？　　答案：不能

11.抽象類和抽象方法 abstract override

　　抽象方法就是在父類中未實現的方法，在子類中必須實現父類中的全部的抽象方法。

　　一個抽象類內能夠沒有抽象方法。

　　一個抽象方法所在的類必須是抽象類。

 1 abstract class Animal  2 {  3    public string Name {get;set;}  4    public Animal(){}  5    //用abstract修飾抽象方法
 6    public abstract void Have();  7 }  8 
 9 class Dog:Animal 10 { 11    //用override重寫父類未實現的方法
12    public override void Have() 13  { 14        Console.WriteLine("狗吃骨頭"); 15  } 16 } 17 
18 class Cat:Anima 19 { 20     public override void Have() 21  { 22         Console.WriteLine("貓吃魚"); 23  } 24 }

抽象方法和重寫

 1 abstract class Animal  2  {  3         public string Name { get; set; }//名字
 4         public string Color { get; set; }//顏色
 5         public string Kind { get; set; }//種類
 6         public string Favorite { get; set; }//喜愛  7         //父類構造函數
 8         public Animal() { }  9         public Animal(string name, string color, string kind) 10  { 11             this.Color = color; 12             this.Name = name; 13             this.Kind = kind; 14  } 15         //抽象方法
16         public abstract void Have(); 17  } 18 
19 class Dog : Animal 20  { 21         public Dog(string name, string color, string kind, string favorite) 22             : base(name, color, kind) 23  { 24             this.Favorite = favorite; 25  } 26         public override void Have() 27  { 28             Console.WriteLine("咱們要吃香噴噴的排骨啦！"); 29  } 30  } 31 
32 class Cat : Animal 33  { 34         public Cat(string name, string color, string kind, string favorite) 35             : base(name, color, kind) 36  { 37             this.Favorite = favorite; 38  } 39         public override void Have() 40  { 41             Console.WriteLine("咱們要吃香噴噴的烤魚啦！"); 42  } 43  } 44 
45 static void Main(string[] args) 46  { 47             //建立一隻狗和一隻貓
48             Cat objCat = new Cat("球球兒", "黃色", "小花貓", "小魚"); 49             Dog objDog = new Dog("棒棒", "黑色", "小黑狗", "排骨"); 50             //將子類對象添加的父類集合
51             List<Animal> list = new List<Animal>(); 52  list.Add(objCat); 53  list.Add(objDog); 54             //取出子類對象
55             foreach (Animal obj in list) 56  { 57                 obj.Have();//***********這就是多態***********
58  } 59  Console.ReadLine(); 60         }

抽象方法和重寫(2)

12.抽象類的概念與使用要點

　　12.1使用關鍵字abstract修飾的類，稱爲抽象類

　　12.2抽象類只是用來列舉一個類所具備的行爲，不能單獨經過建立對象來使用，也就是說抽樣類不能被new

　　12.3抽象類中能夠有抽象方法，也能夠沒有任何抽象方法

　　12.4抽象類不能是靜態的（static）或密封的（sealed），密封類不能被繼承

13.抽象方法的概念與使用要點

　　13.1在抽象類中使用abstract修飾的方法，稱爲抽象方法

　　13.2抽象方法必須在抽象類中定義，不能在普通類中使用

　　13.3抽象方法只是一個方法的聲明，不能有任何方法體

　　13.4抽象方法僅僅是表示一個應該具備的行爲，具體實現由其子類實現

　　13.5抽象方法在子類中被實現（重寫）必須使用關鍵字override

　　13.6子類必須重寫父類的全部抽象方法，除非子類自己也是抽象類

 14.多態

　　概念：不一樣對象，接受相同信息，產生不一樣行爲，稱爲多態。

　　多態是由「聰明的」虛擬機自行決定的。

　　例如：子類重寫了父類的抽象方法，父類集合中的對象直接調用抽象方法，實現子類中重寫的抽象方法，能夠稱之爲多態。

15.使用繼承實現多態

　　15.1父類中必須有抽象方法或虛方法

　　15.2子類必須覆寫（override）父類中的抽象方法或虛方法

　　15.3子類對象必須轉換成父類類型去使用

　　多態的應用大大提升了程序的可擴展性

 1 abstract class Animal  2  {  3         public string Name { get; set; }//名字
 4         public string Color { get; set; }//顏色
 5         public string Kind { get; set; }//種類
 6         public string Favorite { get; set; }//喜愛  7         //父類構造函數
 8         public Animal() { }  9         public Animal(string name, string color, string kind) 10  { 11             this.Color = color; 12             this.Name = name; 13             this.Kind = kind; 14  } 15         //抽象方法
16         public abstract void Have(); 17  } 18 
19 class Dog : Animal 20  { 21         public Dog(string name, string color, string kind, string favorite) 22             : base(name, color, kind) 23  { 24             this.Favorite = favorite; 25  } 26         //吃飯
27         public override void Have() 28  { 29             Console.WriteLine("咱們要吃香噴噴的排骨啦！"); 30  } 31  } 32 
33 class Cat : Animal 34  { 35         public Cat(string name, string color, string kind, string favorite) 36             : base(name, color, kind) 37  { 38             this.Favorite = favorite; 39  } 40         //吃飯
41         public override void Have() 42  { 43             Console.WriteLine("咱們要吃香噴噴的烤魚啦！"); 44  } 45  } 46 
47 static void Main(string[] args) 48  { 49             //建立一隻狗和一隻貓
50             Cat objCat = new Cat("球球兒", "白色", "小花貓", "小魚"); 51             Dog objDog = new Dog("棒棒", "黑色", "小黑狗", "排骨"); 52             //調用方法，傳遞子類對象
53  Test(objCat); 54  Test(objDog); 55  Console.ReadLine(); 56         }

繼承多態的典型應用

 16.里氏替換原則

　　16.1子類的對象可以替換父類

　　16.2父類對象不可以替換子類

　　16.3父類的方法都要在子類中實現或重寫

　　解釋：父類的範圍廣，父類包含子類，狗類屬於動物類，但動物類不能僅屬於狗類

17.is和as操做符

　　is操做符檢查是否與指定類型兼容。若是轉換失敗程序中斷

1 foreach (Animal obj in list) 2 { 3    if(obj is Cat) 4         Console.WriteLine("我是隻貓"); 5    else if (obj is Dog) 6         Console.WriteLine("我是條狗"); 7 }

is操做符

　　as操做符用於在兼容的引用類型之間執行轉換，轉換失敗返回null

　　Cat cat = obj as Cat;

18.引入虛方法（虛方法和抽象方法的區別）

　　18.1抽象方法的特色：抽象方法僅僅是聲明，沒有任何實現內容；抽象方法通常必須在子類中被重寫之後纔有使用價值。

　　18.2若是父類中提供一個方法，要求由本身的方法體，子類根據本身的須要再決定是否須要重寫此方法，該如何實現?————>>>>>>虛方法！  原來的abstract換成virtual。

　　18.3若是子類重寫了虛方法，調用的就是子類的；若是子類未重寫虛方法，調用的就是父類的。

 1 //注意有虛方法的父類並不要添加abstract關鍵字
 2     class Animal  3  {  4         public string Name { get; set; }//名字
 5         public string Color { get; set; }//顏色
 6         public string Kind { get; set; }//種類
 7         public string Favorite { get; set; }//喜愛
 8         public Animal() { }  9         public Animal(string name, string color, string kind) 10  { 11             this.Color = color; 12             this.Name = name; 13             this.Kind = kind; 14  } 15         //虛方法
16         public virtual void Have() 17  { 18             Console.WriteLine("咱們要吃飯啦！"); 19  } 20  } 21 
22 //Dog類重寫了虛方法
23     class Dog : Animal 24  { 25         public Dog(string name, string color, string kind, string favorite) 26             : base(name, color, kind) 27  { 28             this.Favorite = favorite; 29  } 30         //吃飯
31         public override void Have() 32  { 33             Console.WriteLine("咱們要吃香噴噴的排骨啦！"); 34  } 35  } 36 
37 //Cat類未重寫虛方法
38     class Cat : Animal 39  { 40         public Cat(string name, string color, string kind, string favorite) 41             : base(name, color, kind) 42  { 43             this.Favorite = favorite; 44  } 45  } 46 
47 static void Main(string[] args) 48  { 49             //建立一隻狗和一隻貓
50             Cat objCat = new Cat("球球兒", "黃色", "小花貓", "小魚"); 51             Dog objDog = new Dog("棒棒", "黑色", "小黑狗", "排骨"); 52             //將子類對象添加的父類集合
53             List<Animal> list = new List<Animal>(); 54  list.Add(objCat); 55  list.Add(objDog); 56             //取出子類對象
57             foreach (Animal obj in list) 58  { 59  obj.Have(); 60  } 61  Console.ReadLine(); 62  } 63 
64 //最終結果顯示 65 //咱們要吃飯啦！ 66 //咱們要吃香噴噴的排骨啦！

虛方法

19.虛方法與抽象方法比較

虛方法	抽象方法
用virtual修飾	用abstract修飾
要有方法體，哪怕是一個分號	不容許有方法體
能夠被子類override	必須被子類override
除了密封類均可以寫	必須在抽象類中

20.object類自帶的虛方法　　

　　Eauals()虛方法

　　　　對於字符串和值類型，可以自動比較是否相等

　　　　對於對象比較，必須重寫override後纔有意義

　　ToString()虛方法

　　　　對於值類型，返回變量值的字符串表示

　　　　對於對象，默認返回該對象的徹底限定類型名(徹底限定類型名：引用空間+類名）,可根據須要重寫

21.密封類sealed

　　當一個類使用sealed修飾後，該類不能被繼承。

　　sealed對於保護知識產權起到必定做用，必定程度限制別人二次開發。

22.方法覆蓋new

　　子類中的方法定義時使用new關鍵字覆蓋父類中的同名方法

　　使用子類覆蓋父類的方法後，子類對象調用該方法調用的是子類中new的方法

　　若是其餘子類沒有覆蓋new父類的同名方法，其餘子類對象調用此方法時仍然是父類中的方法

　　在控件開發中常用new關鍵字來覆蓋父類的同名方法

 1 //Dog覆蓋了Introduce()，Cat未處理
 2 abstract class Animal  3  {  4         public string Name { get; set; }//名字
 5         public string Color { get; set; }//顏色
 6         public string Kind { get; set; }//種類
 7         public string Favorite { get; set; }//喜愛  8         //父類構造函數
 9         public Animal() { } 10         public Animal(string name, string color, string kind) 11  { 12             this.Color = color; 13             this.Name = name; 14             this.Kind = kind; 15  } 16         //自我介紹
17         public void Introduce() 18  { 19             string info = string.Format("這是父類的方法，我是漂亮的{0}，個人名字叫{1}，身穿{2}的衣服，我愛吃{3}！", 20  Kind, Name, Color, Favorite); 21  Console.WriteLine(info); 22  } 23  } 24 
25 class Dog : Animal 26  { 27         public Dog(string name, string color, string kind, string favorite) 28             : base(name, color, kind) 29  { 30             this.Favorite = favorite; 31  } 32         public new void Introduce() 33  { 34             string info = string.Format("這是Dog類中的方法Hi! I am {0}，My Name is {1}！", 35  Kind, Name); 36  Console.WriteLine(info); 37  } 38  } 39 
40 class Cat : Animal 41  { 42         public Cat(string name, string color, string kind, string favorite) 43             : base(name, color, kind) 44  { 45             this.Favorite = favorite; 46  } 47  } 48 
49 static void Main(string[] args) 50  { 51             //建立一隻狗和一隻貓
52             Cat objCat = new Cat("球球兒", "黃色", "小花貓", "小魚"); 53  objCat.Introduce(); 54             Dog objDog = new Dog("棒棒", "黑色", "小黑狗", "排骨"); 55  objDog.Introduce(); 56  Console.ReadLine(); 57  } 58 
59 //結果顯示 60 //這是父類的方法，我是漂亮的小花貓，個人名字叫球球兒，身穿黃色的衣服，我愛吃小魚！ 61 //這是Dog類中的方法，Hi! I am 小黑狗，My Name is 棒棒！

使用new覆蓋掉父類中的方法

23.面向對象三大特性簡單總結

　　23.1封裝　　隱藏內部實現，穩定外部接口——>系統穩定性

　　23.2繼承　　子類繼承父類成員，實現代碼複用——>開發和維護效率

　　23.3多態　　不一樣子類，對同一消息，作出不一樣反應——>系統擴展性

 

　　23.1 封裝是把一個對象的屬性和行爲打包，繼承就是動物都會呼吸，多態就是人用肺呼吸，魚用鰓呼吸。封裝的是字段、屬性、方法。封裝的好處：數據安全、內部修改保持穩定、提升重用性、分工合做、職責分明、方便構建大型複雜的系統。封裝是面向過程到面向對象的最大的一個改變。

　　23.2 繼承：去掉重複代碼，能夠實現多態，是侵入性很強的類關係，里氏替換原則

　　23.3 多態：相同的變量，相同的操做，可是不一樣的實現。方法重載、接口&實現、抽象類&實現、繼承&實現。

　　23.4 抽象abstract：一方面子類都得有某個行爲，另外一方面子類中的各個行爲又各不相同，能夠在抽象abstract類裏面定義一個抽象方法，在抽象方法裏僅僅定義方法聲明沒有方法的具體實現，全部繼承抽象類的子類必須override重寫此抽象方法。抽象類無法直接實例化，只能new子類；面向抽象，只能用抽象裏面的東西，若是有個性化操做（某個子類特有的），那就別抽象了，由於沒有意義。

　　23.5接口：接口中方法不能具體實現，這點和抽象類相似，且不能寫訪問修飾符，所有默認public，接口能夠包含屬性、事件、索引器，不能包含字段、委託、類。實現接口須要顯式實現接口的全部方法（子類中方法前不須要加override）。接口不能直接實例化，只能new實現該接口的子類。

　　23.6  如何選擇接口和抽象類？

　　　　抽象類：父類+約束，父類的特性能夠在抽象類中完成通用方法的實現。 【 ：至關於 is a】

　　　　接口：純粹的約束，只能約束，接口中全部的方法僅僅是聲明、都不能實現。【：至關於 can do】

　　　　一個子類只能繼承一個父類，但能夠實現多個接口，這點上來說接口實現更靈活。【單繼承多實現】　　抽象類畢竟仍是一個類，只是某些內容不肯定，例如手機基類，在抽象類中能夠定義名稱、用戶等屬性和Call()、Photo()等能夠實現的共有方法以及抽象的什麼操做系統的手機方法，而接口則是定義行爲，形容一系列事物能夠大體作什麼。【子類都同樣的，放在父類；子類都有可是相關之間不一樣，抽象一下；有的有有的沒有，接口】【工做中接口用的更多，由於接口更簡單靈活，除非有些共有的東西須要繼承】

　　　　舉例：門：屬性有材質、貓眼、門鈴          方法有開門()、關門()、報警()　　　　抽象類：材質、開門()、關門()          接口：貓眼（運鈔車也有貓眼，因此運鈔車能夠繼承此接口）　　　　接口：門鈴　　　　接口：報警（能報警的東西不少，例如說監控器、健康手錶，因此這類東西均可以繼承此接口）

　　23.7 虛方法virtual與抽象方法abstract【重寫new  覆寫override  重載overload】

　　　　虛方法能夠在父類中默認實現，抽象方法不能在父類中實現，虛方法能夠在子類中覆寫也能夠不覆寫，抽象方法必須在子類中覆寫。virtual、abstract、override能夠一直覆寫，不想被覆寫，方法名前加sealed（密封：斷子絕孫）  base.()  調用直接父類的方法     this.()指定當前這個類型的實例的方法，this只能放在實例方法中，在子類構造函數中的this.屬性，該屬性是父類中的屬性，除非在子類中重寫new此屬性，若是重寫this指的是此類中的屬性。