【轉】C#類的分類（靜態類、實例類、嵌套類、結構、簡單的抽象類、簡單的密封類）

靜態類

--------------------------------------------------------------------------------

    靜態類就是在class關鍵字前加入了static關鍵字，基本語法是static  Class  ClassName{} 。

靜態類有幾個特色：

1.靜態類只能包括靜態成員

2.類自己沒法被實例化，也就是不能建立靜態類的對象

3.靜態類沒法被繼承

4.沒法包含實例構造方法

因此咱們在建立靜態類的時候，必須注意到以上四點，下面的實例是簡單的靜態類的使用。

靜態類實例
1 class Program
2    {
3        static void Main(string[] args)
4        {
5            //靜態類不能被實例化，由於靜態類中的成員都是靜態的，調用靜態類中的成員使用類名引用。
6              Console .WriteLine (  StaticClass.a);
7        }
8    }
9    //定義一個靜態類名字叫作StaticClass
10    static class StaticClass
11        {
12        //定義一個靜態成員
13      public  static int a=2;  
14        }
結果就是2.

  靜態類所提供的數據成員和方法成員具備惟一性，就如同使用了全局變量，因此比較適合封裝公用的成員。

結構

--------------------------------------------------------------------------------

      在c#中也有結構，結果就是幾個數據組成的數據結構，一般用來封裝小型相關變量組，結構也能夠當作是種輕量級的類，它的行爲與類類似，可是不支持複雜的類功能，例如：繼承。在結構中也能夠建立各類成員，好比：構造方法、常數、字段、方法、屬性、索引器、運算符、事件、嵌套類型等，可是若是往一個結構中放入比較複雜的成員，對與結構來講就和類沒有區別了，也就是失去告終構的特色，這時應該用建立類來代替建立結構。結構的基本語法是 public struct StructName{} 。

結構在MSDN上的概述：

結構是值類型，而類是引用類型。

與類不一樣，結構的實例化能夠不使用 new 運算符。

結構能夠聲明構造函數，但它們必須帶參數。

一個結構不能從另外一個結構或類繼承，並且不能做爲一個類的基。全部結構都直接繼承自 System.ValueType，後者繼承自 System.Object。

結構能夠實現接口。

結構的副本由編譯器自動建立和銷燬，所以不須要使用默認構造函數和析構函數。

在結構聲明中，除非字段被聲明爲 const 或 static，不然沒法初始化。

      建立結構對象的時候不須要使用new關鍵字，因爲直接存儲對象數據、省略了對象引用的步驟，同時也就提高了使用性能，這就是使用結構的好處。結構一樣具備本身專門的默認構造方法，它會自動引用，固然咱們也能夠建立自定義的構造方法，而此時就須要使用new關鍵字，引用這個構造方法了。看下面的代碼：

結構體實例
1 class Program
2    {
3        static void Main(string[] args)
4        {
5            //建立結構對象，沒必要使用new關鍵字
6            StructName structobj;
7            structobj.kuan = 3;
8            structobj.chang = 5;
9          Console .WriteLine ("面積是"+  structobj.Getmj());
10
11            //使用結構體的構造方法，必須使用和類建立對象的方法相同new
12          StructName structobj1 = new StructName(4,6);
13        }
14    }
15    //定義一個靜態類名字叫作StructName
16    public struct StructName
17        {
18        public int chang;
19        public int kuan;
20        public  int Getmj()
21        {
22            return chang * kuan;
23        }
24
25    //結構體的構造函數
26        public StructName(int chang1, int kuan1)
27        {
28          chang = chang1;
29            kuan = kuan1;
30            Console.WriteLine("使用構造方法的面積是" + chang1 *kuan1);
31        }
32        }
結果：

面積是15
使用構造方法的面積是24。

      由於結構聲明時沒法初始化，因此在使用new建立結構對象時，必須在定義結構的有參構造方法，給結構中的已定義的無初值的變量賦一個值，不然就會報錯，如程序的第2八、29行。你們能夠試一試若是是在類的有參構造方法中，即便沒有2八、29行，也能正常的編譯出結果。

  嵌套類

