譯：C#面向對象的基本概念 (Basic C# OOP Concept) 第三部分（多態，抽象類，虛方法，密封類，靜態類，接口）

時間 2019-11-06

標籤 c# 面向對象基本概念 basic oop concept 第三部分抽象方法密封靜態接口欄目 C# 简体版

原文原文鏈接

9.多態web

Ploy的意思就是多於一種形式。在文章開始，方法那一章節就已經接觸到了多態。多個方法名稱相同，而參數不一樣，這就是多態的一種。編程

方法重載和方法覆蓋就是用在了多態。多態有2中類型，一種是編譯時多態，一種是運行時多態。ide

方法重載：測試

方法重載就是，多個方法擁有相同的方法名稱，而參數個數或類型不一樣。this

下面就是一個多態的例子，能夠看到方法名稱「BedRoom」被用到了2個方法中，就是2個方法有共同的方法名稱"BedRoom",可是2個方法的參數是不一樣的。spa

 1 class HouseOwnerClass
 2     {
 3         //Function with parameter
 4         public void BedRoom(String nameandColor)
 5         {
 6             Console.WriteLine(nameandColor);
 7         }
 8 
 9         // Same Function Name with Different Paramenter
10         public void BedRoom(String MemberName, String Color)
11         {
12             Console.WriteLine(MemberName + " Like " + Color + "Color");
13         }
14 
15         static void Main(string[] args)
16         {
17             HouseOwnerClass objHouseOwner = new HouseOwnerClass();
18             
19             objHouseOwner.BedRoom("My Name is Shanu I like Lavender color");
20             objHouseOwner.BedRoom("My Name is Afraz I like Light Blue color");
21             objHouseOwner.BedRoom("SHANU", "Lavender");
22             Console.ReadLine();
23 
24         }
25     }

方法覆蓋：rest

方法重載和方法覆蓋的不一樣就是在於方法重載方法有相同的方法名稱而參數不一樣。可是在方法覆蓋中方法不只有相同的方法名稱，並且參數必須相同，返回值類型也相同。方法覆蓋只能用在派生類中。後面的章節咱們就會看到方法重載和抽象方法，虛方法，密封方法之間的關係。code

10.抽象類/方法orm

抽象類：抽象類就是給一個類前面加上"abstract"對象

abstract class GuestVist
    {
    }

抽象類是一個超級類。抽象類不可以被對象所訪問，換句話說，抽象類是不能被實例化的。不能建立抽象類的對象。
那麼咱們建立一個抽象類的對象會怎麼樣呢？

抽象類能夠包涵抽象方法和非抽象方法。在抽象類中至少要申明一個抽象方法。總而言之，派生類必須重寫（override上面說的覆蓋）抽象類非抽象方法。看下面的代碼編譯圖片，會出現錯誤，意思是派生類必須實現父類的全部抽象方法。

下面咱們看一個具體的例子來詳細瞭解抽象方法。

 1 abstract class GuestVist
 2     {
 3          public void Guestwelcomemessage()
 4          {
 5              Console.WriteLine("Welcome to our AbstractHome");
 6          }
 7          public void GuestName()
 8          {
 9              Console.WriteLine("Guest name is: Abstract");
10          }
11          public abstract void purposeofVisit();
12 
13     }
14 // derived class to inherit the abstract class
15 public class Houseclass : GuestVist
16     {
17          static void Main(string[] args)
18          {
19              Houseclass objHouse = new Houseclass();
20              objHouse.Guestwelcomemessage();
21          }
22 
23          public override void purposeofVisit()
24          {
25              Console.WriteLine("Abstract just came for a Meetup and spend some time ");
26          }
27     }

在這個例子中咱們能夠看到在一個抽象類中，有普通的非抽象方法，和抽象方法。抽象類中，至少要有一個抽象方法。

11.虛類/方法

咱們平常編程中虛方法是很是重要的。

那麼什麼是虛方法，咱們要怎樣使用虛方法呢？

繼續咱們的House示例：加入今天一共有5我的要來家裏作客。那麼咱們寫一個方法來顯示5個客人要來訪的信息。可是客人來的時候咱們才發現來了20我的。通常狀況下，當他們來以前，咱們會知道來的人數增長仍是減小。

在這種狀況下，guest是一個獨立的類，House 是另一個類。爲了避免改變guest類裏面的信息，咱們要怎麼經過派生類去改變數據呢？

抽象方法和虛方法有什麼不一樣點？

兩個都是用在覆蓋重寫方法的關鍵字。抽象方法只能被申明在抽象類裏面。意思就是，抽象方法只能在抽象類中申明，而不能在抽象類中實現。然而虛方法可以實現。

