C# 中類的基本概念

• 一、類的概述
• 二、程式和類：一個簡單的示例
• 三、宣告類
• 四、類成員
  • 4.1 欄位
  • 4.2 方法
• 五、創建變數和類的實體
• 六、為資料分配記憶體
• 七、實體成員
• 八、訪問修飾符
• 九、從類的內部訪問成員
• 十、從類的外部訪問成員
• 十一、綜合應用

一、類的概述

在上一篇文章中（https://www.dotnetprimer.com/csharp/01-types-and-variables-in-csharp/#六用戶定義型別），我們看到 C# 提供了 6 種用戶定義型別，其中最重要的，也是首先要闡述的是類，因為類在 C# 中是個很大的主題，所以關于它的討論將會延伸到接下來的幾篇文章，

類是一種活動的資料結構

在面向物件的分析和設計出現之前，程式員們僅把程式當作指令的序列，那時的焦點主要放在指令的組合和優化上，隨著面向物件的出現，焦點從優化指令轉移到組織程式的資料和功能上來，程式的資料和功能被組織為邏輯上相關的資料項和函式的封裝集合，并被稱為類，

類是一個能存盤資料并執行代碼的資料結構，它包含資料成員和函式成員，

• 資料成員 它存盤與類或類的實體相關的資料，資料成員通常模擬該類所表示的現實世界事物的特性，
• 函式成員 它執行代碼，通常會模擬類所表示的現實世界事物的功能和操作，

一個 C# 類可以有任意數目的資料成員和函式成員，成員可以是 9 種成員型別的任意組合，這些成員型別如下表所示，

說明 類是邏輯相關的資料和函式的封裝，通常代表真實世界中或概念上的事物，

二、程式和類：一個簡單的示例

一個運行中的 C# 程式是一組相互作用的型別物件，它們中的大部分是類的實體，例如，假設有一個模擬撲克牌游戲的程式，當程式運行時，它有一個名為 Dealer 的類實體，它的作業就是運行游戲，還有幾個名為 Player 的類實體，它們代表游戲的玩家，

Dealer 物件保存紙牌的當前狀態和玩家數目等資訊，它的動作包括洗牌和發牌，

Player 類有很大不同，它保存玩家名稱以及用于押注的錢等資訊，并實作如分析玩家當前手上的牌和出牌這樣的動作，運行中的程式如下圖所示，類名顯示在方框外面，實體名顯示在方框內，

一個真正的程式無疑會包含除 DeaLer 和 Player 之外的許多具他的類，還會包括像 Card 和 Deck 這樣的類，每一個類都模擬某種撲克牌游戲中的事物，

說明 運行中的程式是一組相互作用的物件的集合，

三、宣告類

或許你能猜到，雖然型別 int、double 和 char 由 C# 定義，但像 Dealer 和 Player 這樣的類不是由語言定義的，如果想在程式中使用它們，你必須通過撰寫類的宣告自己定義它們，

類的宣告定義新類的特征和成員，它并不創建類的實體，但創建用于創建實體的模板，類的宣告提供下列內容：

• 類的名稱；
• 類的成員；
• 類的特征，

下面是一個最簡單的類宣告語法示例，大括號內包含了成員的宣告，它們組成了類主體，類成員可以在類主體內部以任何順序宣告，這意味著一個成員的宣告完全可以參考另一個在后面的類宣告中才定義的成員，

下面的代碼給出了兩個類宣告的概貌：

class Dealer    // 類宣告
{
    ...
}

class Player    // 類宣告
{
    ...
}

說明 因為類宣告“定義”了一個新類，所以經常會在文獻和程式員的日常使用中看到類宣告被稱為類定義，

四、類成員

欄位和方法是最重要的類成員型別，欄位是資料成員，方法是函式成員，

4.1 欄位

欄位是隸屬于類的變數，

• 它可以是任何型別，無論是預定義型別還是用戶定義型別，
• 和所有變數一樣，欄位用來保存資料，并具有如下特征：
  • 可以被寫入；
  • 可以被讀取，

宣告一個欄位最簡單的陳述句如下：

