C#接口與抽象類學習筆記

時間 2019-12-31

標籤 c# 接口抽象學習筆記欄目 C# 简体版

原文原文鏈接

本筆記摘抄自：https://www.cnblogs.com/solan/archive/2012/08/01/CSharp06.html，記錄一下學習過程以備後續查用。html

摘要：ide

抽象類：是一種特殊的類，能夠定義具備實現的方法，也能夠定義未實現的方法契約，自己不能被實例化，只能在派生類中進行實例化。接口：對一函數

組方法簽名進行統一的命名，只能定義未實現的方法契約，自己也不能被實例化，只能在實現類中進行實例化。學習

兩者均可以有部分數據成員（如：屬性），它們貌似有着相同的「契約」功能，但對各自的派生類（實現類）又有着不一樣的要求，那麼，到底它們有何ui

異同呢？下面將從四個方面來說解它們的相同與不一樣之處。this

1、定義spa

抽象類 不能實例化。抽象類的用途是提供多個派生類可共享的基類的公共定義，是對類進行抽象，能夠有實現，也能夠不實現。使用關鍵字abstract3d

進行定義。code

下面定義一個抽象類：htm

public abstract class Code_06_03
{
}

經過ISDASM來看一下生成的IL：

.class abstract auto ansi nested public beforefieldinit Code_06_03
       extends [mscorlib]System.Object
{
} // end of class Code_06_03

能夠看以，抽象類其實是繼承了System.Object類，而且編譯器爲它生成了一個默認的構造函數。

接口它是對一組方法簽名進行統一命名，是對一組行爲規範的定義，使用關鍵字interface進行定義。

下面定義一個接口：

public interface ICode_06_01
{
}

經過ISDASM來看一下生成的IL：

.class interface abstract auto ansi nested public ICode_06_01
{
} // end of class ICode_06_01

能夠看到，接口其實是把它當成抽象類來看待，可是沒有構造函數。不管是抽象類擁有構造函數，仍是接口不擁有構造函數，它們都是不能被實例

化的。

2、成員的區別

抽象類 描述：

1）能夠定義抽象方法，抽象方法沒有具體實現，僅僅是一個方法的契約，在子類中重寫該方法。抽象類能夠重寫父類的虛方法爲抽象方法。

2）能夠定義非抽象方法，但要求該方法要有具體實現，若是該方法是虛方法，則在子類中能夠重寫該方法。

3）能夠定義字段、屬性、抽象屬性、事件及靜態成員。

下面是對類Code_06_03的擴充：

    class Program
    {
        /// <summary>
        /// 抽象類
        /// </summary>
        public abstract class Code_06_03
        {
            Dictionary<Guid, string> root = new Dictionary<Guid, string>();
            public string Sex { get; set; }
            public abstract string Address { get; }
            public abstract int Add(int a, int b);

            protected virtual string GetAddress(string addressID)
            {
                return addressID + " 廣東";
            }

            public void AddRoot(Guid id, string rootName)
            {
                root.Add(id, rootName);
                OnAddRoot();
            }

            public event EventHandler AddRootEvent;

            void OnAddRoot()
            {
                AddRootEvent?.Invoke(this, null);
            }

            public string this[Guid key]
            {
                get
                {
                    return root[key];
                }
                set
                {
                    root[key] = value;
                }
            }
        }

        static void Main(string[] args)
        {

        }
    }

View Code

2.1抽象方法public abstract int Add(int a, int b);的IL：

.method public hidebysig newslot abstract virtual 
        instance int32  Add(int32 a,
                            int32 b) cil managed
{
} // end of method Code_06_03::Add

編譯器把Add方法看成一個虛方法，在子類中能夠被重寫。

2.2虛方法protected virtual string GetAddress(string addressID)的IL：

.method family hidebysig newslot virtual 
        instance string  GetAddress(string addressID) cil managed
{
  // 略過
} // end of method Code_06_03::GetAddress

