深入理解C#之接口

更新時間：2021年07月08日 15:04:08 作者：佳園

這篇文章主要介紹了C#接口(Interface)用法,較為詳細的分析了C#中接口的功能、實現及使用技巧,具有一定參考借鑒價值,需要的朋友可以參考下

C#之接口

在編程中，我們經常會用到接口，那什么是接口呢？

接口描述的是可屬于任何類或結構的一組相關功能，所以實現接口的類或結構必須實現接口定義中指定的接口成員。

接口使用interface 關鍵字進行定義，可由方法、屬性、事件、索引器或這四種成員類型的任意組合構成。

接口的特性：

1.接口類似于抽象基類，不能直接實例化接口；接口中的方法都是抽象方法，實現接口的任何非抽象類型都必須實現接口的所有

成員。

當顯式實現該接口的成員時，實現的成員不能通過類實例訪問，只能通過接口實例訪問。

當隱式實現該接口的成員時，實現的成員可以通過類實例訪問，也可以通過接口實例訪問，但是實現的成員必須是公有的。

2.接口不能包含常量、字段、運算符、實例構造函數、析構函數或類型、不能包含靜態(tài)成員。

3.接口成員是自動公開的，且不能包含任何訪問修飾符。

4.接口自身可從多個接口繼承，類和結構可繼承多個接口，但接口不能繼承類。

為什么不能指定接口中方法的修飾符？

接口中的方法用來定義對象之間通信的契約，指定接口中的方法為私有或保護沒有意義。它們默認為公有方法。

   interface IProgram  
  {     
       void Fun();  
  }   
   class Program:IProgram  
  {    
     //顯式實現接口成員        
     void IProgram.Fun()     
     {        
           Console.WriteLine("I am Fun.");    
    }     
     staticvoid Main(string[] args)    
    {    
          IProgram p =new Program(); 
     //聲明一個接口實例，但不是對接口進行實例化            
     p.Fun();        
     Console.Read();    
    }    
}

上面提到，實現接口可以顯式實現和隱式實現，那么這兩種實現到底有什么優(yōu)缺點呢？

一般情況，當類或者結構要實現的是單個接口，可以使用隱式實現。

如果類或者結構繼承了多個接口且接口中具有相同名稱成員時，就要用到顯式實現，當顯式實現方式存在時，隱式實現方式就失效了。

interface IProgram
    {
        void Fun();
    }
    interface IAProgram
    {
        void Fun();
    }
    class Program : IProgram, IAProgram
    {
        void IProgram.Fun()  //顯式實現接口IProgram
        {
            Console.WriteLine("I am IProgram Fun.");
        }
        void IAProgram.Fun()  //顯式實現接口IAProgram
        {
            Console.WriteLine("I am IAProgram Fun.");
        }
        //public void Fun()   //隱式實現接口
        //{
        //    Console.WriteLine("I am Program Fun.");
        //}
        staticvoid Main(string[] args)
        {
            //IProgram p = new Program();
            //p.Fun();
            //IAProgram ap = new Program();
            //ap.Fun();
            Program pro =new Program();
            ((IProgram)pro).Fun();
            ((IAProgram)pro).Fun();
            Console.Read();
        }
    }

結果為：

I am IProgram Fun. I am IAProgram Fun.

接口的繼承：

接口繼承和類繼承不同：首先，類繼承不僅是說明繼承，而且也是實現繼承；而接口繼承只是說明繼承。

也就是說，派生類可以繼承基類的方法實現，而派生的接口只繼承了父接口的成員方法說明，而沒有繼承父接口的實現，

其次，C#中類繼承只允許單繼承，但是接口繼承允許多繼承，一個子接口可以有多個父接口。

接口可以從零或多個接口中繼承。從多個接口中繼承時，用":"后跟被繼承的接口名字，多個接口名之間用","分割。

被繼承的接口應該是可以訪問得到的，比如從private 類型或internal 類型的接口中繼承就是不允許的。

接口不允許直接或間接地從自身繼承。和類的繼承相似，接口的繼承也形成接口之間的層次結構。

interface IProgram
    {
        void Fun();
    }
    interface IAProgram:IProgram
    {
    }
    class Program :  IAProgram
    {
        void IProgram.Fun()
        {
            Console.WriteLine("I am IProgram Fun.");
        }
        staticvoid Main(string[] args)
        {
            Program pro =new Program();
            ((IAProgram)pro).Fun();
            Console.Read();
        }
    }

接口的覆蓋：

由于接口的實現沒有方法體，抽象方法也沒有方法體，那么當我們在接口的實現方法里調用抽象方法時，會如何執(zhí)行呢？

 interface IProgram
    {
        void Fun();
    }
    abstractclass AProgram : IProgram
    {
        publicabstractvoid AFun();
        void IProgram.Fun()
        {
            AFun();
        }
    }
    class Program:AProgram
    {
        publicoverridevoid AFun()
        {
            Console.WriteLine("I am AProgram.");
        }
        staticvoid Main(string[] args)
        {
            IProgram pro =new Program();
            pro.Fun();
            Console.Read();
        }
    }

結果：

I am Aprogram.

通過斷點，可以看到，當執(zhí)行pro.Fun();時，首先會跳到接口的實現方法里，然后去調用抽象函數的實現方法，當抽象函數的方法實現后，再回到接口的實現方法，直到執(zhí)行完成。

當我們在實現接口的方法里調用虛函數呢？

 interface IProgram
    {
        void Fun();
    }
    class AProgram : IProgram
    {
        publicvirtualvoid AFun()    //注意這里是虛函數
        {
            Console.WriteLine("I am virtual AFun.");
        }
        void IProgram.Fun()
        {
            AFun();
        }
    }
    class Program:AProgram
    {
        publicoverridevoid AFun()  //這里是Override重寫
        {
            Console.WriteLine("I am override AFun.");
        }
        staticvoid Main(string[] args)
        {
            IProgram pro =new Program();
            pro.Fun();
            Console.Read();
        }
    }

這時，我們發(fā)現，執(zhí)行的順序和上一個例子是相同的。所以結果為：

I am override AFun.

由此，我們可以繼續(xù)聯想，當我們把override關鍵字，換成new呢？是不是也是同樣的結果，還是和我們以前講的例子一樣，是隱藏呢？

我們把上面的例子進行改進：

interface IProgram
    {
        void Fun();
    }
    class AProgram : IProgram
    {
        publicvirtualvoid AFun()
        {
            Console.WriteLine("I am virtual AFun.");
        }
        void IProgram.Fun()
        {
            AFun();
        }
    }
    class Program:AProgram
    {
        publicnewvoid AFun()
        {
            Console.WriteLine("I am new AFun.");
        }
        staticvoid Main(string[] args)
        {
            Program pro =new Program();
            ((IProgram)pro).Fun();
            pro.AFun();
            Console.Read();
        }
    }

結果為：