例如，下面的類包含欄位 MyField 的宣告，它可以保存 int 值：

class MyClass
{
    int MyField;
}

說明 與 C 和 C++ 不同，C# 在型別的外部不能宣告全域變數（也就是變數或欄位），所有的欄位都屬于型別，而且必須在型別宣告內部宣告，

1. 顯式和隱式欄位初始化

因為欄位是一種變數，所以欄位初始化陳述句在語法上和上一篇（[{{< ref "01-04-型別和變數.md#91-變數宣告" >}}]({{< ref "01-04-型別和變數.md#91-變數宣告" >}})）所述的變數初始化陳述句相同，

• 欄位初始化陳述句是欄位宣告的一部分，由一個等號后面跟著一個求值運算式組成，

• 初始化值必須是編譯時可確定的，

  class MyClass
  {
      int f1 = 17;
  }
  

• 如果沒有初始化陳述句，欄位的值會被編譯器設為默認值，默認值由欄位的型別決定，簡單型別的默認值見（[{{< ref "01-04-型別和變數.md#五預定義型別" >}}]({{< ref "01-04-型別和變數.md#五預定義型別" >}})），可是總結起來，每種值型別的默認值都是 0，bool 型的默認值是 false，參考型別的默認值為 null，

例如，下面的代碼宣告了 4 個欄位，前面兩個欄位被隱式初始化，另外兩個欄位被初始化陳述句顯示初始化，

class MyClass
{
    int f1;               // 初始化為 0     - 值型別
    string f2;            // 初始化為 null  - 參考型別

    int f3 = 25;          // 初始化為 25
    string f4 = "abcd";   // 初始化為 “abcd”
}

2. 宣告多個欄位

可以通過用逗號分隔名稱的方式，在同一條陳述句中宣告多個相同型別的欄位，但不能在一個宣告中混合不同的型別，例如，可以把之前的 4 個欄位宣告結合成兩條陳述句，語意結果相同，

int f1,f3 = 25;
string f2,f4 = "abcd";

4.2 方法

方法是具有名稱的可執行代碼塊，可以從程式的很多不同地方執行，甚至從其他程式中執行，

當方法被呼叫（call/invoke）時，它執行自己所含的代碼，然后回傳到呼叫它的代碼并繼續執行呼叫代碼，有些方法回傳一個值到它們被呼叫的位置，方法相當于 C++ 中的成員函式，

宣告方法的最簡語法包括以下組成部分，

• 回傳型別 它宣告了方法回傳值的型別，如果一個方法不回傳值，那么回傳型別被指定為 void，
• 名稱 這是方法的名稱，
• 引數串列 它至少由一對空的圓括號組成，如果有引數（[{{< ref "01-06-方法和引數.md" >}}]({{< ref "01-06-方法和引數.md" >}})），將被列在圓括號中間，
• 方法體 它由一對大括號組成，大括號內包含執行代碼，

例如，下面的代碼宣告了一個類，帶有一個名為 PrintNums 的簡單方法，從這個宣告中可以看出下面幾點關于 PrintNums 的情況：

• 它不回傳值，因此回傳型別指定為 void；
• 它有空的引數串列；
• 它的方法體有兩行代碼，其中第 1 行列印數字 1，第 2 行列印數字 2，

class SimpleClass
{
    void PrintNums()
    {
        Console.WriteLine("1");
        Console.WriteLine("2");
    }
}

說明與 C 和 C++ 不同，C# 中沒有全域函式（也就是方法或函式）宣告在型別宣告的外部，同樣，和 C/C++ 不同，C# 中方法沒有默認的回傳型別，所有方法必須包含回傳型別或 void，

五、創建變數和類的實體

類的宣告只是用于創建類的實體的藍圖，一旦類被宣告，就可以創建類的實體，

• 類是參考型別，正如你從上一篇（[{{< ref "01-04-型別和變數.md#八值型別和參考型別" >}}]({{< ref "01-04-型別和變數.md#八值型別和參考型別" >}})）了解到的，這意味著它們要為資料參考和實際資料都申請記憶體，
• 資料的參考保存在一個型別別的變數中，所以，要創建類的實體，需要從宣告一個型別別的變數開始，如果變數沒有被初始化，它的值是未定義的，

