2. 程式人生 > >C#介面和抽象類:Interface、abstract

C#介面和抽象類:Interface、abstract

阿新 • • 發佈：2019-01-04

一、介面

介面是C#中很常見的工具，概念什麼的就不說了，這裡講幾個值得注意的小地方:

1、介面內部只能有函式、屬性和事件的宣告:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->interface IParent
{
    void Show();
    string Type     //--屬性的宣告
    {
        
get;           //-- get; 不能為get{};或是：get();

        set;
    }
    event AddChildren Add;
}

在介面中宣告的成員都不需要訪問修飾符(public,private等)，因為介面成員的許可權預設都是public，另外值得注意的是介面中之所以能夠宣告事件是因為事件就是委託的特殊屬性。

介面不能是靜態的,介面成員也只能宣告為例項成員不能宣告為靜態成員，如下宣告就是錯誤的:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->static interface
 IParent
    {
        staticvoid Show();
        string Type
        {
            get;
            set;
        }
        event AddChildren Add;
    }

你會得到提示:

錯誤 1 修飾符“static”對該項無效 C:\Documents and Settings\HMD\桌面\CLR_Excise\CLR_Excise\Lib.cs 10 22 CLR_Excise

原因是如果介面是靜態的就無法被繼承,靜態成員也無法被介面直接訪問(因為介面中的成員都還沒有實體只是宣告)所以定義在介面中無意義。

2、介面支援部分宣告:

上面的介面實際上可以在一個名稱空間裡宣告為3部分:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->partialinterface IParent
    {
        void Show();
    }

    partialinterface IParent
    {
        string Type
        {
            get;
            set;
        }
    }

    partialinterface IParent
    {
        event AddChildren Add;
    }

上面這種部分介面的宣告方式和宣告為一個介面的效果完全相同，若要了解部分關鍵字partial請檢視:C#裡partial關鍵字的作用(轉摘)

3、介面的實現:

介面成員的實現方式分為兩種：

<1>隱式實現:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->class ChildrenA : IParent
        {

            #region IParent 成員publicvoid Show()
            {
                thrownew NotImplementedException();
            }


            publicstring Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            publicevent AddChildren Add;

            #endregion
        }

 在類中隱式宣告的介面成員都必須是public訪問許可權

(2)如果有一個類C實現了兩個介面IA、IB且IA、IB都有同名函式void Display();那麼可以在C中隱式實現Display，這樣即實現了IA的Dislpay也實現了IB的Display

例如:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->publicinterface IParent
        {
            void Show();
            string Type
            {
                get;
                set;
            }
            event AddChildren Add;
        }

        publicinterface IFather
        {
            void Show();
            string Type
            {
                get;
                set;
            }
            event AddChildren Add;
        }


        publicclass ChildrenA : IParent, IFather
        {


            #region IParent,IFather 成員publicvoid Show()
            {
                thrownew NotImplementedException();
            }

            publicstring Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            publicevent AddChildren Add;

            #endregion
        }

在上面類CA中將IParent和IFather的同名成員都用隱式實現介面成員的方式一次性實現了。

(3)隱式實現介面屬性的時候可以擴充介面屬性的訪問器，例如:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->publicinterface IParent
        {
            string Type
            {
                get;
            }
        }

        publicclass CParent : IParent
        {

            #region IParent 成員publicstring Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }


            #endregion
        }

本來介面屬性Type只有get訪問器，但是實現介面的類CParent擴充了介面屬性Type即定義了get訪問器也定義了set訪問器，這在隱式實現介面屬性的時候是允許的，但是在顯式實現介面屬性的時候必須嚴格按照介面定義的格式來！

<2>顯式宣告介面:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->class ChildrenA : IParent
        {

            void IParent.Show()
            {
                thrownew NotImplementedException();
            }


            string IParent.Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            event AddChildren IParent.Add
            {
                add { thrownew NotImplementedException(); }
                remove { thrownew NotImplementedException(); }
            }
        }

顯式實現介面不能設定實現成員的訪問許可權(因為顯式宣告成員的許可權就是其對應介面成員的許可權，當然就是public)

此外顯式實現介面需要注意以下幾點：

(1)顯式實現介面，那麼實現的介面成員只能由介面呼叫，因為顯式實現的介面成員對於實現類來說是不可見的。

