1. 前言
我們回到我們的動物園吧。有一個基礎類別 Animal(動物),還有它的衍生類別:Dog(狗)、Cat(貓)、Fish(魚)。
在前面的課程裡,我們在 Animal 加了一個 virtual 方法 MakeSound():
public class Animal
{
public string Name { get; set; }
public int Age { get; set; }
public virtual void MakeSound() // 虛擬方法
{
Console.WriteLine("某種動物發出聲音。"); // 預設實作
}
public void Sleep() // 一般方法
{
Console.WriteLine($"{Name} 在睡覺。");
}
}
public class Dog : Animal
{
public override void MakeSound() // 為狗重寫聲音
{
Console.WriteLine("汪汪!");
}
}
public class Cat : Animal
{
public override void MakeSound() // 為貓重寫聲音
{
Console.WriteLine("喵!");
}
}
這樣超好用!當我們建立 Dog 或 Cat 並呼叫 MakeSound(),就會聽到牠們獨特的聲音。但如果我們只建立一個 Animal 呢?
Animal genericAnimal = new Animal();
genericAnimal.Name = "未知生物";
genericAnimal.MakeSound(); // 會輸出:"某種動物發出聲音。"
看起來很合理。但有時候,基礎類別的預設實作根本沒意義。假如 Animal 其實不是具體的動物,而是一個概念?「動物」本身不會發出特定聲音,是具體的動物種類才會。或者想像一下,有個 Shape(圖形)類別,裡面有個 CalculateArea()(計算面積)方法。單純圖形要怎麼算面積?根本沒辦法!圓形、正方形才有面積,抽象的「圖形」沒有。
這種情況下,當基礎類別不能(或不該)提供有意義的預設實作,但又強制所有衍生類別都要實作這個方法時,抽象方法和抽象類別就派上用場啦。
2. 抽象類別:藍圖還不是房子
想像你是建築師,正在畫一個標準房子的藍圖。但這不是一般的房子,而是「概念房子」。它有共同特徵:牆、屋頂、地基。但你還不知道它會是一層樓的別墅還是高樓大廈。有些藍圖細節是確定的(例如一樓天花板高度),有些則只是提示(例如「樓層數」要之後決定)。
在 C# 世界裡,這種「概念房子」就叫做抽象類別。
抽象類別就是用 abstract 關鍵字標記的類別。
public abstract class Animal // 現在 Animal 是抽象類別
{
// ...
}
抽象類別的重點:
- 不能直接建立實體。 你不能寫 new Animal()。為什麼?因為 Animal 現在是個不確定的東西,是個概念。你不能蓋「概念房子」,只能蓋具體的別墅或大樓。
如果你硬要 new Animal(),編譯器馬上打你手:
這個限制超重要!Cannot create an instance of the abstract type or interface 'Animal' (無法建立抽象型別或介面的實體 'Animal') - 可以包含抽象成員。 這才是重點!
3. 抽象方法:只有契約沒有實作
如果抽象類別是「概念房子」,那抽象方法就是藍圖上寫著「要做這個」,但沒說「怎麼做」的部分。像是「蓋地基」——一定要有,但地基的尺寸和材料要看房子類型決定。
抽象方法就是:
- 用 abstract 標記。
- 沒有方法主體(沒有 {} 區塊),直接用分號 ; 結尾。
- 只能在抽象類別裡宣告。
我們把 MakeSound() 變成抽象方法吧:
public abstract class Animal // Animal 變成抽象類別
{
public string Name { get; set; }
public int Age { get; set; }
public abstract void MakeSound(); // 抽象方法!沒有主體!
public void Sleep() // 這個方法還是一般的
{
Console.WriteLine($"{Name} 在睡覺。");
}
}
你看 MakeSound() 變了!沒有大括號、沒有預設內容。它只是在說:「任何動物都必須會發出聲音。怎麼發出——讓繼承我的類別自己決定。」
重點規則: 如果你的類別繼承自抽象類別,而且自己不是抽象的,就一定要用 override 實作所有基礎類別的抽象方法。這不是選項,是強制、契約!C# 編譯器超嚴格。如果你忘了,它馬上提醒你:
public class Dog : Animal // 一般(非抽象)類別
{
// 編譯錯誤!
// 'Dog' does not implement inherited abstract member 'Animal.MakeSound()'
// (類別 'Dog' 沒有實作繼承來的抽象成員 'Animal.MakeSound()')
// 編譯器等著我們寫 MakeSound() + override!
}
要消除錯誤,Dog 和 Cat 一定要實作 MakeSound():
public class Dog : Animal
{
public override void MakeSound() // 一定要實作!
{
Console.WriteLine("汪汪!");
}
}
public class Cat : Animal
{
public override void MakeSound() // 這裡也要!
{
Console.WriteLine("喵!");
}
}
virtual、abstract 和 override 比較
| 特性 | virtual 方法 | abstract 方法 | override 關鍵字 |
|---|---|---|---|
| 出現位置 | 一般類別或抽象類別 | 只能在抽象類別 | 在衍生(子)類別 |
| 方法主體 | 有主體(預設實作) | 沒有主體(分號 ; 結尾) | 有主體(新實作) |
| 目的 | 提供預設實作,但允許子類覆寫 | 宣告契約:子類必須自己實作 | 為 virtual 或 abstract 方法提供專屬實作 |
| 能不能建立基礎類別實體? | 可以(如果基礎類別不是抽象) | 不行(如果基礎類別是抽象) | N/A(針對方法,不是類別) |
| 子類的義務 | 可以選擇要不要 override | 一定要 override(如果子類不是抽象) | N/A |
4. 抽象方法下的多型實戰
這才是重點!我們知道多型讓我們可以用基礎類別的參考來操作不同的子類物件。即使基礎類別是抽象的也完全沒問題!
雖然我們不能直接建立 Animal 的實體(記得 new Animal() 會錯),但我們可以用 Animal 當作參考型別來指向子類物件。這超強大!
繼續我們的動物園。假設有個農場,裡面住著各種動物。我們想讓每隻動物都發出自己的聲音。
using System;
// 抽象類別 Animal
public abstract class Animal
{
public string Name;
public int Age;
public Animal(string name, int age) { Name = name; Age = age; }
public abstract void MakeSound();
public void Sleep() { Console.WriteLine($"{Name} 在睡覺。"); }
}
public class Dog : Animal
{
public Dog(string name, int age) : base(name, age) { }
public override void MakeSound() { Console.WriteLine("汪汪!"); }
}
public class Cat : Animal
{
public Cat(string name, int age) : base(name, age) { }
public override void MakeSound() { Console.WriteLine("喵!"); }
}
public class Fish : Animal
{
public Fish(string name, int age) : base(name, age) { }
public override void MakeSound() { Console.WriteLine("咕嚕咕嚕"); }
}
class Program
{
static void Main()
{
Animal[] animals = {
new Dog("小球", 3),
new Cat("小咪", 5),
new Fish("尼莫", 1)
};
foreach (Animal animal in animals)
{
Console.WriteLine($"\n哈囉,我是 {animal.Name},我 {animal.Age} 歲。");
animal.MakeSound();
animal.Sleep();
}
}
}
這段程式碼發生了什麼?
- 我們把 Animal 宣告成 abstract class。這告訴編譯器:「這是模板,不能直接建立,但可以被繼承」。
- 我們在 Animal 裡宣告了 public abstract void MakeSound();。這表示:「任何繼承 Animal 的類別(不是抽象的),都必須實作 MakeSound()。這是契約!」
- Dog、Cat、Fish 都乖乖照契約重寫 MakeSound(),各自有自己的實作。如果忘了寫,編譯器不會讓你過。
- 在 Main 方法裡,我們建立一個 Animal[] 陣列。雖然 Animal 是抽象的,這個陣列還是可以存放子類(Dog、Cat、Fish)的參考,因為它們都是 Animal!
- 當我們用 foreach 迴圈跑陣列,呼叫 animal.MakeSound(),多型就發揮作用了,C# 會自動知道要呼叫哪個 MakeSound():Dog.MakeSound()、Cat.MakeSound() 或 Fish.MakeSound()。呼叫的是實際物件型別的方法,不是參考型別。這就是多型的精髓!
- 而 animal.Sleep() 則會呼叫基礎類別 Animal 的具體實作,因為這個方法沒被標記成 virtual 或 abstract,也沒被子類覆寫。
5. 現實生活中有什麼用?
「好啦,動物園、動物……那我以後寫銀行或商店的應用程式有啥用?」你可能會這樣問。這問題超棒!抽象類別和方法是設計彈性又可擴充系統的超強工具。
強制實作契約: 這是最大優點。想像你要做一個支付系統框架。有個基礎 abstract class PaymentProcessor(支付處理器)。你很清楚,任何支付處理器都要會 ProcessPayment()(處理付款)、RefundPayment()(退款)、CheckStatus()(查詢狀態)。但 PayPal、信用卡、Bitcoin 的實作完全不同。
你就在 PaymentProcessor 裡把這些方法宣告成 abstract。
public abstract class PaymentProcessor
{
public abstract bool ProcessPayment(decimal amount, string currency, string cardNumber);
public abstract bool RefundPayment(string transactionId);
public abstract string CheckStatus(string transactionId);
// ... 其他可以是具體的,例如日誌
public void LogTransaction(string message)
{
Console.WriteLine($"[LOG]: {message}");
}
}
public class PayPalProcessor : PaymentProcessor
{
public override bool ProcessPayment(decimal amount, string currency, string cardNumber)
{
// 這裡是跟 PayPal API 溝通的複雜邏輯
Console.WriteLine($"PayPal: 處理 {amount} {currency}...");
return true;
}
public override bool RefundPayment(string transactionId) { /* ... */ return true; }
public override string CheckStatus(string transactionId) { /* ... */ return "Completed"; }
}
public class CreditCardProcessor : PaymentProcessor
{
public override bool ProcessPayment(decimal amount, string currency, string cardNumber)
{
// 這裡是跟銀行溝通的邏輯
Console.WriteLine($"CreditCard: {amount} {currency} 用卡號 {cardNumber.Substring(0,4)}XXXX...");
return true;
}
public override bool RefundPayment(string transactionId) { /* ... */ return true; }
public override string CheckStatus(string transactionId) { /* ... */ return "Processing"; }
}
這樣任何想寫新支付處理器(例如 BitcoinProcessor)的工程師,一定要實作這三個方法。不會不小心忘了 RefundPayment(),因為編譯器根本不讓你過!這讓你的系統超一致。
彈性與擴充性: 你可以寫只認得 PaymentProcessor 的程式碼,根本不用知道底下是哪個實作。例如購物車程式只要呼叫 currentProcessor.ProcessPayment(),系統會自動用對應的處理器。明天有新支付方式——只要寫新類別繼承 PaymentProcessor,實作抽象方法,主程式根本不用改!
避免空實作: 如果你用 virtual 方法而不是 abstract,就得給它空的預設內容,這很 misleading(容易誤會)。abstract 就是明講:「這裡沒實作,去子類找!」
讓架構更清楚: 抽象類別幫你把共用邏輯和專屬邏輯分開。共用的(像 LogTransaction 在 PaymentProcessor)寫在基礎類別,專屬的(像 ProcessPayment)寫在子類。這讓程式碼更好讀、好維護、好測試。設計框架或函式庫時,也能明確定義「擴充點」,讓用戶一定要補上。
6. 常見錯誤與小細節
錯誤一:想建立抽象類別的實體。
這一定會編譯錯。抽象類別是概念,不是具體物件。你可以用它當參考型別,但不能寫 new Animal()。
錯誤二:忘了實作抽象方法。
如果子類不是抽象的,就一定要實作所有 abstract 方法。不然就編譯錯。唯一能閃過的辦法是讓子類也變抽象,但通常你不會想這樣。
錯誤三:搞混 abstract 和 virtual。
abstract 強制要實作,沒有主體。virtual 有預設內容,可以被覆寫。不能寫有主體的 abstract 方法,也不能寫沒主體的 virtual 方法——這會語法錯誤。
錯誤四:用 new 取代 override。
如果你不用 override,只是在子類寫同名方法,你不是覆寫,而是隱藏基礎類別的方法。這會讓多型呼叫時出現怪現象:會呼叫基礎類別的方法。
public class Base
{
public void DoSomething() { Console.WriteLine("Base"); }
}
public class Derived : Base
{
public new void DoSomething() { Console.WriteLine("Derived"); }
}
Base obj = new Derived();
obj.DoSomething(); // 會輸出:Base
GO TO FULL VERSION