--------------------------------------------------------------------------------
        在類一系列中，我也提到過類成員中還包括一中嵌套類，其實嵌套類就是類中的一個類，因爲嵌套類在類的內部，屬於外部類的內部成員，因此外部類的private訪問權限對內部類是無效的，也就是說，內部類可使用外部類的任何成員，建立嵌套類insideClassName的基本語法以下：

      Class  outclassName

    {

    public  class insideclassName          

          {

            }

    }

      當外部程序代碼要訪問嵌套類的時候，必須引用外層類的名稱像引出外部類的其餘靜態成員同樣使用類名加運算符「.」的方式,建立嵌套類的對象具體語法以下：

        outclassName.insideclassName  bj=new  outclassName.insideclassName（）；

        若是再用嵌套類的對象時，再使用obj.的方式引用出，咱們來看下面的例子：

嵌套類實例
1namespace hello
2{
3    class program
4    {
5        static void Main(string[] args)
6        {
7            //建立內部類的實例，必須把內部類做爲靜態成員，使用外部類名來引用
8            //而使用外部類的實例成員，必須使用外部類的對象來引用
9            outclassName.insideclassName i = new outclassName.insideclassName();
10
11            //用內部類的對象引用出內部類的實例成員（方法say（））
12            i.say();
13        }
14    }
15    //定義一個外部類
16    class outclassName
17    {
18        //定義一個外部類的變量s，它的訪問權限是私有的。
19      string s = "我是外部類的變量s";
20        //定義一個內部類，由於它是外部類中的一個類成員，在第三方類（Program）中，
21        //要想調用這個類中，就必須加上public，和其餘外部類的公用方法同樣。
22      public class insideclassName
23        {
24            //建立一個外部類的對象o，用於便於內部類訪問外部類成員。
25            outclassName o = new outclassName();
26            //定義一個內部類的方法say
27            public void say()
28            {
29                //調用外部類中的字段s，使用外部類的對象o來引用，並且s的訪問權限沒必要是public。
30                Console.WriteLine("用內部的方法調出外部的變量"+o.s);
31            }
32        }
33    }
34  
35}
結果就是：

用內部的方法調出外部的變量我是外部類的變量s
請按任意鍵繼續. . .

        使用嵌套類注意：嵌套類要想被其餘類訪問到，必須像外部類的一個公用成員同樣，要加public修飾符；建立嵌套類的對象時，要用外部類的類名來調用，這有點像把內部的嵌套類做爲外部類的一個靜態成員來使用；嵌套類要想使用外部類的成員，也是須要建立用外部類名（.靜態成員）或是外部類的對象(.實例成員)來調用，惟一與兩個並列類訪問不一樣的是，嵌套類能夠調用外部類的私有成員（private修飾），而並列類只能用公有成員（public修飾）。

      下面咱們要來學習最後兩個類，這兩個類我在標題的時候註明了是簡單的抽象類和簡單的密封類，緣由就是這兩個類都是面嚮對象語言相對面向過程的一大進步，他們利用了面向對象的繼承性，要想學懂這兩個類必須在學到繼承後，再相信的講解，這裏我只是把他們的大致定義和基本結構寫明，具體的應用我會在學習繼承的時候，着重講解。

抽象類

--------------------------------------------------------------------------------

      在實際項目中，咱們定義一個抽象類主要是爲派生類提供可共享的基類的公共定義，抽象類中能夠包括抽象方法，抽象方法就是沒有方法體，只有方法的定義，抽象方法具體由繼承這個包含抽象方法的抽象類的子類中的方法來實現。是否是很難理解呢？不要緊！同窗們，如今咱們只須要記住由於一個類中有了沒有實現的抽象方法，因此把這個類也定義爲抽象類，也就是說，抽象方法必定在抽象類中，可是抽象類中能夠沒有抽象方法，抽象類的和抽象方法都須要加入關鍵字abstract，下面咱們來必定一個抽象類，而且這個抽象類中包括一個抽象方法，你們先記住他們的基本語法，往後我會詳細講解。  

