2026-04-20 關於類別型別(classes type) 它還有一些關鍵字 ,比如說 static override ....

2026-04-20 關於類別型別(classes type) 它還有一些關鍵字 ,比如說 static override ….

我:
關於類別型別(classes type) 它還有一些關鍵字 ,比如說 static override ….., 可以細說嗎?

當你深入學習 C# 的面向物件程式設計（OOP）時，了解類別（Classes）相關的各種關鍵字是非常重要的。這些關鍵字控制著類別的行為、屬性以及它們與其他類別的互動方式。以下將詳細介紹一些常見的類別相關關鍵字，如 static、override、virtual、abstract、sealed、partial 等，並提供相應的範例以幫助你更好地理解和應用這些概念。

目錄
1. static 關鍵字

2. virtual 和 override 關鍵字

3. abstract 關鍵字

4. sealed 關鍵字

5. partial 關鍵字

6. new 關鍵字

7. 其他相關關鍵字

8. 小結


1. static 關鍵字
   概述：
static 關鍵字用於定義靜態類別、靜態成員（方法、屬性、字段等）。靜態成員屬於類別本身，而不是類別的實例。
   用途：
   • 靜態類別（Static Classes）：用於封裝不需要實例化的功能，如工具類別（Helper Classes）。

   • 靜態成員（Static Members）：共享數據或方法，不依賴於任何實例。

   範例：靜態類別和靜態方法
   using System;

static class MathUtilities
{
public static double Pi = 3.141592653589793;

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

public static double Multiply(double a, double b)
{
    return a * b;
}

}

class Program
{
static void Main(string[] args)
{
// 訪問靜態成員，不需要實例化類別
Console.WriteLine($”Pi 的值是 {MathUtilities.Pi}”);
double sum = MathUtilities.Add(5.5, 3.2);
double product = MathUtilities.Multiply(4.0, 2.5);
Console.WriteLine($”5.5 + 3.2 = {sum}”);
Console.WriteLine($”4.0 * 2.5 = {product}”);
}
}
輸出：
Pi 的值是 3.141592653589793
5.5 + 3.2 = 8.7
4.0 * 2.5 = 10
注意事項：
• 靜態類別不能被實例化（無法使用 new 關鍵字創建對象）。

• 靜態類別中的所有成員必須是靜態的。

• 靜態類別通常用於封裝全局功能或常數。

範例：靜態字段和靜態方法
using System;

class Counter
{
public static int Count = 0;

public Counter()
{
    Count++;
}

public static void DisplayCount()
{
    Console.WriteLine($"當前計數為: {Count}");
}

}

class Program
{
static void Main(string[] args)
{
new Counter();
new Counter();
new Counter();

    Counter.DisplayCount(); // 輸出: 當前計數為: 3
}

}

2. virtual 和 override 關鍵字
   概述：
   • virtual：用於基類的方法、屬性或事件，允許派生類重寫（覆蓋）這些成員。

   • override：用於派生類的方法、屬性或事件，表示該成員覆蓋了基類的虛擬成員。

   用途：
實現多態性，允許基類引用指向派生類對象，並在運行時調用正確的覆蓋方法。
   範例：使用 virtual 和 override
   using System;

class Animal
{
public virtual void Speak()
{
Console.WriteLine(“Animal speaks”);
}
}

class Dog : Animal
{
public override void Speak()
{
Console.WriteLine(“Dog barks”);
}
}

class Cat : Animal
{
public override void Speak()
{
Console.WriteLine(“Cat meows”);
}
}

class Program
{
static void Main(string[] args)
{
Animal myDog = new Dog();
Animal myCat = new Cat();
Animal genericAnimal = new Animal();

    myDog.Speak();          // 輸出: Dog barks
    myCat.Speak();          // 輸出: Cat meows
    genericAnimal.Speak();  // 輸出: Animal speaks
}

}
輸出：
Dog barks
Cat meows
Animal speaks
解析：
1. 基類 Animal 定義了一個虛擬方法 Speak。

2. 派生類 Dog 和 Cat 使用 override 關鍵字覆蓋了 Speak 方法。

3. 基類引用 myDog 和 myCat 分別指向 Dog 和 Cat 對象，呼叫 Speak 方法時，會根據實際對象類型執行相應的覆蓋方法。

4. 基類引用 genericAnimal 指向基類對象，呼叫 Speak 方法時，執行基類的實現。

注意事項：
• 只有在基類方法標記為 virtual 或 abstract 時，派生類才能使用 override 來覆蓋該方法。

• 使用 override 時，方法簽名必須與基類方法完全一致。


3. abstract 關鍵字
   概述：
abstract 關鍵字用於定義抽象類別或抽象方法。抽象類別不能被實例化，必須被派生類繼承並實現其抽象方法。
   用途：
用於定義一個類別的基礎結構，而具體實現由派生類完成。
   範例：抽象類別和抽象方法
   using System;

abstract class Shape
{
public abstract double Area(); // 抽象方法，沒有實現

public void DisplayArea()
{
    Console.WriteLine($"面積是: {Area()}");
}

}

