.NET C#基礎（7）：介面 - 人如何和貓互動

来源:https://www.cnblogs.com/HiroMuraki/archive/2022/06/10/16361278.html
-Advertisement-
Play Games

0. 文章目的 面向有一定基礎的C#初學者，介紹C#中介面的意義、使用以及特點。 1. 閱讀基礎 瞭解C#基本語法（如定義一個類、繼承一個類） 理解OOP中的基本概念（如繼承，多態） 2. 什麼是介面 2.1 現實中的協定與介面 貓貓頭在整理電腦文件，需要一個小工具來分類文件，於是貓貓頭向群里求助： ...


0. 文章目的

  面向有一定基礎的C#初學者，介紹C#中介面的意義、使用以及特點。

 

1. 閱讀基礎

  瞭解C#基本語法（如定義一個類、繼承一個類）

  理解OOP中的基本概念（如繼承，多態）

 

2. 什麼是介面

2.1 現實中的協定與介面

  貓貓頭在整理電腦文件，需要一個小工具來分類文件，於是貓貓頭向群里求助：

  “有沒有小伙伴幫我用Objective-C做一個分類文件的小工具”

  群里沒有人回答，貓貓頭意識到可能是因為會Objective-C的人比較少，於是改問：

  “有沒有小伙伴幫我用Rust做一個分類文件的小工具”

  群里依然沒有人回答，貓貓頭意識到可能是會Rust的人比較少，但貓貓頭此時還意識到，自己只是需要獲一個可以分類文件的小工具，用什麼語言好像並不重要。於是，貓貓頭想了一下，改問：

  “有沒有小伙伴可以幫我做一個分類文件的小工具”

  很快，群里有人用Shell幫貓貓頭寫了一個小工具，貓貓頭用小工具很快完成了任務。

 

  上述例子中，貓貓頭在請求幫助時，給出了一個可以幫忙上的‘前提’，即可以提供一個可以分類文件的小工具，而通過這個前提，貓貓頭的朋友知道如何幫助貓貓頭。我們將這種用於指示兩個實體之間（比如貓貓頭和TA的朋友之間）如何交互的‘前提’稱之為‘協定’。

  協定的最大意義在於規範了不同物件間的交互方式，一個物件如果想要知道如何與另一個物件交互，只需要瞭解與該物件交互所需要遵守的協定，而不需要考慮該物件的具體情況。就像貓貓頭只需要一個能分類文件的小工具，而幫忙的朋友到底如何實現這個小工具其實並無所謂。

  而現實中所謂的介面就是一種協定，例如設備的USB充電介面，任何只要滿足USB規範的連接線都可以接入其充電介面併為其供電，而至於電從哪裡來設備本身並不關心。介面是使物件得以模塊化的重要概念，介面定義了一種‘只要滿足即可交互’的規範，這可以極大程度上降低物件之間的耦合。

  對於編程語言來說，介面的主要作用也是用於為各個模塊之間做出協定，通過協定，模塊之間知道如何進行交互，而不需要為各種模塊進行特別編碼，以此可以最大程度減小模塊間的耦合度。

2.2 繼承與抽象類

（1）基石：繼承與多態

  在具體討論介面是什麼之前，需要先知道介面最早的樣子是什麼。首先我們定義一個Animal類，定義一個名為MakeSound的虛方法：

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("make some noise");
    }
}

  接下來從Animal派生出兩個類，並重寫其MakeSound方法：

class Cat
{
    public override void MakeSound()
    {
        Console.WriteLine("meow meow");
    }
}

class Dog
{
    public override void MakeSound()
    {
        Console.WriteLine("woof woof");
    }
}

  由於Cat與Dog繼承自Animal，因此像下麵這樣代碼是可以使用的：

void Pet(Animal animal)
{
    animal.MakeSound(); 
}

Cat cat = new Cat();
Pet(cat);

Dog dog = new Dog();
Pet(dog);

（會輸出meow meow與woof woof）

  Animal類中定義了MakeSound方法，因此其肯定有一個MakeSound方法可以調用，而Cat與Dog都是Animal的子類，因此兩者也肯定有一個MakeSound方法可以調用，所以上述代碼是安全的。當調用時，由於多態，上述代碼會輸出‘meow meow’與‘woof woof’。

（2）進一步抽象

  上面的代碼中，Animal對MakeSound方法的定義的唯一意義在於保證了其有一個名為MakeSound的方法可以調用，而上文的Pet方法里調用Animal對象的MakeSound方式時，因為多態，實際調用的是Cat與Dog中重寫MakeSound的方法。也就是說，Animal如何實現MakeSound方法並不重要，因此完全可以不提供Animal中MakeSound方法的實現：

