C# 面向對象編程 · ZetCode 中文系列教程

# C# 面向對象編程 > 原文： [https://zetcode.com/lang/csharp/oopi/](https://zetcode.com/lang/csharp/oopi/) 在 C# 教程的這一部分中，我們將討論 C# 中的面向對象編程。共有三種廣泛使用的編程范例：過程編程，函數編程和面向對象的編程。 C# 支持過程式編程和面向對象的編程。 ## OOP 定義面向對象編程（OOP）是一種使用對象及其相互作用設計應用和計算機程序的編程范例。 OOP 中有一些基本的編程概念： * 抽象 * 多態 * 封裝 * 繼承抽象通過建模適合該問題的類來簡化復雜的現實。多態是將運算符或函數以不同方式用于不同數據輸入的過程。封裝對其他對象隱藏了類的實現細節。繼承是一種使用已經定義的類形成新類的方法。 ## C# 對象對象是 C# OOP 程序的基本構建塊。對象是數據和方法的組合。數據和方法稱為對象的成員。在 OOP 程序中，我們創建對象。這些對象通過方法進行通信。每個對象都可以接收消息，發送消息和處理數據。創建對象有兩個步驟。首先，我們定義一個類。類是對象的模板。它是一個藍圖，描述了類對象共享的狀態和行為。一個類可以用來創建許多對象。在運行時從類創建的對象稱為該特定類的實例。 `Program.cs` ```cs using System; namespace Being { class Being {} class Program { static void Main(string[] args) { var b = new Being(); Console.WriteLine(b); } } } ``` 在第一個示例中，我們創建一個簡單的對象。 ```cs class Being {} ``` 這是一個簡單的類定義。模板的主體為空。它沒有任何數據或方法。 ```cs var b = new Being(); ``` 我們創建`Being`類的新實例。為此，我們使用了`new`關鍵字。 `b`變量是創建對象的句柄。 ```cs Console.WriteLine(b); ``` 我們將對象打印到控制臺以獲取該對象的一些基本描述。打印對象是什么意思？實際上，當我們打印對象時，我們將其稱為`ToString()`方法。但是我們還沒有定義任何方法。這是因為創建的每個對象都繼承自基本`object`。它具有一些基本功能，可以在所有創建的對象之間共享。其中之一是`ToString()`方法。 ```cs $ dotnet run Being.Being ``` 我們得到對象類名。 ## C# 對象屬性對象屬性是捆綁在類實例中的數據。對象屬性稱為實例變量或成員字段。實例變量是在類中定義的變量，該類中的每個對象都有一個單獨的副本。 `Program.cs` ```cs using System; namespace ObjectAttributes { class Person { public string name; } class Program { static void Main(string[] args) { var p1 = new Person(); p1.name = "Jane"; var p2 = new Person(); p2.name = "Beky"; Console.WriteLine(p1.name); Console.WriteLine(p2.name); } } } ``` 在上面的 C# 代碼中，我們有一個帶有一個成員字段的`Person`類。 ```cs class Person { public string name; } ``` 我們聲明一個名稱成員字段。 `public`關鍵字指定可以在類塊之外訪問成員字段。 ```cs var p1 = new Person(); p1.name = "Jane"; ``` 我們創建`Person`類的實例，并將名稱變量設置為`"Jane"`。我們使用點運算符來訪問對象的屬性。 ```cs var p2 = new Person(); p2.name = "Beky"; ``` 我們創建`Person`類的另一個實例。在這里，我們將變量設置為`"Beky"`。 ```cs Console.WriteLine(p1.name); Console.WriteLine(p2.name); ``` 我們將變量的內容打印到控制臺。 ```cs $ dotnet run Jane Beky ``` 我們看到了程序的輸出。 `Person`類的每個實例都有一個單獨的名稱成員字段副本。 ## C# 方法方法是在類主體內定義的函數。它們用于通過對象的屬性執行操作。方法將模塊化帶入我們的程序。在 OOP 范式的封裝概念中，方法至關重要。例如，我們的`AccessDatabase`類中可能有一個`Connect()`方法。我們無需知道方法`Connect()`如何精確地連接到數據庫。我們只需要知道它用于連接數據庫。這對于劃分編程中的職責至關重要，尤其是在大型應用中。對象將狀態和行為分組，方法代表對象的行為部分。 `Program.cs` ```cs using System; namespace Methods { class Circle { private int radius; public void SetRadius(int radius) { this.radius = radius; } public double Area() { return this.radius * this.radius * Math.PI; } } class Program { static void Main(string[] args) { var c = new Circle(); c.SetRadius(5); Console.WriteLine(c.Area()); } } } ``` 在代碼示例中，我們有一個`Circle`類。我們定義了兩種方法。 ```cs private int radius; ``` 我們只有一個成員字段。它是圓的半徑。 `private`關鍵字是訪問說明符。它表明變量僅限于外部世界。如果要從外部修改此變量，則必須使用公共可用的`SetRadius()`方法。這樣我們可以保護我們的數據。 ```cs public void SetRadius(int radius) { this.radius = radius; } ``` 這是`SetRadius()`方法。 `this`變量是一個特殊變量，我們用它來訪問方法中的成員字段。 `this.radius`是實例變量，而半徑是局部變量，僅在`SetRadius()`方法內部有效。 ```cs var c = new Circle(); c.SetRadius(5); ``` 我們創建`Circle`類的實例，并通過在圓對象上調用`SetRadius()`方法來設置其半徑。我們使用點運算符來調用該方法。 ```cs public double Area() { return this.radius * this.radius * Math.PI; } ``` `Area()`方法返回圓的面積。 `Math.PI`是內置常數。 ```cs $ dotnet run 78.5398163397448 ``` 運行該示例可得出此結果。 ## C# 訪問修飾符訪問修飾符設置方法和成員字段的可見性。 C# 具有四個基本訪問修飾符：`public`，`protected`，`private`和`internal`。可以從任何地方訪問`public`成員。 `protected`成員只能在類本身內部以及繼承的和父類訪問。 `private`成員僅限于包含類型，例如僅在其類或接口內。可以從同一程序集（exe 或 DLL）中訪問`internal`成員。修飾符還有兩種組合：`protected internal`和`private protected`。 `protected internal`類型或成員可以由聲明它的程序集中的任何代碼訪問，也可以從另一個程序集中的派生類中訪問。 `private protected`類型或成員只能在其聲明程序集中通過同一個類或從該類派生的類型的代碼進行訪問。訪問修飾符可防止意外修改數據。它們使程序更強大。 | | 類 | 當前程序集 | 派生類 | 當前程序集中的派生類 | 整個程序 | | --- | --- | --- | --- | --- | --- | | `public` | `+` | `+` | `+` | `+` | `+` | | `protected` | `+` | `o` | `+` | `+` | `o` | | `internal` | `+` | `+` | `o` | `o` | `o` | | `private` | `+` | `o` | `o` | `o` | `o` | | `protected internal` | `+` | `+` | `+` | `+` | `o` | | `private protected` | `+` | `o` | `o` | `+` | `o` | 上表總結了 C# 訪問修飾符（`+`是可訪問的，`o`是不可訪問的）。 `Program.cs` ```cs using System; namespace AccessModifiers { class Person { public string name; private int age; public int GetAge() { return this.age; } public void SetAge(int age) { this.age = age; } } class Program { static void Main(string[] args) { var p = new Person(); p.name = "Jane"; p.SetAge(17); Console.WriteLine("{0} is {1} years old", p.name, p.GetAge()); } } } ``` 在上面的程序中，我們有兩個成員字段。一個被宣布為公開，另一個被宣布為私有。 ```cs public int GetAge() { return this.age; } ``` 如果成員字段是`private`，則訪問它的唯一方法是通過方法。如果要在類外部修改屬性，則必須將方法聲明為`public`。這是數據保護的重要方面。 ```cs public void SetAge(int age) { this.age = age; } ``` `SetAge()`方法使我們能夠從類定義之外更改`private`年齡變量。 ```cs var p = new Person(); p.name = "Jane"; ``` 我們創建`Person`類的新實例。因為名稱屬性是`public`，所以我們可以直接訪問它。但是，不建議這樣做。 ```cs p.SetAge(17); ``` `SetAge()`方法修改年齡成員字段。由于已聲明`private`，因此無法直接訪問或修改。 ```cs Console.WriteLine("{0} is {1} years old", p.name, p.GetAge()); ``` 最后，我們訪問兩個成員以構建一個字符串。 ```cs $ dotnet run Jane is 17 years old ``` 運行示例將給出此輸出。具有`private`訪問修飾符的成員字段不被派生類繼承。 `Program.cs` ```cs using System; namespace Protected { class Base { public string name = "Base"; protected int id = 5323; private bool isDefined = true; } class Derived : Base { public void info() { Console.WriteLine("This is Derived class"); Console.WriteLine("Members inherited"); Console.WriteLine(this.name); Console.WriteLine(this.id); // Console.WriteLine(this.isDefined); } } class Program { static void Main(string[] args) { var derived = new Derived(); derived.info(); } } } ``` 在前面的程序中，我們有一個`Derived`類，該類繼承自`Base`類。 `Base`類具有三個成員字段。全部具有不同的訪問修飾符。 `isDefined`成員不繼承。 `private`修飾符可以防止這種情況。 ```cs class Derived : Base ``` 類`Derived`繼承自`Base`類。要從另一個類繼承，我們使用冒號（:)運算符。 ```cs Console.WriteLine(this.name); Console.WriteLine(this.id); // Console.WriteLine(this.isDefined); ``` `public`和`protected`成員由`Derived`類繼承。可以訪問它們。 `private`成員未繼承。訪問成員字段的行被注釋。如果我們取消注釋該行，則代碼將無法編譯。 ```cs $ dotnet run Program.cs(9,22): warning CS0414: The field 'Base.isDefined' is assigned but its value is never used [C:\Users\Jano\Documents\csharp\tutorial\oop\Protected\Protected.csproj] This is Derived class Members inherited Base 5323 ``` 運行程序，我們收到此輸出。 ## C# 構造器構造器是一種特殊的方法。創建對象時會自動調用它。構造器不返回值。構造器的目的是初始化對象的狀態。構造器與類具有相同的名稱。構造器是方法，因此它們也可以重載。構造器不能被繼承。它們按繼承順序被調用。如果我們不為類編寫任何構造器，則 C# 提供一個隱式默認構造器。如果提供任何類型的構造器，則不提供默認值。 `Program.cs` ```cs using System; namespace Constructor { class Being { public Being() { Console.WriteLine("Being is created"); } public Being(string being) { Console.WriteLine("Being {0} is created", being); } } class Program { static void Main(string[] args) { new Being(); new Being("Tom"); } } } ``` 我們有一個`Being`類。此類具有兩個構造器。第一個不帶參數；第二個采用一個參數。 ```cs public Being(string being) { Console.WriteLine("Being {0} is created", being); } ``` 此構造器采用一個字符串參數。 ```cs new Being(); ``` 創建`Being`類的實例。這次，在創建對象時調用沒有參數的構造器。 ```cs $ dotnet run Being is created Being Tom is created ``` 這是程序的輸出。在下一個示例中，我們初始化類的數據成員。變量的初始化是構造器的典型工作。 `Program.cs` ```cs using System; namespace Constructor2 { class MyFriend { private DateTime born; private string name; public MyFriend(string name, DateTime born) { this.name = name; this.born = born; } public void Info() { Console.WriteLine("{0} was born on {1}", this.name, this.born.ToShortDateString()); } } class Program { static void Main(string[] args) { var name = "Lenka"; var born = new DateTime(1990, 3, 5); var friend = new MyFriend(name, born); friend.Info(); } } } ``` 我們有一個帶有數據成員和方法的`MyFriend`類。 ```cs private DateTime born; private string name; ``` 類定義中有兩個私有變量。 ```cs public MyFriend(string name, DateTime born) { this.name = name; this.born = born; } ``` 在構造器中，我們啟動兩個數據成員。 `this`變量是用于引用對象變量的處理器。 ```cs var friend = new MyFriend(name, born); friend.Info(); ``` 我們創建帶有兩個參數的`MyFriend`對象。然后我們調用對象的`Info()`方法。 ```cs $ dotnet run Lenka was born on 3/5/1990 ``` 這是輸出。 ## C# 構造器鏈接構造器鏈接是類從構造器調用另一個構造器的能力。要從同一類調用另一個構造器，我們使用`this`關鍵字。 `Program.cs` ```cs using System; namespace ConstructorChaining { class Circle { public Circle(int radius) { Console.WriteLine("Circle, r={0} is created", radius); } public Circle() : this(1) { } } class Program { static void Main(string[] args) { new Circle(5); new Circle(); } } } ``` 我們有一個`Circle`類。該類具有兩個構造器。一種采用一個參數，一種不采用任何參數。 ```cs public Circle(int radius) { Console.WriteLine("Circle, r={0} is created", radius); } ``` 此構造器采用一個參數-`radius`。 ```cs public Circle() : this(1) { } ``` 這是沒有參數的構造器。它只是簡單地調用另一個構造器，并為其提供默認半徑 1。 ```cs $ dotnet run Circle, r=5 is created Circle, r=1 is created ``` This is the output. ## C# `ToString`方法每個對象都有一個`ToString()`方法。它返回人類可讀的對象表示形式。默認實現返回`Object`類型的標準名稱。請注意，當我們使用對象作為參數調用`Console.WriteLine()`方法時，將調用`ToString()`。 `Program.cs` ```cs using System; namespace ToStringMethod { class Being { public override string ToString() { return "This is Being class"; } } class Program { static void Main(string[] args) { var b = new Being(); var o = new Object(); Console.WriteLine(o.ToString()); Console.WriteLine(b.ToString()); Console.WriteLine(b); } } } ``` 我們有一個`Being`類，其中我們重寫了`ToString()`方法的默認實現。 ```cs public override string ToString() { return "This is Being class"; } ``` 創建的每個類都從基`object`繼承。 `ToString()`方法屬于此對象類。我們使用`override`關鍵字來通知我們正在覆蓋方法。 ```cs var b = new Being(); var o = new Object(); ``` 我們創建一個自定義對象和一個內置對象。 ```cs Console.WriteLine(o.ToString()); Console.WriteLine(b.ToString()); ``` 我們在這兩個對象上調用`ToString()`方法。 ```cs Console.WriteLine(b); ``` 正如我們之前指定的，將對象作為`Console.WriteLine()`的參數將調用其`ToString()`方法。這次，我們隱式調用了該方法。 ```cs $ dotnet run System.Object This is Being class This is Being class ``` 這是我們運行示例時得到的。 ## C# 對象初始化器對象初始化器讓我們在創建時將值分配給對象的任何可訪問字段或屬性，而無需調用構造器。屬性或字段在`{}`括號內分配。另外，我們可以為構造器指定參數，也可以省略參數。 `Program.cs` ```cs using System; namespace ObjectInitializers { class User { public User() {} public string Name { set; get; } public string Occupation { set; get; } public override string ToString() { return $"{Name} is a {Occupation}"; } } class Program { static void Main(string[] args) { var u = new User { Name = "John Doe", Occupation = "gardener" }; Console.WriteLine(u); } } } ``` 在示例中，我們使用對象初始化器語法創建一個新用戶。 ```cs public User() {} ``` 我們定義一個空的構造器。 ```cs public string Name { set; get; } public string Occupation { set; get; } ``` 我們有兩個屬性：`Name`和`Occupation`。 ```cs var u = new User { Name = "John Doe", Occupation = "gardener" }; ``` 我們將值分配給`{}`括號中的屬性。 ```cs $ dotnet run John Doe is a gardener ``` This is the output. ## C# 類常量 C# 可以創建類常量。這些常量不屬于具體對象。他們屬于類。按照約定，常量用大寫字母表示。 `Program.cs` ```cs using System; namespace ClassConstants { class Math { public const double PI = 3.14159265359; } class Program { static void Main(string[] args) { Console.WriteLine(Math.PI); } } } ``` 我們有一個帶有`PI`常量的`Math`類。 ```cs public const double PI = 3.14159265359; ``` `const`關鍵字用于定義常數。 `public`關鍵字使它可以在類的主體之外訪問。 ```cs $ dotnet run 3.14159265359 ``` 運行示例，我們看到此輸出。 ## C# 繼承繼承是使用已經定義的類形成新類的方法。新形成的類稱為派生的類，我們派生的類稱為基類。繼承的重要好處是代碼重用和降低程序的復雜性。派生類（后代）將覆蓋或擴展基類（祖先）的功能。 `Program.cs` ```cs using System; namespace Inheritance { class Being { public Being() { Console.WriteLine("Being is created"); } } class Human : Being { public Human() { Console.WriteLine("Human is created"); } } class Program { static void Main(string[] args) { new Human(); } } } ``` 在此程序中，我們有兩個類。基類`Being`和派生的`Human`類。派生類繼承自基類。 ```cs class Human : Being ``` 在 C# 中，我們使用冒號（`:`）運算符創建繼承關系。 ```cs new Human(); ``` 我們實例化派生的`Human`類。 ```cs $ dotnet run Being is created Human is created ``` 我們可以看到兩個構造器都被調用了。首先，調用基類的構造器，然后調用派生類的構造器。接下來是一個更復雜的示例。 `Program.cs` ```cs using System; namespace Inheritance2 { class Being { static int count = 0; public Being() { count++; Console.WriteLine("Being is created"); } public void GetCount() { Console.WriteLine("There are {0} Beings", count); } } class Human : Being { public Human() { Console.WriteLine("Human is created"); } } class Animal : Being { public Animal() { Console.WriteLine("Animal is created"); } } class Dog : Animal { public Dog() { Console.WriteLine("Dog is created"); } } class Program { static void Main(string[] args) { new Human(); var dog = new Dog(); dog.GetCount(); } } } ``` 我們有四個類。繼承層次更加復雜。 `Human`和`Animal`類繼承自`Being`類。 Dog 類直接繼承自`Animal`類，并間接繼承自`Being`類。我們還介紹了`static`變量的概念。 ```cs static int count = 0; ``` 我們定義一個`static`變量。靜態成員是類的所有實例共享的成員。 ```cs Being() { count++; Console.WriteLine("Being is created"); } ``` 每次實例化`Being`類時，我們將`count`變量增加一。這樣，我們就可以跟蹤創建的實例數。 ```cs class Animal : Being ... class Dog : Animal ... ``` `Animal`繼承自`Being`，`Dog`繼承自`Animal`。 `Dog`也間接繼承自`Being`。 ```cs new Human(); var dog = new Dog(); dog.GetCount(); ``` 我們從`Human`和`Dog`類創建實例。我們稱為`Dog`對象的`GetCount()`方法。 ```cs $ dotnet run Being is created Human is created Being is created Animal is created Dog is created There are 2 Beings ``` `Human`調用兩個構造器。 `Dog`調用三個構造器。有兩個實例化的存在。我們使用`base`關鍵字顯式調用父級的構造器。 `Program.cs` ```cs using System; namespace Shapes { class Shape { protected int x; protected int y; public Shape() { Console.WriteLine("Shape is created"); } public Shape(int x, int y) { this.x = x; this.y = y; } } class Circle : Shape { private int r; public Circle(int r, int x, int y) : base(x, y) { this.r = r; } public override string ToString() { return String.Format("Circle, r:{0}, x:{1}, y:{2}", r, x, y); } } class Program { static void Main(string[] args) { var c = new Circle(2, 5, 6); Console.WriteLine(c); } } } ``` 我們有兩個類：`Shape`類和`Circle`類。 `Shape`類是幾何形狀的基類。我們可以在此類中加入一些常見形狀的共同點，例如`x`和`y`坐標。 ```cs public Shape() { Console.WriteLine("Shape is created"); } public Shape(int x, int y) { this.x = x; this.y = y; } ``` `Shape`類具有兩個構造器。第一個是默認構造器。第二個參數有兩個參數：`x`，`y`坐標。 ```cs public Circle(int r, int x, int y) : base(x, y) { this.r = r; } ``` 這是`Circle`類的構造器。此構造器啟動`r`成員并調用父級的第二個構造器，并向其傳遞`x`和`y`坐標。如果不使用`base`關鍵字顯式調用構造器，則將調用`Shape`類的默認構造器。 ```cs $ dotnet run Circle, r:2, x:5, y:6 ``` 這是示例的輸出。 ## C# 抽象類和方法抽象類無法實例化。如果一個類至少包含一個抽象方法，則也必須將其聲明為抽象方法。抽象方法無法實現；他們只是聲明方法的簽名。當我們從抽象類繼承時，所有抽象方法都必須由派生類實現。此外，必須以較少受限制的可見性聲明這些方法。與接口不同，抽象類可能具有完全實現的方法，并且可能具有定義的成員字段。因此，抽象類可以提供部分實現。程序員經常將一些通用功能放入抽象類中。這些抽象類隨后會被子類化以提供更具體的實現。例如，Qt 圖形庫具有`QAbstractButton`，它是按鈕小部件的抽象基類，提供按鈕所共有的功能。按鈕`Q3Button`，`QCheckBox`，`QPushButton`，`QRadioButton`和`QToolButton`都從此基本抽象類繼承。正式地說，抽象類用于強制執行協議。協議是所有實現對象都必須支持的一組操作。 `Program.cs` ```cs using System; namespace AbstractClass { abstract class Drawing { protected int x = 0; protected int y = 0; public abstract double Area(); public string GetCoordinates() { return string.Format("x: {0}, y: {1}", this.x, this.y); } } class Circle : Drawing { private int r; public Circle(int x, int y, int r) { this.x = x; this.y = y; this.r = r; } public override double Area() { return this.r * this.r * Math.PI; } public override string ToString() { return string.Format("Circle at x: {0}, y: {1}, radius: {2}", this.x, this.y, this.r); } } class Program { static void Main(string[] args) { var c = new Circle(12, 45, 22); Console.WriteLine(c); Console.WriteLine("Area of circle: {0}", c.Area()); Console.WriteLine(c.GetCoordinates()); } } } ``` 我們有一個抽象基類`Drawing`。該類定義兩個成員字段，定義一個方法并聲明一個方法。一種方法是抽象的，另一種是完全實現的。 `Drawing`類是抽象的，因為我們無法繪制它。我們可以畫一個圓，一個點或一個正方形。 `Drawing`類對我們可以繪制的對象具有一些通用功能。 ```cs abstract class Drawing ``` 我們使用`abstract`關鍵字定義一個抽象類。 ```cs public abstract double Area(); ``` 抽象方法之前還帶有`abstract`關鍵字。 ```cs class Circle : Drawing ``` 圓是`Drawing`類的子類。它必須實現抽象的`Area()`方法。 ```cs public override double Area() { return this.r * this.r * Math.PI; } ``` 當我們實現`Area()`方法時，必須使用`override`關鍵字。這樣，我們通知編譯器我們將覆蓋現有的（繼承的）方法。 ```cs $ dotnet run Circle at x: 12, y: 45, radius: 22 Area of circle: 1520.53084433746 x: 12, y: 45 ``` This is the output of the program. ## C# 部分類使用`partial`關鍵字，可以將類的定義拆分到同一名稱空間中的幾個部分中。該類也可以在多個文件中定義。當使用非常大的代碼庫時可以使用部分類，這些代碼庫可以拆分為較小的單元。局部類也與自動代碼生成器一起使用。 `Program.cs` ```cs using System; namespace PartialClass { partial class Worker { public string DoWork() { return "Doing work"; } } partial class Worker { public string DoPause() { return "Pausing"; } } class Program { static void Main(string[] args) { var worker = new Worker(); Console.WriteLine(worker.DoWork()); Console.WriteLine(worker.DoWork()); Console.WriteLine(worker.DoPause()); } } } ``` 在示例中，我們將`Worker`類定義為兩部分。這些部分由編譯器連接在一起以形成最終類。 ```cs $ dotnet run Doing work Doing work Pausing ``` 這是輸出。這是 C# 中 OOP 描述的第一部分。