(2)顯式實現接事件的時候要注意，只能顯示實現事件的定義，例如顯式實現IParent.Add事件的時候，用的顯式實現事件:

event AddChildren IParent.Add
{
　　add { throw new NotImplementedException(); }
　　remove { throw new NotImplementedException(); }
}

如果用隱式實現事件就會報錯:

event AddChildren IParent.Add
提示:錯誤 1 事件的顯式介面實現必須使用事件訪問器語法 C:\Documents and Settings\HMD\桌面\CLR_Excise\CLR_Excise\Lib.cs 45 38 CLR_Excise

(3)上面隱式實現介面(3)中的例子沒有區分IParent、IFather同名成員的實現，而是在繼承類CA中由隱式實現方式統一實現。下面舉例說明如何將IParent、IFather的同名成員分別實現:

還是有一個類C實現了兩個介面IA、IB且IA、IB都有同名函式void Display();，這次為了區分IA,IB同名成員Dispaly函式的實現，可以在CA中將一個介面的Display函式用顯式方式實現，這說明在實現介面的時候可以將其中一個介面的同名成員用顯式方式實現，以區分同名成員的實現

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->publicdelegatevoid AddChildren();

        interface IParent
        {
            void Show();
            string Type
            {
                get;
                set;
            }
            event AddChildren Add;
        }

        interface IFather
        {
            void Show();
            string Type
            {
                get;
                set;
            }
            event AddChildren Add;
        }


        class ChildrenA : IParent, IFather
        {


            #region IParent 成員publicvoid Show()
            {
                thrownew NotImplementedException();
            }

            publicstring Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            publicevent AddChildren Add;

            #endregion#region IFather 成員void IFather.Show()
            {
                thrownew NotImplementedException();
            }

            string IFather.Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            event AddChildren IFather.Add
            {
                add { thrownew NotImplementedException(); }
                remove { thrownew NotImplementedException(); }
            }

            #endregion
        }

現在就將IParent和IFather介面的同名成員分開實現了，其中將IFather介面的同名成員用顯式方式宣告以區分IParent介面的實現。事實上可以將IParent和IFather的成員都以顯式方式實現，不過這樣實現類CA就不能訪問到IParent和IFather的成員了，只有用IParent和IFather來訪問它們各自的成員。

 (4)如果實現類繼承了具有同名成員的抽象類，那麼加上override關鍵字後即實現了抽象類也實現了介面

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->publicdelegatevoid AddChildren();

        interface IParent
        {
            void Show();
            string Type
            {
                get;
                set;
            }
            event AddChildren Add;
        }

        abstractclass AParent
        {
            publicabstractvoid Show();
            publicabstractstring Type
            {
                get;
                set;
            }
            publicabstractevent AddChildren Add;
        }

        class ChildrenA :AParent, IParent
        {


            #region AParent、IParent 成員publicoverridevoid Show()
            {
                thrownew NotImplementedException();
            }

            publicoverridestring Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            publicoverrideevent AddChildren Add;

            #endregion

        }

二、抽象類

抽象類是C#裡面用的相對較少的工具，不過在有些場合他比介面更有用，抽象類的作用與介面類似就是宣告個框架，讓繼承類照著這個框架去實現，不過抽象類允許對已經確定的部分先進行實現，繼承類要做的就是實現沒有確定的成員(抽象成員)

abstract 修飾符可以和類、方法、屬性、索引器及事件一起使用。

在使用抽象類的時候需要注意:

(1)抽象類和介面一樣是個框架，本身不能被例項化，只能通過繼承類將其例項化。

(2)抽象類不能使用sealed和static關鍵字，因為使用sealed關鍵字表示類不能被繼承，而靜態類也不能被繼承，抽象類不被繼承是完全沒有意義的。

(3)實現抽象類的類必須實現抽象類的所有抽象成員(標記了abstract的成員):

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->publicabstractclass AParent
        {
            publicabstractvoid Show();
            publicabstractstring Type
            {
                get;
                set;
            }
            publicabstractevent AddChildren Add;
            public int tInt
            {
                get
                {
                    return 1;
                }
            }
        }

        publicclass Parent : AParent
        {

            publicoverridevoid Show()
            {
                thrownew NotImplementedException();
            }

            publicoverridestring Type
            {
                get
                {
                    thrownew NotImplementedException();
                }
                set
                {
                    thrownew NotImplementedException();
                }
            }

            publicoverrideevent AddChildren Add;
        }