下圖闡明了如何定義保存參考的變數，左邊頂端的代碼是類 Dealer 的宣告，下面是類 Program 的宣告，它包含 Main 方法，Main 宣告了 Dealer 型別的變數 theDealer，因為該變數沒有初始化，所以它的值是未定義的，

六、為資料分配記憶體

宣告型別別的變數所分配的記憶體是用來保存參考的，而不是用來保存類物件實際資料的，要為實際資料分配記憶體，需要使用 new 運算子，

• new 運算子為任意指定型別的實體分配并初始化記憶體，它依據型別的不同，從堆疊或堆里分配，

• 使用 new 運算子組成的一個物件創建運算式，它的組成如下：

  • 關鍵字 new;

  • 要分配記憶體的實體的型別名稱；

  • 成對的括號，可能包括引數也可能沒有引數，

    

• 如果將記憶體分配給一個參考型別，則物件創建運算式回傳一個參考，指向在堆中被分配并初始化的物件實體，

要分配和初始化用于保存類實體資料的記憶體，需要的作業就是這些，下面是使用 new 運算子創建物件創建運算式，并把它的回傳值賦給類變數的一個例子：

Dealer theDealer;            // 宣告參考變數
theDealer = new Dealer();    // 為類物件分配記憶體并賦值給變數

下圖左邊的代碼展示了用干分配記憶體并創建類 Dealer 實體的 new 云算符，隨后實體被賦值給類變數，右邊的圖展示了記憶體的結構，

合并這兩個步驟

可以將這兩個步驟合并起來，用物件創建運算式來初始化變數，

Dealer theDealer = new Dealer();    // 宣告并初始化

七、實體成員

類宣告相當于藍圖，通過這個藍圖想創建多少個類的實體都可以，

• 實體成員 類的每個實體都是不同的物體，它們有自己的一組資料成員，不同于同一類的其他實體，因為這些資料成員都和類的實體相關，所以被稱為實體成員，
• 靜態成員 實體成員是默認型別，但也可以宣告與類而不是實體相關的成員，稱為靜態成員，

下面的代碼是實體成員的示例，展示了有 3 個 Player 類實體的撲克牌程式，下圖表明每個實體的 Name 欄位都有不同的值，

class Dealer {...}    // 宣告類
class Player          // 宣告類
{
    string Name;      // 欄位
        ...
}

class Program
{
    static void Main()
    {
        Dealer theDealer = new Dealer();
        Player player1 = new Player();
        Player player2 = new Player();
        Player player3 = new Player();
        ...
    }
}

八、訪問修飾符

從類的內部，任何函式成員都可以使用成員的名稱訪問類中任意的其他成員，

訪問修飾符是成員宣告的可選部分，指明程式的其他部分如何訪問成員，訪問修飾符放在簡單宣告形式之前，下面是欄位和方法宣告的語法：

欄位

訪問修飾符 型別 識別符號;

方法

訪問修飾符 回傳型別 方法名()
{
    ...
}

5 種成員訪問控制如下，本文將闡述前兩種，

• 私有的（private）；
• 公有的（public）；
• 受保護的（protected）；
• 內部的（internal）；
• 受保護內部的（protected internal），

私有訪問和公有訪問

私有成員只能從宣告它的類的內部訪問，其他的類看不見或無法訪問它們，

• 私有訪問是默認的訪問級別，所以，如果一個成員在宣告時不帶訪問修飾符，那它就是私有成員，
• 還可以使用 private 訪問修飾符顯式地將一個成員宣告為私有，隱式地宣告私有成員和顯式地宣告在語意上沒有不同，兩種形式是等價的，

例如，下面的兩個宣告都指定了 private int 成員：

int MyInt1;            // 隱式宣告為私有
private int MyInt2;    // 顯示宣告為私有

實體的公有成員可以被程式中的其他物件訪問，必須使用 public 訪問修飾符指定公有訪問，

public int MyInt;

1. 公有訪問和私有訪問圖示

本文中的插圖把類表示為標簽框，如下圖所示，