它原本就是一個虛方法，因此編譯器並無特殊對待它。

2.3方法public void AddRoot(Guid id, string rootName)的IL：

.method public hidebysig instance void  AddRoot(valuetype [mscorlib]System.Guid id,
                                                string rootName) cil managed
{
  // 略過
} // end of method Code_06_03::AddRoot

它也是一個普通的對象方法。

接口描述：

1）能夠定義屬性及索引器，但不能定義字段。

2）能夠定義事件。

3）能夠定義方法，僅僅是方法簽名的約定，不得有實現，在實現類中對該方法進行具體實現，有點相似於抽象類的抽象方法。

4）不能夠定義虛方法。

5）不能夠定義任何靜態成員。

6）接口成員默認是全開放的，不得有訪問修飾符。

下面是對類Code_06_01的擴充：

    class Program
    {
        /// <summary>
        /// 接口
        /// </summary>
        public interface ICode_06_01
        {
            string Name { get; set; }
            int Add(int a, int b);
            event EventHandler AddEvent;
        }

        static void Main(string[] args)
        {

        }
    }

View Code

2.4方法int Add(int a, int b);的IL：

.method public hidebysig newslot abstract virtual 
        instance int32  Add(int32 a,
                            int32 b) cil managed
{
} // end of method ICode_06_01::Add

能夠看到，定義的時候，咱們並無爲其指定可訪問修飾符（編譯器也不容許咱們明文指定其可訪問修飾符），但編譯器默認將它的訪問級

別指定爲public，另外是把它看成一個抽象的虛方法。

至於成員屬性和事件，編譯器則將它們看成普通的對象屬性和對象事件對待，會爲它們生成相應的get/set和add/remove 方法，並沒有特別之

處。

3、實現方式的區別

抽象類 實現：

因爲抽象類也是類，因此對它的實現就像普通的繼承同樣，子類經過繼承能夠獲得抽象類的公有成員，且能夠重寫部分紅員，如虛方法和抽象

方法等。

下面是對Code_06_03類的實現：

    class Program
    {
        /// <summary>
        /// 抽象類
        /// </summary>
        public abstract class Code_06_03
        {
            Dictionary<Guid, string> root = new Dictionary<Guid, string>();
            public string Sex { get; set; }
            public abstract string Address { get; }

            /// <summary>
            /// 抽象方法ADD
            /// </summary>
            /// <param name="a"></param>
            /// <param name="b"></param>
            /// <returns></returns>
            public abstract int Add(int a, int b);

            /// <summary>
            /// 虛方法GetAddress
            /// </summary>
            /// <param name="addressID"></param>
            /// <returns></returns>
            protected virtual string GetAddress(string addressID)
            {
                return addressID + " 廣東";
            }

            public void AddRoot(Guid id, string rootName)
            {
                root.Add(id, rootName);
                OnAddRoot();
            }

            public event EventHandler AddRootEvent;

            void OnAddRoot()
            {
                AddRootEvent?.Invoke(this, null);
            }

            public string this[Guid key]
            {
                get
                {
                    return root[key];
                }
                set
                {
                    root[key] = value;
                }
            }
        }

        /// <summary>
        /// 抽象類的實現
        /// </summary>
        public class Code_06_04 : Code_06_03
        {
            public override int Add(int a, int b)
            {
                return a + b;
            }
            protected override string GetAddress(string addressID)
            {
                return "GuangDong";
            }

            readonly string addressPrefix = "China ";
            public override string Address
            {
                get { return addressPrefix; }
            }
        }

        static void Main(string[] args)
        {

        }
    }

View Code

經過ISDASM來看一下生成的IL：

能夠看到類Code_06_04是標準地對繼承類Code_06_03，兩個重寫的方法Add和GetAddress都是普通的對象方法，只是依然被

看成虛方法來看待。

3.1方法Add的IL：

.method public hidebysig virtual instance int32 
        Add(int32 a,
            int32 b) cil managed
{
  // 略過
} // end of method Code_06_04::Add