class Circle : Shape
{
public double Radius { get; set; }

public Circle(double radius)
{
    Radius = radius;
}

public override double Area()
{
    return Math.PI * Radius * Radius;
}

}

class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }

public Rectangle(double width, double height)
{
    Width = width;
    Height = height;
}

public override double Area()
{
    return Width * Height;
}

}

class Program
{
static void Main(string[] args)
{
Shape circle = new Circle(5);
Shape rectangle = new Rectangle(4, 6);

    circle.DisplayArea();      // 輸出: 面積是: 78.53981633974483
    rectangle.DisplayArea();   // 輸出: 面積是: 24
}

}
輸出：
面積是: 78.53981633974483
面積是: 24
解析：
1. 抽象類別 Shape 定義了一個抽象方法 Area 和一個具體方法 DisplayArea。

2. 派生類 Circle 和 Rectangle 必須實現 Area 方法，提供具體的計算邏輯。

3. 無法直接實例化 Shape 類別，只能通過派生類進行實例化。

注意事項：
• 抽象類別可以包含具體方法和抽象方法。

• 派生類必須覆蓋所有基類的抽象方法，除非派生類也是抽象類別。


4. sealed 關鍵字
   概述：
sealed 關鍵字用於防止類別被進一步繼承，或者防止方法被覆蓋。
   用途：
   • 封閉類別（Sealed Classes）：不允許其他類別繼承這個類別。

   • 封閉方法（Sealed Methods）：在覆蓋方法中使用 sealed，防止其被進一步覆蓋。

   範例：封閉類別
   using System;

sealed class Logger
{
public void Log(string message)
{
Console.WriteLine($”Log: {message}”);
}
}

// 嘗試繼承 Logger 會導致編譯錯誤
// class FileLogger : Logger { }

class Program
{
static void Main(string[] args)
{
Logger logger = new Logger();
logger.Log(“應用程式啟動”);
}
}
輸出：
Log: 應用程式啟動
解析：
• Logger 類別被標記為 sealed，無法被其他類別繼承。

• 嘗試創建繼承自 Logger 的 FileLogger 類別會導致編譯錯誤。

範例：封閉方法
using System;

class BaseClass
{
public virtual void Display()
{
Console.WriteLine(“基類的 Display 方法”);
}
}

class DerivedClass : BaseClass
{
public sealed override void Display()
{
Console.WriteLine(“派生類的 Display 方法”);
}
}

// 嘗試在 FurtherDerivedClass 中覆蓋 Display 方法會導致編譯錯誤
// class FurtherDerivedClass : DerivedClass
// {
// public override void Display() // 錯誤
// {
// Console.WriteLine(“進一步派生類的 Display 方法”);
// }
// }

class Program
{
static void Main(string[] args)
{
DerivedClass obj = new DerivedClass();
obj.Display(); // 輸出: 派生類的 Display 方法
}
}
輸出：
派生類的 Display 方法
解析：
• DerivedClass 覆蓋了基類的 Display 方法，並使用 sealed 關鍵字防止進一步的覆蓋。

• 嘗試在 FurtherDerivedClass 中覆蓋 Display 方法會導致編譯錯誤。


5. partial 關鍵字
   概述：
partial 關鍵字允許將一個類別、結構（struct）或介面（interface）的定義分割到多個文件中。這對於大型類別或由工具生成部分代碼的情況非常有用。
   用途：
   • 代碼組織：將類別的不同部分分開管理，提高可讀性。

   • 工具生成代碼：允許工具生成代碼和手動編寫的代碼在不同文件中共存。

   範例：分割類別定義
   File: Person.Part1.cs
   using System;

partial class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }

public void GetFullName()
{
    Console.WriteLine($"全名: {FirstName} {LastName}");
}

}
File: Person.Part2.cs
using System;

partial class Person
{
public int Age { get; set; }

public void GetAge()
{
    Console.WriteLine($"年齡: {Age}");
}

}
File: Program.cs
using System;

class Program
{
static void Main(string[] args)
{
Person person = new Person
{
FirstName = “John”,
LastName = “Doe”,
Age = 30
};

    person.GetFullName(); // 輸出: 全名: John Doe
    person.GetAge();      // 輸出: 年齡: 30
}

}
輸出：
全名: John Doe
年齡: 30
解析：
• Person 類別被分割到兩個不同的文件中，每個文件使用 partial 關鍵字。

• 編譯時，這些部分會被合併成一個完整的類別。

注意事項：
• 所有部分必須使用 partial 關鍵字並具有相同的訪問修飾符（如 public）。

• 必須在同一個命名空間中。


6. new 關鍵字
   概述：
在類別中，new 關鍵字用於隱藏基類中的成員（方法、屬性等）。這不同於 override，因為 new 不涉及多態性，而是定義了一個新的成員來隱藏基類中的同名成員。
   用途：
   • 方法隱藏（Method Hiding）：當你希望在派生類中定義一個與基類同名但不同實現的方法，並且不希望使用多態性時。

   範例：使用 new 隱藏基類方法
   using System;