class Animal
{
    public virtual void MakeSound()
    {
        // 方法實現並不重要
    }; 
}

  然後另一方面，很多時候我們希望調用的MakeSound方法能做一些有意義的事，這就需要繼承自Animal的類都重寫該方法，所以我們可能還希望可以在編碼時要求Animal的子類重寫其MakeSound方法。

  C#提供了實現上述需求的方法，在C#中，有一種特殊的類叫做抽象類（abstract class），這種類不允許實例化，並且允許定義一種被稱為抽象方法（abstarct method）的方法，抽象方法指的是在當前類中不提供實現，轉而由子類提供實現的方法。下麵是將Animal類轉化為抽象類的示例：

abstract class Animal
{
    public abstract void MakeSound(); // 抽象方法不需要也不能提供方法實現，實現由子類完成
}

  （在class關鍵字前添加abstract可將類定義為抽象類，為方法添加abstract修飾符可將方法定義為抽象方法）

  現在，繼承自Animal類的類型都必須重寫其抽象方法MakeSound了，重寫抽象方法和重寫一般的虛方法一致：

class Cat
{
    public override void MakeSound()
    {
        Console.WriteLine("meow meow");
    }
}

class Dog
{
    public override void MakeSound()
    {
        Console.WriteLine("woof woof");
    }
}

  使用上也沒有什麼區別：

void Pet(Animal animal)
{
    animal.MakeSound(); 
}

Cat cat = new Cat();
Pet(cat);

Dog dog = new Dog();
Pet(dog);

  不知道看到這裡你是否意識到了什麼：Animal類保證了其子類有一個MakeSound方法可以被調用，所以Pet方法可以假定所有Animal的子類都有一個MakeSound方法，因此可以安全調用。也就是說，Animal類向外保證了其子類必然有一個MakeSound方法可以調用，而繼承自Animal的Cat與Dog類都實現了Animal對外的保證。

（3）介面

  再進一步來看，其實Pet方法中只需要對象可以提供MakeSound方法即可，至於對象的類型是否與Animal之間存在‘IS-A’關係並不重要，也就是說，對Pet方法來說只要對象可以‘保證’有一個MakeSound方法可以調用即可。現在我們將這一保證抽象出來，並用一個語義更清晰的類名來指代這種保證：

abstract class CanMakeSound
{
    public abstract void MakeSound();
}

  再進一步，在語言層面上提供語法支持來將其與抽象類區分開（定義為一個‘保證’，而不是一個類），我們使用interface來表示這一保證：

interface CanMakeSound
{
    public abstract void MakeSound();
}

  由於這隻是一種保證，所有裡面的方法都只是一種協定（表示有某個方法可以調用），因此方法只需要方法簽名即可（返回類型+方法名+參數列表），另外，既然是‘對外保證’可以調用某一方法，那麼方法也應該是public的，所以可以預設所有的方法聲明都是public的抽象方法：

interface CanMakeSound
{
    void MakeSound();
}

  這樣，通過一步步對抽象類的提煉，我們提出了介面（interface）的這一概念，在簡化語法的同時，CanMakeSound提供的‘保證’也有了更明確的語義。

  這就是介面的本質：協定行為，指明‘可以做什麼’，即‘CAN-DO’。介面是一個概念，不同的語言對介面概念的實現方式不同，例如C#為介面提供了語言級的支持，而一些沒有為介面提供語言級支持的編程語言也可以通過上述的抽象類來模擬介面，例如C++，另一方面，C#中的介面其實也可以視為一種特殊的抽象類。

  不過在繼續之前，我們來看看如果C#沒有對介面的支持將會是什麼樣。在上述例子中我們一開始用抽象類來模擬介面，由於C#不支持多重繼承，因此無法同時實現多個抽象類，如果要表示實現多個‘介面’就不得不一層一層繼承下去，這會使編碼變得複雜以至於難以維護：

abstract class Walkable { ... }
abstract class Flyable { ... }

class WalkableCat : Walkable { }
class WalkableAndFlyableCat : Flyable { }
class SuperCat : WalkableAndFlyableCat { }

  上述代碼中SuperCat使用了兩個輔助類WalkableCat和WalkableAndFlyableCat才得以同時實現Walkable與Flyable，甚至概念上來說SuperCat只是WalkableAndFlyableCat的子類，而不是有‘可以做什麼’的保證，語義上也缺乏清晰度。因此，C#將介面視為一種專門的類型，並提供語言級的支持是很有必要的。

 

3. C#中的介面

3.1 定義介面

  要在C#中定義一個介面，需要使用interface關鍵字，併在介面中定義協定的方法，下麵是一個介面定義：

interface IFlyable
{
    void Fly();
}

（根據C#的編碼建議，介面命名應該以大寫字母I開頭）

  上述代碼中，介面IFlyable協定了實現該介面的的類型都會有一個Fly方法可以調用，你可以把它想象成下麵這樣的抽象類：