Parent類實現了AParent的所有抽象成員，但是並沒有實現AParent的非抽象成員public int tInt

(4)抽象成員都是虛成員(virtual)，這一點上面的程式碼中可以看到，實現抽象類的成員都使用了關鍵字override(實現抽象成員必須要用override)表示重寫抽象類的抽象成員

(5)抽象成員不能標記為static(原因同介面)、virtual，且抽象成員不能是private的(原因就是private成員無法被繼承)。

(6)抽象類的抽象成員可以重寫(override)或隱藏(new)基類成員:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->abstractclass ACA
        {
            publicabstractvoid Call();
        }

        abstractclass ACB : ACA
        {
            publicoverrideabstractvoid Call();
        }

如上所示ACB的抽象成員就重寫了父類ACA的抽象成員

(7)抽象類也支援部分定義，例如可以將（3）中的AParent分成3部分定義，其效果和定義成一個相同:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->publicabstractpartialclass AParent
        {
            publicabstractvoid Show();
            publicint tInt
            {
                get
                {
                    return1;
                }
            }
        }
        publicabstractpartialclass AParent
        {
            publicabstractstring Type
            {
                get;
                set;
            }
        }
        publicabstractpartialclass AParent
        {
            publicabstractevent AddChildren Add;
        }

相關推薦

C#介面和抽象類:Interface、abstract

一、介面 介面是C#中很常見的工具，概念什麼的就不說了，這裡講幾個值得注意的小地方: 1、介面內部只能有函式、屬性和事件的宣告: <!--<br /> <br /> Code highlighting produced by Actip

c#介面和抽象類的區別

   大家都容易把這兩者搞混,我也一樣,在聽李建忠老師的設計模式時,他也老把抽象類說成介面,弄的我就更糊塗了,所以找了些網上的資料.       一、抽象類：     

c++介面和抽象類

其實對抽象類與介面的區別一直是搞不太清楚，最近正在學習《設計模式》，期間用到了很多c++多型的知識。這是才恍然發現，是應該整理下這方面的知識了。但在翻閱書本、上網查閱資料之際，發現有篇文章總結的不錯。於是，轉載（博主勿怪）並稍作修改如下： 抽象類：抽象類是特殊的類，只是不能

C#中的介面和抽象類學習

今天學習了介面和抽象類，但並沒有很好的進行整理，所以現在寫的時候，腦子裡多少有點亂亂的，先從介面開始吧。 interface 介面，規定了所有派生類的需要遵循的標準，介面定義了需要做些什麼，但是沒有具體的做法，做法的實現由派生類來做。 介面的定義使用關鍵字Interface，由於需要派生類繼承，所以

Java序列化的方式、object類中的方法、介面和抽象類的區別、ArrayList在迴圈過程中刪除

Java序列化的方式 a.是相應的物件實現了序列化介面Serializable，這個使用的比較多，對於序列化介面Serializable介面是一個空的介面，它的主要作用就是標識這個物件時可序列化的，jre物件在傳輸物件的時候會進行相關的封裝。 b.Externlizab

java介面和抽象類的區別和作用（功能、用途、好處）

Java介面： 總結了4點關於JAVA中介面存在的意義：        1、重要性：在Java語言中， abstract class 和interface 是支援抽象類定義的兩種機制。正是由於這兩種機制的存在，才賦予了Java強大的 面向物件能力。

一、面試準備--介面和抽象類有什麼區別

對於面向物件程式設計來說，抽象是它的一大特徵之一。在Java中，可以通過兩種形式來體現OOP的抽象：介面和抽象類。 首先，看一下兩者的定義： 抽象類 抽象類是用來捕捉子類的通用特性的 。它不能被例項化，只能被用作子類的超類。抽象類是被用來建立繼承層級裡子類的模板。

Java基礎學習之介面和抽象類的概念、區別及適用的場景