class BaseClass
{
public void Display()
{
Console.WriteLine(“基類的 Display 方法”);
}
}

class DerivedClass : BaseClass
{
public new void Display()
{
Console.WriteLine(“派生類的 Display 方法”);
}
}

class Program
{
static void Main(string[] args)
{
DerivedClass derived = new DerivedClass();
derived.Display(); // 輸出: 派生類的 Display 方法

    BaseClass baseRef = derived;
    baseRef.Display(); // 輸出: 基類的 Display 方法
}

}
輸出：
派生類的 Display 方法
基類的 Display 方法
解析：
• 在 DerivedClass 中使用 new 關鍵字定義了一個與基類 BaseClass 中同名的 Display 方法，這樣會隱藏基類的方法。

• 當使用派生類引用 derived 呼叫 Display 方法時，會調用派生類的方法。

• 當使用基類引用 baseRef 指向派生類對象時，呼叫 Display 方法會調用基類的方法，因為 new 不涉及多態性。

注意事項：
• 使用 new 隱藏基類成員時，不會發生多態性，即基類引用仍然呼叫基類的方法。

• 建議僅在有明確需求時使用 new，否則應優先考慮使用 virtual 和 override 來實現多態性。


7. 其他相關關鍵字
   除了上述主要關鍵字外，還有一些與類別相關的重要關鍵字：
   a. readonly 和 const
   • const：
   ◦ 用於定義編譯時常數，必須在聲明時初始化。

   ◦ 隱式為 static。

   ◦ 不能更改。

   • 範例：
class Constants
   • {
   • public const double Pi = 3.141592653589793;
   • }
   •
   • class Program
   • {
   • static void Main(string[] args)
   • {
   • Console.WriteLine($”Pi 的值是 {Constants.Pi}”);
   • }
   • }
   • 

   • readonly：
   ◦ 用於定義運行時常數，可以在建構函數中初始化。

   ◦ 不是 static，除非明確標記。

   ◦ 可以根據需要在不同實例中有不同的值。

   • 範例：
class Person
   • {
   • public readonly string BirthDate;
   •
   • public Person(string birthDate)
   • {
   • BirthDate = birthDate;
   • }
   • }
   •
   • class Program
   • {
   • static void Main(string[] args)
   • {
   • Person person = new Person(“1990-01-01”);
   • Console.WriteLine($”出生日期: {person.BirthDate}”);
   • }
   • }
   • 

   b. interface 和 implements
   在 C# 中，類別可以實作多個介面（Interfaces），而不是繼承多個類別。介面定義了一組方法、屬性、事件等的合約，類別需要實作這些介面成員。

範例：實作介面
using System;

interface IAnimal
{
void Speak();
}

interface IMovable
{
void Move();
}

class Dog : IAnimal, IMovable
{
public void Speak()
{
Console.WriteLine(“Dog barks”);
}

public void Move()
{
    Console.WriteLine("Dog runs");
}

}

class Program
{
static void Main(string[] args)
{
Dog myDog = new Dog();
myDog.Speak(); // 輸出: Dog barks
myDog.Move(); // 輸出: Dog runs

    IAnimal animal = myDog;
    animal.Speak(); // 輸出: Dog barks

    IMovable movable = myDog;
    movable.Move(); // 輸出: Dog runs
}

}
輸出：
Dog barks
Dog runs
Dog barks
Dog runs
c. new 關鍵字在類別中的其他用途
除了用於方法隱藏外，new 關鍵字還可用於創建對象和在泛型中指定新類型約束等。
創建對象的範例：
class Car
{
public string Make { get; set; }
}

class Program
{
static void Main(string[] args)
{
Car myCar = new Car { Make = “Toyota” };
Console.WriteLine($”車的品牌是 {myCar.Make}”);
}
}
輸出：
車的品牌是 Toyota

8. 小結
   在 C# 中，類別相關的關鍵字控制著類別的行為、成員的訪問性以及類別之間的繼承和多態性。以下是主要關鍵字的快速回顧：
   • static：
   ◦ 定義靜態類別或靜態成員，屬於類別本身而非實例。

   • virtual 和 override：
   ◦ 實現多態性，允許派生類覆蓋基類的虛擬成員。

   • abstract：
   ◦ 定義抽象類別和抽象方法，必須由派生類實現。

   • sealed：
   ◦ 防止類別被進一步繼承，或防止方法被覆蓋。

   • partial：
   ◦ 將類別的定義分割到多個文件中，提高代碼組織性。

   • new：
   ◦ 隱藏基類的成員，或用於創建對象。

   • readonly 和 const：
   ◦ 定義不可變的常數值，readonly 可在建構函數中初始化，const 在編譯時初始化。

   了解並靈活運用這些關鍵字，可以幫助你編寫更高效、可維護且具備良好設計的 C# 程式。如果你有任何進一步的問題或需要更多範例，請隨時告訴我！