看下面的程序：裏面既有抽象方法又有虛方法。在抽象類中，虛方法裏面說只有5個客人。可是在派生類中，該虛方法被override，說有20個客人。看下面的輸出，結果會是虛方法裏面的嗎？究竟是5個客人仍是20個客人？測試一下便知。

 1 abstract class GuestVist
 2     {
 3         public void Guestwelcomemessage()
 4         {
 5             Console.WriteLine("Welcome to our AbstractHome");
 6         }
 7         public void GuestName()
 8         {
 9             Console.WriteLine("Guest name is: Abstract");
10         }
11         public abstract void purposeofVisit();  // Abstract Method 
12         public virtual void NoofGuestwillvisit()  // Virtual Method
13 
14         {
15             Console.WriteLine("Total 5 Guest will Visit your Home");
16         }
17     }
18     class AbstractHouseClass : GuestVist
19     {
20         public override void purposeofVisit()  // Abstract method Override
21         {
22             Console.WriteLine("Abstract just for a Meetup and spend some time ");
23         }
24 
25        public override void NoofGuestwillvisit() // Virtual method override
26         {
27             Console.WriteLine("Total 20 Guest Visited our Home");
28         }
29 
30         static void Main(string[] args)
31         {
32             AbstractHouseClass objHouse = new AbstractHouseClass();
33             objHouse.Guestwelcomemessage();
34             objHouse.purposeofVisit();
35             objHouse.NoofGuestwillvisit();
36             Console.ReadLine();
37         }
38 }

結果是20個客人。

12.密封類/方法

密封類：指的是這個類不可以被其餘的類所繼承，就是該類不能有派生類。

繼續看House示例。在一個房子裏，主人有一個私密的小房間，多是辦公或者藏保險櫃之類的~~哈哈密封類就用到了這裏。、

密封類的聲明用關鍵字 sealed，一旦有類被聲明爲sealed那麼其餘的派生類就不可以繼承該類。

那麼派生類繼承了sealed類會發生什麼？看代碼：

下面是一個完整的sealed類代碼：

 1 public sealed class OwnerofficialRoom
 2     {
 3         public void AllMyPersonalItems()
 4         {
 5             Console.WriteLine("All Items in this rooms are personal to me no one else can access or inherit me");
 6         }
 7     }
 8     class HouseSealedClass 
 9     {
10         static void Main(string[] args)
11         {
12             OwnerofficialRoom obj = new OwnerofficialRoom();
13             obj.AllMyPersonalItems();
14             Console.ReadLine();
15         }
16     }

密封方法：若是咱們聲明一個密封方法，那麼這個方法比較特殊，不可以被派生類重寫（overrid）。

看house示例：類裏面有虛方法和密封的虛方法。普通的虛方法可以被派生類重寫，可是sealed虛方法不可以被派生類重寫。

 1 //Base Class with Sealed Method
 2     public class OwnerOfficialroomwithrestriction
 3     {
 4         public virtual void message()
 5         {
 6             Console.WriteLine("Every one belongs to this house can access my items in my room except my sealed Item");
 7 
 8         }
 9 
10         public virtual sealed void myAccountsLoocker()
11         {
12             Console.WriteLine("This Loocker can not be inherited by other classes");
13         }
14     }
15     //Deraived method which inherits Selaed Method class
16     class HouseSealedClass : OwnerOfficialroomwithrestriction
17     {
18         public override void message()
19         {
20             Console.WriteLine("overrided in the derived class");
21         }
22       
23         public override void myAccountsLoocker()
24         {
25             Console.WriteLine("The sealed method Overrides");
26         }
27 }

13.靜態類/方法
已經討論了密封類。下面來看看靜態類和靜態方法。

靜態類和密封類同樣都不可以被繼承。

那麼靜態類和派生類有何不一樣？

咱們能夠實例化密封類，在密封類章節能夠看到我在main方法裏面建立了一個對象來訪問密封類。在密封類裏，能夠既有靜態方法又有非靜態方法。

可是靜態類不可以被實例化，就是不可以建立靜態類的對象。在靜態類裏只能存在靜態成員。

main方法就是一個靜態方法。當咱們建立一個控制檯應用程序的時候，會看到每一個類都有一個main方法。這篇文章前面說過，main方法是最最最早被執行的。由於main方法被聲明爲static，因此不須要被實例化。

static void Main(string[] args)
        { 
        }

有趣兒的是，靜態方法，靜態變量等在程序一開始執行就會分配相應的內存，而非靜態的是在被實例化的時候分配內存的。