1.介面   介面是抽象方法的集合，一個介面只有方法的形狀而沒有方法的具體實現，介面是Java面向物件提供的一種機制。   Java語言是一種單繼承的，在類的繼承中通過實現多個介面間接實現了多繼承功能。介面的宣告： [public] interface InterfaceName{

介面 interface 介面和抽象類的比較

  接口裡不能包含普通方法，藉口裡所有方法都是抽象方法。   [修飾符] interface 介面名 extends  父介面1，父介面2...{    零個到多個常量定義   零個到多個抽象方法定義

C#基礎系列——一場風花雪月的邂逅：介面和抽象類

前言：最近一個認識的朋友準備轉行做程式設計，看他自己邊看視訊邊學習，挺有幹勁的。那天他問我介面和抽象類這兩個東西，他說，既然它們如此相像， 我用抽象類就能解決的問題，又整個接口出來幹嘛，這不是誤導初學者嗎。博主呵呵一笑，回想當初的自己，不也有此種疑惑麼。。。今天打算針對他的問題，結合一個實際的使用場景來說明下

java自動拆裝箱，介面和抽象類

1.Java支援的資料型別有哪些？什麼是自動拆裝箱？ Java語言支援的8中基本資料型別是： byte short int long float double boolean char 自動裝箱是Java編譯器在基本資料型別和對應的物件包裝型別之間做的一個轉化。比如：把int轉化成Integ

JAVA：介面和抽象類的區別

1.從設計層面來說，抽象是對類的抽象，是一種模板設計 ，介面是行為的抽象，是一種行為的規範 介面 interface 抽象類 介面中所有方法都是抽象的 抽象類中可以有抽象方法和普通方法 一

介面和抽象類得區別

首先是基本定義 介面： 使用介面（interface），可以指定某個類必須實現哪些方法，但不需要定義這些方法的具體內容。 介面是通過 interface 關鍵字來定義的，就像定義一個標準的類一樣，但其中定義所有的方法都是空的。 介面中定義的所有方法都必須是公有，這

Java特性-介面和抽象類區別

抽象類是自底向上抽象出來的，介面則是自頂向下設計出來的。 抽象類是對事物本身的抽象，比如貓類，狗類就可以抽象為動物類。 介面是對行為的抽象，比如男人要吃飯，女人也要吃飯，吃飯就可以抽象為介面。 抽象類表示的是這個物件是什麼，介面表示的是這個物件能幹什麼。 所以

java類介面和抽象類的區別

全域性變數的區別 介面中所有的全域性變數預設為 public static final，處於方法區的常量池中，且是靜態域中的成員 抽象類的全域性變數無硬性約束 方法的區別 介面 介面

Java 介面和抽象類可以被new麼？——順便總結內部類

轉載：https://blog.csdn.net/hackersaillen/article/details/47281549 背景：     最近有同事跟我說了他面試時遇到的問題，考官問：“介面和抽象類可以被new嘛？”。這可能不是考官的原話，但是據他表達考官大概就是這

介面和抽象類是否繼承了Object

我們先看一下Java的幫助文件對於Object的描述： Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implem

介面和抽象類的使用上的區別和選擇

    介面與抽象類的使用上的區別和選擇：       首先，對於抽象類它的作用主要用於繼承和重寫，裡面可以有普通方法，但在設計上面，通常把其派生類的共有屬性和方法抽象出來，其中所有派生類中不變的方法，在抽象類中用普通方法寫出來，而所有派生類中變化的

介面和抽象類的相同和不同之處

共性：不斷的抽取，抽取出抽象的概念    不能建立物件（不能例項化）   區別1：與類的關係        類與介面是實現關係，一個類可以實現多個介面        類與抽象類是繼承關係，Java中的繼承是單一繼承，一個類只能有一個父類，Java中的繼承是多層繼承   區別2：成員     

如何在Java中選擇介面和抽象類

什麼是抽象類？ 摘要意味著某些東西不是完全具體的 - 它只是一個想法或某事的要點。因此，當我們討論抽象類時，它意味著一個本身沒有具體實現的類。這只是為其他具體類建立的結構或指南。我們可以說抽象類是具體類的靈魂。這就是我們“擴充套件”抽象類的原因。抽象類應該只有那些屬性和方法，沒有它們就不能存在具體的類。