abstract class IFlyable
{
    public abstract void Fly();
}

  對比兩者，可以發現定義介面時除了將abstract class替換為了interface外，對方法也沒有用public與abstract修飾，這一原因在前文已經提及過：由於介面本身就是用於對外協定行為，因此介面協定的方法自然應該是可以被外部訪問的public，同時介面中的方法只是提供一種協定，因此無需提供實現。

  當然，一個介面中可以協定多個方法：

interface IFlyable
{
    void Prepare();
    void Fly();
}

  但是，介面中不能定義欄位：

interface IFlyable
{
    string Name; // 不允許定義欄位
}

  這是由於介面的作用是協定行為，而所謂的行為就是方法。但是，你可以在介面中定義屬性甚至事件：

interface IFlayable
{
    event Action Prepared;
    string Name { get; set; }
    string this[int index] { get; set; } // 索引器也是屬性（有參數性）
}

  這是由於屬性本質上是方法，事件本質上是對多播委托的方法封裝，因此上面介面定義的實際含義如下：

interface IFlayable
{
    // event Action Prepared;
    void add_PreparedHandler(Action action);    // 註冊委托
    void remove_PreparedHandler(Action action); // 取消註冊委托
    
    // string Name { get; set; }
    string get_Name();         // 獲取Name屬性
    void set_Name(string val); // 設置Name屬性
    
    // string this[int index] { get; set; }
    string get_Item(int index);           // 獲取Item屬性
    void set_Name(int index, string val); // 設置Item屬性
}

3.2 使用介面

3.2.1 實現介面

  介面定義後，就可以讓類型去實現了。要讓一個類型實現介面很簡單，只需要‘繼承’該介面，然後實現該介面中協定過的方法即可，例如下麵用SuperCat實現IFlyable介面：

interface IFlyable
{
    void Fly();
}

class Cat { }
class SuperCat : Cat, IFlayable
{
    public void Fly()
    {
        Console.WriteLine("Flying");
    }
}

  上述代碼中特地讓SuperCat繼承自Cat類，只是為了說明實現一個介面的語法和繼承一個類型的語法相似，並且介面的位置要位於基類之後，所以下麵這樣是不行的：

class SuperCat : IFlayable, Cat { } // 錯誤，基類要在介面位置之前

  實現介面的方法時只需要保證方法簽名相同（返回類型+方法名+參數列表），而方法本身可以添加async、unsafe等方法修飾符，因此下麵SuperCat中的Fly方法也可以實現IFlyable：

class SuperCat : Cat, IFlayable
{
    public unsafe async void Fly()
    {
        Console.WriteLine("Flying");
    }
}

  另外，與繼承類最大的不同在於，類型可以實現多個介面，只實現了各個介面協定的方法即可：

// SuperCat繼承自Cat
class SuperCat : Cat, IFlyable, IWalkable, ISoundMaker
{ 
	// 實現IFlyable
	// 實現IWalkable
	// 實現ISoundMaker
}

3.2.2 調用介面

  可以像使用抽象類引用一樣使用介面引用，如下麵使用IFlyable：

void Call(IFlyable flyable)
{
    flyable.Fly(); // IFlyable介面協定了實現該介面的方法都有一個Fly方法可以調用
}

SuperCat superCat = new SuperCat();
Call(superCat);

  簡而言之，將介面視為一個抽象類使用即可。

3.3 進階介面操作

3.3.1 介面“繼承”

  介面與介面之間也可以繼承，例如：

interface IMachine
{
    void Launch();
}

interface IGameConsole : IMachine
{
    void PlayGame();
}

  上述代碼中IGameConsole介面“繼承”了IMachine介面，這意味著實現IGameConsole介面時除了要實現其協定的PlayGame方法外，也需要實現IMachine介面中協定的Launch方法：

class Xbox : IGameConsole
{
    public void Launch() { ... }   // IMachine協定的Launch方法
    public void PlayGame() { ... } // IGameConsole協定的PlayGame方法
}

  之所以要為“繼承”添加引號，是因為介面間的繼承行為從概念上來說應該稱為‘組合’，也就是說，IGameConsole並不是繼承了IMachine介面，而是對IMachine介面進行了組合。請記住這個概念，在後文中會提及原因。

3.3.2 顯式實現介面

  有時候多個介面協定的方法之間可能存在衝突，例如：

interface IGameConsole
{
    void Launch(); // 啟動游戲
}

interface IMachine
{
    void Launch(); // 啟動機器
}

class Xbox : IGameConsole, IMachine
{
    public void Launch() { ... } // 只能定義一個Launch
}

  上述代碼中的介面IGameConsole與IMachine都協定了一個Launch方法，然而兩個Launch方法所做的事並不一樣，因此需要分別對其進行實現。但顯然你只能定義一個Launch方法。要解決此類問題，就需要顯式實現介面。以上述情況為例，顯式實現介面的方法如下：

