C#學習筆記（15）——c#介面

標籤：通訊   對象   子介面   nal   訪問   tcl   pre   ref   分享   

說明（2017-7-17 21:57:26）：

原文：http://www.cnblogs.com/jiajiayuan/archive/2011/09/16/2178462.html

本文意在鞏固基礎知識，並不是對其進行深入剖析，還望理解。
本文為原創文，難免會有一些小得瑕疵，敬請諒解。
所有樣本均是博主測試過的，如有轉載請標明出處，謝謝。
在編程中，我們經常會用到介面，那什麼是介面呢？
介面描述的是可屬於任何類或結構的一組相關功能，所以實現介面的類或結構必須實現介面定義中指定的介面成員。
介面使用interface 關鍵字進行定義，可由方法、屬性、事件、索引器或這四種成員類型的任意組合構成。
介面的特性：
1.介面類似於抽象基類，不能直接執行個體化介面；介面中的方法都是抽象方法，實現介面的任何非抽象類別型都必須實現介面的所有成員：
當顯式實現該介面的成員時，實現的成員不能通過類執行個體訪問，只能通過介面執行個體訪問。
當隱式實現該介面的成員時，實現的成員可以通過類執行個體訪問，也可以通過介面執行個體訪問，但是實現的成員必須是公有的。
2.介面不能包含常量、欄位、運算子、執行個體建構函式、解構函式或類型、不能包含靜態成員。
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();
        }
    }

上面提到，實現介面可以顯式實現和隱式實現，那麼這兩種實現到底有什麼優缺點呢？
一般情況，當類或者結構要實現的是單個介面，可以使用隱式實現。
如果類或者結構繼承了多個介面且介面中具有相同名稱成員時，就要用到顯式實現，當顯式實現方式存在時，隱式實現方式就失效了。

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();
        }
    }

介面的覆蓋：
由於介面的實現沒有方法體，抽象方法也沒有方法體，那麼當我們在介面的實現方法裡調用抽象方法時，會如何執行呢？

    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.

通過斷點，可以看到，當執行pro.Fun();時，首先會跳到介面的實現方法裡，然後去調用抽象函數的實現方法，當抽象函數的方法實現後，再回到介面的實現方法，直到執行完成。
當我們在實現介面的方法裡調用虛函數呢？

    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();
        }
    }

這時，我們發現，執行的順序和上一個例子是相同的。所以結果為：I am override AFun.
由此，我們可以繼續聯想，當我們把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();
        }
    }

結果為：I am virtual AFun.
           I am new AFun.
由於前面已經講過了，這裡不在對此進行分析，由此我們可知使用New關鍵字是對其進行隱藏，當對介面實現的方法裡調用的是虛方法時，和類的執行過程是一樣的。
介面和抽象類別的區別。
介面用於規範，抽象類別用於共性。
介面中只能聲明方法，屬性，事件，索引器。而抽象類別中可以有方法的實現，也可以定義非靜態類變數。
抽象類別是類，所以只能被單繼承，但是介面卻可以一次實現多個。
抽象類別可以提供某些方法的部分實現，介面不可以。
抽象類別的執行個體是它的子類給出的。介面的執行個體是實現介面的類給出的。 
在抽象類別中加入一個方法，那麼它的子類就同時有了這個方法。而在介面中加入新的方法，那麼實現它的類就要重新編寫（這就是為什麼說介面是一個類的規範了）。
介面成員被定義為公用的，但抽象類別的成員也可以是私人的、受保護的、內部的或受保護的內部成員（其中受保護的內部成員只能在應用程式的代碼或衍生類別中訪問）。
此外介面不能包含欄位、建構函式、解構函式、靜態成員或常量。 
C#中的介面和類有什麼異同。 
異： 
不能直接執行個體化介面。 
介面不包含方法的實現。 
介面可以實現多繼承，而類只能是單繼承。 
類定義可在不同的源檔案之間進行拆分。 
同： 
介面、類和結構可從多個介面繼承。 
介面類似於抽象基類：繼承介面的任何非抽象類別型都必須實現介面的所有成員。 
介面可以包含事件、索引器、方法和屬性。 
一個類可以實現多個介面。

C#學習筆記（15）——c#介面