3.2方法GetAddress的IL：

.method family hidebysig virtual instance string 
        GetAddress(string addressID) cil managed
{
  // 略過
} // end of method Code_06_04::GetAddress

由於這兩個方法保持着虛方法的特性，因此對於Code_06_04類的子類，一樣還能夠重寫這兩個方法。屬性成員Address這裏還

是一普通的對象屬性。

接口實現

對接口的實現跟對抽象類的實現類似，下面是對接口ICode_06_01的實現：

    class Program
    {
        /// <summary>
        /// 接口
        /// </summary>
        public interface ICode_06_01
        {
            string Name { get; set; }
            int Add(int a, int b);
            event EventHandler AddEvent;
        }

        /// <summary>
        /// 接口的實現
        /// </summary>
        public class Code_06_02 : ICode_06_01
        {
            public string Name { get; set; }

            public int Add(int a, int b)
            {
                OnAdded();
                return a + b;
            }

            public event EventHandler AddEvent;

            void OnAdded()
            {
                AddEvent?.Invoke(this, null);
            }
        }

        static void Main(string[] args)
        {

        }
    }

View Code

經過ISDASM來看一下生成的IL：

它與普通類的區別不大，只是很明確的是實現了接口ICode_06_01，來看一下它的IL：

.class auto ansi nested public beforefieldinit Code_06_02
       extends [mscorlib]System.Object
       implements LinkTo.Test.InterfaceAndAbstractClass.Program/ICode_06_01
{
} // end of class Code_06_02

能夠看到，類Code_06_02不只繼承於System.Object類，同時還實現了接口ICode_06_01。再來看一下對於接口中的方法，編

譯器是如何處理的？

3.3方法Add的IL：

.method public hidebysig newslot virtual final 
        instance int32  Add(int32 a,
                            int32 b) cil managed
{
  // 略過
} // end of method Code_06_02::Add

編譯器認爲Add方法具備虛方法的特性。而對於屬性和事件，依然是普通的實現，如get/set、add/remove。另外，接口還支持

顯示實現接口，咱們上面討論的Code_06_02類對接口的實現默認是隱式實現。

在接口的實現類內部，能夠存在一個與接口某一方法名（包括簽名）徹底相同的方法，但要求對接口實現的那個方法必須是顯

示實現，以下代碼：

        public int Add(int a, int b)
        {
            return a + b;
        }

        int ICode_06_01.Add(int a, int b)
        {
            OnAdded();
            return a + b;
        }

能夠看出顯示實現就是在方法前加上接口名和點號（ICode_06_01.），另外方法是不能有可訪問修飾符的，編譯器會對其進行

private處理。那如何才能調用顯示實現的接口方法呢？能夠將實現類的對象轉爲一個接口變量，再調用該變量的相應方法，以下

代碼：

        static void Main(string[] args)
        {
            Code_06_02 code0602 = new Code_06_02();
            ICode_06_01 icode0602 = code0602;
            var result = icode0602.Add(1, 2);
            Console.WriteLine($"Result={result}");
            Console.Read();
        }

而對於抽象類的實現，是不能進行顯示實現的。

4、應用中的區別

1）抽象類保留一普通類的部分特性，定義可能已經實現的方法行爲，方法內能夠對數據成員（如屬性）進行操做，且方法能夠

相互溝通。而接口僅僅是定義方法的簽名，就像規則，只是約定，並無實現。

2）抽象類的派生類能夠原封不動地獲得抽象類的部分紅員，接口的實現類若是想要獲得接口的數據成員，則必須對其進行重寫。

3）一個類只能繼承於一個類（含抽象類），但能夠實現多個接口，而且能夠在繼承一個基類的基礎上，同時實現多個接口。

4）抽象類和接口都不能對其使用密封sealed，事實上這二者都是爲了被其餘類繼承和實現，對其使用sealed是沒有任何意義的。