class Xbox : IGameConsole, IMachine
{
    void IGameConsole.Launch() { ... } // 實現IGameConsole的Launch
    void IMachine.Launch() { ... }     // 實現IMachine的Launch
}

  有兩個需要點需要關註：

  1. 顯式實現的方法沒有訪問修飾符
  2. 顯式實現的方法名為介面名.方法名

  由於顯式實現的方法沒有訪問修飾符，意味著其訪問許可權是預設的private，外部無法直接調用，但可以通過介面引用來調用相應的方法：

XBox xbox = new XBox();
// xbox.GetInformation(); // 不能直接調用

IGameConsole console = xbox;              // 使用IGameConsole引用
ConsoleInfo a = console.GetInformation(); // 調用Xbox中的IGameConsole.GetInformation

IMachine machine = xbox;                  // 使用IMachine引用
MachineInfo b = machine.GetInformation(); // 調用Xbox中的IMachine.GetInformation

  另外，對於類內部來說，也需要使用介面引用來調用：

class Xbox : IGameConsole, IMachine
{
    void IGameConsole.Launch() { ... } // 實現IGameConsole的Launch
    void IMachine.Launch() { ... }     // 實現IMachine的Launch
    
    void Test()
    {
        IGameConsole console = this;   // 使用介面引用調用IGameConsole的Launch方法
        console.Launch();
    }
}

  順便一提，由於要通過介面引用來調用方法，因此對值類型來說此時將會面臨裝箱問題。一般情況下，應該儘可能選擇預設的實現方式（即通過定義方法簽名相同的方法）而非顯式實現。

  現在回過頭來談論一下為什麼介面之間的“繼承”實際是‘組合’，還是對於下述列子：

interface IMachine
{
    void Launch(); // 這個Launch用來啟動機器
}

interface IGameConsole : IMachine
{
    void Launch(); // 這個Launc用來啟動游戲
}

class Xbox : IGameConsole
{
    void IGameConsole.Launch() { ... }
    void IMachine.Launch() { ... }
}

  你應該很快能理解上述代碼的意圖：IGameConsole組合了IMachine介面，Xbox實現IGameConsole介面，並顯式實現了兩個GetInformation方法。如果介面之間是繼承，那麼上述代碼從概念上說不通：IGameConsole繼承自IMachine，然後重寫了其同名的Launch方法，然而我們在實現介面的時候卻分別實現了IMachine和IGameConsole的Launch方法，那麼IGameConsole到底繼承了IMachine什麼？另一方面來講，協定的行為又如何用繼承關係描述？總不能說‘可以啟動游戲’繼承了‘可以開機’吧。因此，應當認識到介面之間的“繼承”實質是組合，即將協定進行組合。

3.3.3 介面方法的預設實現

  儘管介面協定的方法預設是抽象方法，但是你確實可以在介面中為協定的方法提供實現，這種方法被稱為預設介面方法：

interface IGameConsole
{
    void Launch()
    {
        Console.WriteLine("Launched");
    }
}

class Xbox : IGameConsole
{
    // 此時不需要為IGameConsole協定的Launch方法提供實現
}


Xbox xbox = new Xbox();
        
// 由於Launch方法在Xbox中沒有聲明為public，因此需要通過介面引用來調用
IGameConsole console = xbox;
console.Launch();

（輸出：Launched）

  實現介面時可以不實現介面中提供了預設實現的方法，但是由於方法沒有在實現該介面的類型中定義為public，因此此時該方法對外部來說無法訪問，此時則同樣需要通過介面引用來調用相應方法。另外，不必擔心兩個介面的預設實現出現衝突，如下：

interface IGameConsole
{
    void Launch()
    {
        Console.WriteLine("GameConsole Launched");
    }
}

interface IMachine
{
    void Launch()
    {
        Console.WriteLine("Machine Launched");
    }
}

class Xbox : IGameConsole, IMachine
{

}

  這是因為如果XBox沒有實現IGameConsole與IMachine的Launch方法，那麼外部要使用這兩個介面協定的方法就只能通過介面引用，那麼這時候顯然可以明確要調用的方法：

Xbox xbox = new Xbox();

IGameConsole console = xbox;
console.Launch(); // IGameConsole預設實現的Launch

IMachine machine = xbox;
machine.Launch(); // IMachine預設實現的Launch

  此外，如果對介面組合時出現方法衝突，編譯器會給出警告，此時可以使用new關鍵字來抑制警告：

interface IMachine
{
    void Launch()
    {
        Console.WriteLine("Machine Launched");
    }
}

interface IGameConsole : IMachine
{
    new void Launch() // new的含義是：本類型中與基類中相似簽名的成員沒有關係
    {
        Console.WriteLine("GameConsole Launched");
    }
}