咱們把密封類的例子修改爲靜態類的例子來看一下：

派生類繼承靜態類會發生什麼？

咱們在靜態類中聲明非靜態方法又會怎樣呢？

咱們建立一個靜態類的示例又會怎樣呢？

運行程序會報錯"Can not create an instance of a static class" 意思是不可以對靜態類實例化，即不能建立靜態類的對象。用的vs是韓版的so看到的是韓文。

那麼不可以建立靜態類的對象，咱們改如何調用靜態類裏的方法和變量呢？

很簡單，只須要用類名.方法名就能夠了。看代碼：

 1 public static class OwnerofficialRoom
 2     {
 3         public static void AllMyPersonalItems()
 4         {
 5             Console.WriteLine("All Items in this rooms are personal to me no one else can access or inherit me");
 6         }
 7        
 8     }
 9 
10     class HouseStaticClass 
11     {
12         static void Main(string[] args)
13         {
14             OwnerofficialRoom.AllMyPersonalItems();
15             Console.ReadLine();
16 
17         }
18     }

輸出以下圖：

能不能再非靜態類中建立靜態方法呢？yes

在非靜態類裏建立靜態方法，和上面的調用方式同樣，不須要對象去調用，直接用類名就能夠了。

看下面的代碼：

 1 public  class OwnerofficialRoom
 2     {
 3         public static void AllMyPersonalItems()
 4         {
 5             Console.WriteLine("No need to create object for me just use my class name to access me :)");
 6         }
 7 
 8         public void non_staticMethod()
 9         {
10             Console.WriteLine("You need to create an Object to Access Me :(");
11         }
12 
13 
14     }
15 
16     class StaticmethodClass
17     {
18         static void Main(string[] args)
19         {
20             // for statci method no need to create object just call directly using the classname.
21             OwnerofficialRoom.AllMyPersonalItems();
22             
23             // for non-static method need to create object to access the method.
24             OwnerofficialRoom obj = new OwnerofficialRoom();
25             obj.non_staticMethod();
26             Console.ReadLine();
27 
28         }
29     }

輸出結果：

14.接口

接口和抽象類很類似，可是在接口裏面只能存在方法的聲明。而在抽象類中既能夠聲明方法，也能夠實現方法。

看代碼：

 1 interface GuestInterface
 2     {
 3         void GuestWelcomeMessage();
 4         void NoofGuestes();
 5     }
 6     interface FriendsandRelationsInterface
 7     {
 8         void friendwelcomemessage();
 9         void FriendName();
10     }
11    
12     class HouseOwnerClass : GuestInterface, FriendsandRelationsInterface
13     {
14         public void GuestWelcomeMessage()
15         {
16             Console.WriteLine("All guests are well come to our home");
17         }
18 
19         public void NoofGuestes()
20         {
21             Console.WriteLine("Total 15 Guestes has visited");
22         }
23 
24         public void friendwelcomemessage()
25         {
26             Console.WriteLine("Welcome to our Home");
27         }
28         public void FriendName()
29         {
30             Console.WriteLine("Friend  name is: Afraz");
31         }
32         static void Main(string[] args)
33         {
34             HouseOwnerClass obj = new HouseOwnerClass();
35             obj.GuestWelcomeMessage();
36             obj.NoofGuestes();
37             obj.friendwelcomemessage();
38             obj.FriendName();
39             Console.ReadLine();
40         }
41     }

看結果：

有時候咱們肯定有些方法派生類中要用，可是每一個派生類對該方法的需求不一樣，那麼就可使用接口，把該方法寫到接口裏面，讓每一個派生類本身去實現本身的需求。

在抽象類中，能夠有抽象方法也能夠有非抽象方法。可是接口裏的全部方法都被默認爲抽象方法，全部在接口中聲明的方法，在派生類中都必須實現。

一個接口的代碼：

 1 interface GuestInterface
 2     {
 3         void GuestWelcomeMessage();
 4         void NoofGuestes();      
 5     }
 6     class HouseOwnerClass: GuestInterface
 7     {
 8         public  void GuestWelcomeMessage()
 9         {
10             Console.WriteLine("All guests are well come to our home");
11         }
12 
13         public  void NoofGuestes()
14         {
15             Console.WriteLine("Total 15 Guestes has visited");
16         }
17 
18         static void Main(string[] args)
19         {
20             HouseOwnerClass obj = new HouseOwnerClass();
21 
22             obj.GuestWelcomeMessage();
23             obj.NoofGuestes();
24             Console.ReadLine();
25         }
26     }