5）抽象類能夠對接口進行實現。

6）抽象類更多的用於「複製對象副本」，就是咱們常說的「子類與父類有着is a的關係」，它更多關注於一個對象的總體特性。接口

更多傾向於一系列的方法操做，這些操做在當前上下文中既有着相同做用對象，又相互隔離。

7）某些時候，抽象類能夠與接口互換。

經過生活中常見的紅娘搭線的示例：紅娘（Matchmaker）安排相親者（wooer）見面並指導場面話，來講明接口與抽象類給咱們

帶來的方便性。

下面代碼演示不使用接口與抽象類的紅娘搭線：

    class Program
    {
        /// <summary>
        /// 紅娘類
        /// </summary>
        public class Matchmaker
        {
            string message;

            /// <summary>
            /// 場面話、客套話指導
            /// </summary>
            public void Teach()
            {
                message = "曾經有一份真摯的愛情擺在我面前……";
                Wooer wooer = new Wooer();
                wooer.Say(message);
            }
        }

        /// <summary>
        /// 相親者類
        /// </summary>
        public class Wooer
        {
            /// <summary>
            /// 場面話、客套話大全
            /// </summary>
            /// <param name="message"></param>
            public void Say(string message)
            {
                Console.WriteLine(message);
            }
        }

        static void Main(string[] args)
        {
            #region 不使用接口及抽象類的紅娘搭線
            Matchmaker matchmaker = new Matchmaker();
            matchmaker.Teach();
            Console.Read();
            #endregion
        }
    }

View Code

運行結果以下：

以上功能實現沒有問題，可是假如相親者想要增長一點肢體動做或文藝展現來博取對方好感的話，紅娘就得跟着變。因而，紅娘

搭建了一個相親平臺……

下面代碼演示使用接口與抽象類的紅娘搭線：

    class Program
    {
        /// <summary>
        /// 紅娘類
        /// </summary>
        public class MatchmakerNew
        {
            string message;
            /// <summary>
            /// 場面話、客套話指導
            /// </summary>
            public void Teach(IWooer wooer)
            {
                message = "曾經有一份真摯的愛情擺在我面前……";
                wooer.Say(message);
            }
        }
        /// <summary>
        /// 相親者接口
        /// </summary>
        public interface IWooer
        {
            /// <summary>
            /// 房子車子票子……
            /// </summary>
            string Message { get; }
            /// <summary>
            /// 能歌善舞……
            /// </summary>
            void Action();
            /// <summary>
            /// 甜言蜜語……
            /// </summary>
            /// <param name="message"></param>
            void Say(string message);
        }

        /// <summary>
        /// 男相親者實現類
        /// </summary>
        public class ManWooer : IWooer
        {
            public string Message
            {
                get { return "嫁給我，房子車子票子啥都有。"; }
            }
            public void Action()
            {
                Console.WriteLine("野狼disco……");
            }
            public void Say(string message)
            {
                Action();
                Console.WriteLine(message + Message);
            }
        }

        /// <summary>
        /// 女相親者實現類
        /// </summary>
        public class WomanWooer : IWooer
        {
            public string Message
            {
                get { return "娶了我，這頭牛和後面的這座山都是你的。"; }
            }
            public void Action()
            {
                Console.WriteLine("相見恨晚……");
            }
            public void Say(string message)
            {
                Action();
                Console.WriteLine(message + Message);
            }
        }

        static void Main(string[] args)
        {
            #region 使用接口及抽象類的紅娘搭線
            MatchmakerNew matchmakerNew = new MatchmakerNew();

            //男大爲婚
            IWooer manWooer= new ManWooer();
            matchmakerNew.Teach(manWooer);
            manWooer.Say("親：");
            Console.WriteLine();

            //女大爲嫁
            IWooer womanWooer = new WomanWooer();
            matchmakerNew.Teach(womanWooer);
            womanWooer.Say("親：");
            
            Console.Read();
            #endregion
        }
    }