（同樣此時只能通過介面引用來調用介面方法，因此也不會出現衝突）

  最後，如果類型中實現了介面的預設方法（無論是預設實現還是顯式實現），那麼就會覆蓋預設實現：

interface IGameConsole
{
    void Launch()
    {
        Console.WriteLine("Launched");
    }
}

class Xbox : IGameConsole
{
    public void Launch() // 實現IGameConsole的Launch方法
    {
        Console.WriteLine("Xbox Launched");
    }
}

Xbox xbox = new Xbox();

IGameConsole console = xbox;
console.Launch(); // 此時調用的是Xbox中定義的Launch

（上述代碼輸出‘Xbox Launched’）  

  然而，不推薦使用介面預設實現，因為介面本身應該只提供協定功能，一般情況下如果需要有預設實現更應該考慮使用基類而不是介面，或者定義一個實現了該介面的類，併在這個類中提供實現：

interface IGameConsole { ... }

class GameConsoleBase : IGameConsole { ... }

  通常真正需要預設實現的場合是需要更新某個介面，但又不希望影響之前已經使用了該介面的代碼。

3.3.4 為介面添加靜態方法

  你可以在介面中定義靜態方法：

interface IFoo 
{
    static void Hello() 
    {
        Console.WriteLine("Hello");
    }
}

  其使用和使用一般類的靜態方法沒有區別：

IFoo.Hello();

  靜態方法不屬於介面的協定，因此實現介面時不需要實現介面中的靜態方法，你可以把介面中的靜態方法理解為一個由該介面管理的方法。不過，C#目前有一項預覽功能，可以像協定普通方法一樣協定靜態方法，這在後文會提到。

3.3.5 指定介面成員的訪問修飾符

  介面成員預設的訪問修飾符為public，但你可以指定為其他修飾符：

interface IFoo 
{
    private void PrivateMethod()      // private訪問限制，必須提供預設實現
    {
        Console.WriteLine("Require defualt Implement");
    }
    
    protected void ProtectedMethod(); // protected訪問限制，可在組合了該介面的介面中使用
    
    internal void InternalMethod();   // internal訪問限制，同一程式集範圍內可用
    
    public void PublicMethod();       // pubilc訪問限制，預設的訪問限制
    
    // ... 還有一些很少用的組合訪問修飾符，這裡就不提了
}

  而當訪問限製為private時，由於這個方法只能用在介面內部訪問，無法在介面外為其提供實現，所以必須為其提供預設實現，通常private訪問級別是用於實現預設介面方法的輔助方法。另外再特別說明一下訪問限製為protected時的情況。當介面中協定的方法的訪問限製為protected時，如果要實現該方法，則必須顯式實現，否則不會被視為該方法的實現：

class Foo : IFoo
{
    void IFoo.ProtectedMethod() { ... }      // 顯式實現IFoo中的ProtectedMethod
    
    protected void ProtectedMethod() { ... } // 只是定義了一個ProtectedMethod方法而已，與介面無關
}

  另外，由於你只是‘實現’了該介面而不是‘繼承’了該介面，所以你也無法調用其方法：

class Foo : IFoo 
{
    void IFoo.ProtectedMethod() { ... }

    void Test()
    {
        IFoo foo = this;
        foo.ProtectedMethod(); // Foo和介面IFoo之間不是繼承關係，無法調用
    }
}

  這類方法只能在組合該介面的介面中調用：

interface IFoo 
{
    protected void ProtectedMethod();
}

interface Foo2 : IFoo 
{
    void DoSomething() 
    {
        ProtectedMethod(); // 可以訪問IFoo中的ProtectedMethod方法
    }
}

  你可能覺得這種既不能被外部訪問也不能被內部訪問的方法沒什麼用，不過下麵是一個使用例子：

查看代碼 
interface ISpeaker
{
    protected void Say(); // protected訪問許可權，只能在介面內以及組合了該介面的介面內使用
}

interface IRepeater : ISpeaker // IRepeater組合了ISpeaker
{
    void Repeat() // Repeat的預設實現，調用三次ISpeaker協定的Say方法
    {
        Say();
        Say();
        Say();
    }
}

class HelloRepeater : IRepeater
{
    void ISpeaker.Say() // 顯式實現了ISpeaker中協定訪問等級為protected的Say方法
    {
        Console.WriteLine("Hello!");
    }
}

class WorldRepeater : IRepeater
{
    void ISpeaker.Say() // 顯式實現了ISpeaker中協定訪問等級為protected的Say方法
    {
        Console.WriteLine("World!");
    }
}



void CallRepeater(IRepeater speaker)
{
    speaker.Repeat();
}

CallRepeater(new HelloRepeater());
CallRepeater(new WorldRepeater());