• 類成員為類框中的小標簽框，
• 私有成員完全封閉在它們的類框中，
• 公有成員有一部分伸出它們的類框之外，

2. 成員訪問示例

類 C1 宣告了公有和私有的欄位和方法，下圖闡明了類 C1 的成員的可見性，

class C1
{
    int F1;               // 隱式私有欄位
    private int F2;       // 顯示私有欄位
    public int F3;        // 公有欄位

    void DoCalc()         // 隱式私有方法
    {
        ...
    }

    public int GetVal()    // 公有方法
    {
        ...
    }
}

九、從類的內部訪問成員

如前所述，類的成員僅用其他類成員的名稱就可以訪問它們，

例如，下面的類宣告展示了類的方法對欄位和其他方法的訪問，即時欄位和兩個方法被宣告為 private，類的所有成員還是可以被類的任何方法（或任何函式成員）訪問，下圖闡明了這段代碼，

class DaysTemp
{
    // 欄位
    private int High = 75;
    private int Low = 45;

    // 方法
    private int GetHigh()
    {
        return High;  // 訪問私有欄位
    }

    private int GetLow()
    {
        return Low;  // 訪問私有欄位
    }

    public float Average()
    {
        return (GetHigh() + GetLow()) / 2;  //  訪問私有方法
    }

}

十、從類的外部訪問成員

要從類的外部訪問實體成員，必須包括變數名稱和成員名稱，中間用句點（.）分隔，這稱為點運算子（dot-syntax notation），后文會詳細討論，

例如，下面代碼的第二行展示了一個從類的外部訪問方法的示例：

DaysTemp myDt = new DaysTemp();  // 創建類的物件
float fValue = https://www.cnblogs.com/vin-c/p/myDt.Average();   // 從外部訪問

舉個例子，下面的代碼宣告了兩個類：DaysTemp 和 Program，

• DaysTemp 內的兩個欄位被宣告為 public，所以可以從類的外部訪問它們，
• 方法 Main 是類 Program 的成員，它創建了一個變數和類 DaysTemp 的物件，并給物件的欄位賦值，然后它讀取欄位的值并列印出來，

class DaysTemp  // 宣告類 DaysTemp
{
    public int High = 75;
    public int Low = 45;
}

class Program  // 宣告類 Program
{
    static void Main()
    {
        DaysTemp temp = new DaysTemp();  // 創建物件
        temp.High = 85;  // 欄位賦值
        temp.Low = 60;

        Console.WriteLine($"High: {temp.High}"); // 讀取欄位值
        Console.WriteLine($"Low: {temp.Low}");
    }
}

輸出：

High: 85
Low: 60

十一、綜合應用

下面的代碼創建兩個實體并把它們的參考保存在名稱為 t1 和 t2 的變數中，下圖闡明了記憶體中的 t1 和 t2，這段代碼示范了目前為止討論的使用類的 3 種行為：

• 宣告一個類；
• 創建類的實體；
• 訪問類的成員（也就是寫入欄位和讀取欄位），

class DaysTemp  // 宣告類
{
    public int High, Low;  // 宣告實體欄位

    public int Average()
    {
        return (High + Low) / 2;
    }
}

class Program
{
    static void Main()
    {
        // 創建兩個 DaysTemp 實體
        DaysTemp t1 = new DaysTemp();
        DaysTemp t2 = new DaysTemp();

        // 給欄位賦值
        t1.High = 76;
        t1.Low = 57;

        t2.High = 75;
        t2.Low = 53;

        // 讀取欄位值
        // 呼叫實體的方法

        Console.WriteLine($"t1: {t1.High}, {t1.Low}, {t1.Average()}");
        Console.WriteLine($"t2: {t2.High}, {t2.Low}, {t2.Average()}");
    }
}

輸出：

t1: 76, 57, 66
t2: 75, 53, 64

原文鏈接：https://www.dotnetprimer.com/csharp/01-classes-in-csharp

（完）

標籤：C#

上一篇：Redis分布式快取系列（四）- Redis中的Set型別

下一篇：詳細介紹 C# 中的方法和引數