抽象方法的基本語法
1    //定義一個抽象類abstractclassName
2    abstract class abstractclassName
3    {
4        //定義一個抽象方法abstractMethods
5        abstract public void abstractMethods();
6    }
7  
      使用抽象類還要記住二點，一：由於抽象類中有可能存在抽象方法，也就是存在沒有實現的方法，因此抽象類沒法被實例化，也就是沒法建立類的實例對象；二：定義抽象方法的時候，爲了讓繼承的子類可以實現這個抽象方法，也就必須把抽象的方法定義成公有成員，這樣在抽象類的外部才能訪問到這個抽象方法。

密封類

--------------------------------------------------------------------------------

    密封類的定義是經過sealed關鍵字來實現的，密封類能夠用來限制擴展性，我也聽過把密封類叫成太監類的說法，很形象的說明了密封類的特色，就是沒有子類，也就是密封類沒法被繼承，這一點和靜態類同樣，下面來看看密封類的基本語法：

sealed class sealedclassName
    {

        類的主體；
    }

    密封類除了不能被繼承，其餘的用法和實例類基本一致，能夠有多個構造方法，能夠有靜態的、也能夠有實例的，類的成員也是能夠有靜態的和實例的。因此就再也不演示密封類的用法了，對於密封類來講，它與面向對象編程技術的靈活性和擴展性是相抵觸的，因此一般狀況下，不建議定義密碼類。   靜態類、實例類、嵌套類、結構、簡單的抽象類、簡單的密封類

確實比較有趣。。這裏 1.靜態類，2.結構，3.密封類 這三者，都是 揮刀自宮，沒有 OO特性的。——要了解OO特性，其實很簡單，只須要打開設計模式的 PPT，看看那些類圖。。設計模式中大量使用到了 OO特性。。反過來講，設計模式類圖中用不到的 這些 構造塊，其實，極可能就是沒有 OO特性的。。

1.靜態類：與靜態有關的任何構造塊，所有沒有 OO特性。所謂靜態，即爲全局，之因此要全局，就是爲了‘穩定’——而 OO特性，天生是爲了 OCP 爲了可擴展，面對變化——因此，靜態static關鍵字 出現的地方，就失去OO特性。 單例模式中的static，其實只是爲了讓 類的使用者至少能有辦法拿到該類的實例，並非體現 OO特性。

2.結構：這確實是一個很是有意思的東西。由於在C++中，大量使用結構，而Java中徹底摒棄 結構 。首先，結構是 值類型。C++中，絕大部分的類型都是 值類型。若是要讓值類型得到 引用類型 的特徵，須要‘取地址’操做，獲得的地址以後操做地址，纔有了面向對象的意義——GOF23種設計模式，首先是針對C++編寫的，我的觀點，對於老前輩，仍是要給於必定的尊重。

反過來，Java做爲對C++某種程度上的顛覆，除了8種基本類型（不是對象）外，全部的自定義類型都是 引用類型。Java，10幾年來，變化確實比較小，這也是它最近被詬病不能與時俱進的一大杯具。但，把OO精神推向縱深的貌似要屬它。由於學習曲線低，很容易入門。除了8種基本類型（這些類型不用學，基本上全部語言都用），只要你自定義了類型，它天生就是 引用類型。

再看看C#。。這位老兄的優點是，背靠大山，得天獨厚。它既保留了C++複雜語法中，關於值類型（能夠自定義的值類型，就是 Struct——ValueType。。枚舉類型其實也是一種結構）的部分，又大量借鑑了Java的引用類型。若是使用C#，又須要寫出 OO風格 的代碼，固然，最好多使用 Class，而不是 Struct。Struct的用武之地，在於封裝那些不太賦予變化的值，像枚舉這樣的封裝，也有很大用處。

3.密封類。這個構造大概基本上會在 框架 中用到較多。咱們本身寫的類，若是不想被別人繼承，那就把類標記成 Internal，別人也就看不到你這個類了。——固然，若是別人能拿到源碼，或者反編譯獲得，那就是兩碼事了。。那你用sealed關鍵字，豈非也是不保險的。。人家能夠改嘛。