（輸出三次Hello!與三次World!）   

  儘管如此，通常來說訪問級別為protected的介面方法確實沒什麼明顯的作用，但在一些特殊的情況下可能對於封裝和修改現有系統有幫助。

3.4 特殊介面

3.4.1 泛型介面

  可以聲明一個泛型介面：

interface IDataObject<T>
{
    T GetData();
}

  上面定義了一個泛型介面IDataObject<>，泛型介面並不神秘，就如可以像理解抽象類一樣去理解介面，同樣可以用理解泛型類的方式去理解泛型介面，由於泛型不是本文重點故不多做闡述。不過，為了提高泛型介面的實用性，泛型介面還支持將類型參數聲明為協變數或逆變數，關於協變與逆變在另一篇文章里有所闡述，這裡也不再贅述。

3.4.2 協定靜態成員的介面

  前文提到過介面允許協定靜態成員，但截至目前這是C#的一項預覽功能，需要在項目的csproj配置文件中向PropertyGroup添加EnablePreviewFeatures以啟用語言的預覽功能：

<EnablePreviewFeatures>True</EnablePreviewFeatures>

  一個協定了靜態方法的介面如下（註意由於介面中本身可以定義靜態方法，所以需要添加abstract關鍵字來指示其為抽象方法）：

interface IGameConsole
{
    static abstract void PrintInfo();
}

  以及一個實現該介面協定的靜態方法的類：

class Xbox : IGameConsole
{
    public static void PrintInfo()
    {
        Console.WriteLine("A famous game console");
    }
}

  咋一看好像協定靜態方法的意義不大，因為調用靜態方法需要直接使用類型名，無法通過介面引用來調用。但是，考慮以下代碼：

interface IAddable<T> where T : IAddable<T>
{
    static abstract T operator +(T left, T right);
}


class Math<T> where T : IAddable<T>
{
    public static T Add(T left, T right)
    {
        return left + right;
    }
}

  由於運算符重載的本質是定義一個靜態方法，因此協定靜態方法意味著可以對類型允許使用的運算符進行協定，意味著可以在泛型中假定泛型類型可以進行+-*/等運算，這對於泛型約束來說非常有用，要知道在相當的一段時間里C#是沒有辦法假定泛型類型可以使用運算符的。需要說明的是你可能註意到上述代碼中泛型介面IAddable<>的 類型參數T的泛型約束是where T : IAddable<T>，看起來有點彆扭，這是因為運算符重載要求其參數類型至少有一個是當前類型，因此需要T是IAddable<T>類型（即自己）。

 

4. 介面雜談

4.1 介面在繼承鏈中的傳遞

  首先定義一個介面，基類以及其子類：

interface IGameConsole
{
    public void Launch();
}

class Xbox : IGameConsole
{
    public void Launch()
    {
        Console.WriteLine("Xbox Launched!");
    }
}

class XboxOne : Xbox { }

  既然基類實現了介面，那麼其子類必然也滿足介面的實現，因此下麵的代碼可以按預期運行：

IGameConsole console = new XboxOne(); // IGameConsole可以引用XboxOne
console.Launch(); // 輸出Xbox Launched!

  子類自然可以重新實現父類中實現過的介面協定，但是要分情況：

（1）父類中的方法不是虛方法，需要重新實現介面：

class XboxOne : Xbox, IGameConsole // 聲明重新實現IGameConsole
{
    public new void Launch()
    {
        Console.WriteLine("Xbox One Launched!");
    }
}

  （方法中的new修飾符不是必須的，但是加上會讓語義更清晰）

  這樣在使用介面引用時才能調用到正確的方法：

IGameConsole console = new XboxOne();
console.Launch(); // 輸出Xbox One Launched!

  而下麵的實現無法正確重新實現：

class XboxOne : Xbox
{
    public void Launch()
    {
        Console.WriteLine("Xbox One Launched!");
    }
}

  畢竟Xbox的Launch方法只是一個普通非虛方法，只是它可以實現IGameConsole介面的協定而已。

（2）父類中的方法為虛方法，直接重寫該虛方法即可：

class XboxOne : Xbox
{
    public override void Launch() // 如果基類的Launch方法被修飾為虛方法，則直接重寫即可
    {
        Console.WriteLine("Xbox One Launched!");
    }
}

  當然，嚴格來說這是多態的功勞（雖然介面本身的實現也依賴多態就是了）。

4.2 多重實現

  可以同時對介面進行預設實現和顯式實現：

interface IGameConsole
{
    void Launch();
}

class Xbox : IGameConsole
{
    public void Launch()       // 預設實現
    {
        Console.WriteLine("Xbox Launched!");
    }

    void IGameConsole.Launch() // 顯式實現
    {
        Console.WriteLine("A Game Console Launched");
    }
}

   不過從實際上來說，同時定義預設實現和顯式實現後，真正實現介面的是顯式實現，而預設實現此時就只是普通的方法而已。原因是因為使用介面無外乎通過下麵兩方式：

Xbox xbox = new Xbox();

xbox.Launch();    // 輸出Xbox Launched!

IGameConsole console = xbox;
console.Launch(); // 輸出A Game Console Launched

  第一是直接通過對象使用，但其實這和介面無關，這本身就只是一個普通的方法調用。

  第二是通過介面引用調用，這時候介面引用將調用顯式實現，因此顯式實現才是真正的實現。

  這是合理的，因為顯式實現的語義更明確。

5. 使用建議

5.1 基類 or 介面？

  使用基類有時也可以做到介面能做的事，而另一方面在面向介面編程成為一種流行時可能讓人在更應該使用基類的地方使用介面。關於選擇基類還是介面，主要有如下幾點可以考慮：

（1）IS-A還是CAN-DO。在OOP中繼承主要是描述類型間的IS-A關係，例如Cat繼承自Animal，因為Cat是一種（IS-A）Animal，而介面主要用於表示‘CAN-DO’，即表示類型‘可以做什麼’。

（2）是否需要儲存狀態或定義複雜行為。基類可以定義欄位，提供更豐富的方法實現，而介面不能定義欄位並且方法通常都是抽象方法（不推薦使用預設實現）。

（3）行為是否比類型重要。例如某一位置只需要使用類型FileUtil的某個方法來獲取文本數據，那麼此時重要的是獲取文本數據，至於數據是不是FileUtil提供的其實並不重要，此時若將獲取數據這一行為抽象為介面可以獲得提供更好的泛用性。

5.2 對介面的一些使用建議

（1）介面名以I開頭，並且儘可能以‘CAN-DO’風格命名，或者合適時使用名詞亦可。下麵是良好的介面名例子：

interface IEnumerable { ... }   // 表示可遍歷
interface IList { ... }         // 表示可以進行類似列表的操作
interface IFlyable { ... }      // 表示能飛
interface IDataProvider { ... } // 表示能提供數據

（2）介面一旦定義後應該儘可能避免修改，因為介面是協定，類型之間基於介面的協定而做出假設進行交互，隨意更改會使程式的維護變得複雜。

（3）介面的協定應該儘可能少，能滿足其介面名描述的行為即可。多個簡單的介面組合勝過一個所謂的“萬能”介面。

（4）介面應該提供詳細的註釋，以闡述該介面的協定。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 乾貨合集│最好用的 python 庫都在這
    一、分詞 - jieba 優秀的中文分詞庫，依靠中文詞庫，利用詞庫確定漢子之間關聯的概率，形成分詞結果 import jieba word = '偉大的中華人民共和國' jieba.cut(word) jieba.lcut(word) 二、詞雲庫 - wordcloud 對數據中出現頻率較高的 關鍵 ...
  • EasyExcel-合併單元格
    pom版本 <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>2.2.7</version> </dependency> 1.自定義合併單元格 在某些業務場景中可能會有合併單 ...
  • Java日誌體系一本通
    主要內容 1·學習java日誌體系及日誌工具的演進 2·瞭解日誌採集、處理、分析等各階段的常用中間件 3·學會搭建完整的elk日誌平臺 4·學習日誌打點，切麵，日誌文件等輸出手段 5·項目實戰，完成一訪問日誌鏈路的跟蹤 1、Java日誌體系 1.1 體系概述 1.1.1 日誌介面 JCL：Apach ...
  • SpringCloud微服務實戰——搭建企業級開發框架（四十一）：擴展JustAuth+SpringSecurity+Vue實現多租戶系統微信掃碼、釘釘掃碼等第三方登錄
    前面我們詳細介紹了SSO、OAuth2的定義和實現原理，也舉例說明瞭如何在微服務框架中使用spring-security-oauth2實現單點登錄授權伺服器和單點登錄客戶端。目前很多平臺都提供了單點登錄授權伺服器功能，比如我們經常用到的QQ登錄、微信登錄、新浪微博登錄、支付寶登錄等等。 如果我們自己 ...
  • 【Java面試】什麼是可重入，什麼是可重入鎖? 它用來解決什麼問題?
    一個工作了3年的粉絲，去一個互聯網公司面試，結果被面試官懟了。 面試官說：”這麼簡單的問題你都不知道？ 沒法聊了，回去等通知吧“。 這個問題是： ”什麼是可重入鎖，以及它的作用是什麼？“ 對於這個問題，來看看普通人和高手的回答吧 普通人： 嗯。。。。。。。。。。。。。。。。。。 高手： 好的。 可重 ...
  • Java連接MySQL
    JDBC概述 JDBC（Java Data Base Connectivity,java資料庫連接）是一種用於執行SQL語句的Java API，可以為多種關係資料庫提供統一訪問，它由一組用Java語言編寫的類和介面組成。是Java訪問資料庫的標準規範。 JDBC提供了一種基準,據此可以構建更高級的工 ...
  • 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（十） - ShardingSphere-JDBC 集成與配置
    手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（一） - 介紹 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（二） - 資料庫設計 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（三） - 項目初始化 ...
  • 1w+ 字總結 Java 常用類，整理太全了，建議收藏..
    來源：cnblogs.com/lwtyyds/p/15678152.html 常用類概述 內部類 Object類 包裝類 數學類 時間類 字元串 String Builder和StringBuffer DecimalFormat 內部類 「概念」 ：在一個類內部再定義一個完整的類。 一般情況下類與類 ...
一周排行
    -Advertisement-
    Play Games
  • GoF之工廠模式
    GoF之工廠模式 @目錄GoF之工廠模式每博一文案1. 簡單說明“23種設計模式”1.2 介紹工廠模式的三種形態1.3 簡單工廠模式（靜態工廠模式）1.3.1 簡單工廠模式的優缺點:1.4 工廠方法模式1.4.1 工廠方法模式的優缺點:1.5 抽象工廠模式1.6 抽象工廠模式的優缺點：2. 總結:3 ...
  • dotnet C# 簡單的追加文件夾到 ZipArchive 壓縮文件的方法
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • Elasticsearch 系列（六）- ES數據同步和ES集群
    本章將和大家分享ES的數據同步方案和ES集群相關知識。廢話不多說，下麵我們直接進入主題。 一、ES數據同步 1、數據同步問題 Elasticsearch中的酒店數據來自於mysql資料庫，因此mysql數據發生改變時，Elasticsearch也必須跟著改變，這個就是Elasticsearch與my ...
  • 自動化測試數據生成：Asp.Net Core單元測試利器AutoFixture詳解
    引言 在我們之前的文章中介紹過使用Bogus生成模擬測試數據，今天來講解一下功能更加強大自動生成測試數據的工具的庫"AutoFixture"。 什麼是AutoFixture? AutoFixture 是一個針對 .NET 的開源庫，旨在最大程度地減少單元測試中的“安排（Arrange）”階段，以提高 ...
  • .NET Emit 入門教程：第七部分：實戰項目1：將 DbDataReader 轉實體
    經過前面幾個部分學習，相信學過的同學已經能夠掌握 .NET Emit 這種中間語言，並能使得它來編寫一些應用，以提高程式的性能。隨著 IL 指令篇的結束，本系列也已經接近尾聲，在這接近結束的最後，會提供幾個可供直接使用的示例，以供大伙分析或使用在項目中。 ...
  • Windows下綁定線程到指定的CPU核心
    當從不同來源導入Excel數據時，可能存在重覆的記錄。為了確保數據的準確性，通常需要刪除這些重覆的行。手動查找並刪除可能會非常耗費時間，而通過編程腳本則可以實現在短時間內處理大量數據。本文將提供一個使用C# 快速查找並刪除Excel重覆項的免費解決方案。 以下是實現步驟： 1. 首先安裝免費.NET ...
  • mORMot 1.18 第07章 簡單的讀寫操作
    C++ 異常處理 C++ 異常處理機制允許程式在運行時處理錯誤或意外情況。它提供了捕獲和處理錯誤的一種結構化方式，使程式更加健壯和可靠。 異常處理的基本概念： 異常: 程式在運行時發生的錯誤或意外情況。 拋出異常: 使用 throw 關鍵字將異常傳遞給調用堆棧。 捕獲異常: 使用 try-catch ...
  • mORMot 1.18 第06章 概念
    優秀且經驗豐富的Java開發人員的特征之一是對API的廣泛瞭解，包括JDK和第三方庫。 我花了很多時間來學習API，尤其是在閱讀了Effective Java 3rd Edition之後 ，Joshua Bloch建議在Java 3rd Edition中使用現有的API進行開發，而不是為常見的東西編 ...
  • php 開發規範
    框架 · 使用laravel框架，原因：tp的框架路由和orm沒有laravel好用 · 使用強制路由，方便介面多時，分多版本，分文件夾等操作 介面 · 介面開發註意欄位類型，欄位是int，查詢成功失敗都要返回int（對接java等強類型語言方便） · 查詢介面用GET、其他用POST 代碼 · 所 ...
  • 2024 年 4 月 28 日 周日 晴 熱（1253 字）
    正文 下午找企業的人去鎮上做貸後。 車上聽同事跟那個司機對罵，火星子都快出來了。司機跟那同事更熟一些，連我在內一共就三個人，同事那一手指桑罵槐給我都聽愣了。司機也是老社會人了，馬上聽出來了，為那個無辜的企業經辦人辯護，實際上是為自己辯護。 “這個事情你不能怪企業。”“但他們總不能讓銀行的人全權負責， ...
所有分類