CodeGym /課程 /C# SELF /多型與抽象方法的關聯

多型與抽象方法的關聯

C# SELF
等級 21, 課堂 4
開放

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();
        }
    }
}

這段程式碼發生了什麼?

  1. 我們把 Animal 宣告成 abstract class。這告訴編譯器:「這是模板,不能直接建立,但可以被繼承」。
  2. 我們在 Animal 裡宣告了 public abstract void MakeSound();。這表示:「任何繼承 Animal 的類別(不是抽象的),都必須實作 MakeSound()。這是契約!」
  3. Dog、Cat、Fish 都乖乖照契約重寫 MakeSound(),各自有自己的實作。如果忘了寫,編譯器不會讓你過。
  4. 在 Main 方法裡,我們建立一個 Animal[] 陣列。雖然 Animal 是抽象的,這個陣列還是可以存放子類(Dog、Cat、Fish)的參考,因為它們都是 Animal!
  5. 當我們用 foreach 迴圈跑陣列,呼叫 animal.MakeSound(),多型就發揮作用了,C# 會自動知道要呼叫哪個 MakeSound():Dog.MakeSound()、Cat.MakeSound() 或 Fish.MakeSound()。呼叫的是實際物件型別的方法,不是參考型別。這就是多型的精髓!
  6. 而 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
2
任務
C# SELF, 等級 21, 課堂 4
上鎖
建立抽象類別並實作
建立抽象類別並實作
2
任務
C# SELF, 等級 21, 課堂 4
上鎖
多型與抽象方法
多型與抽象方法
1
問卷/小測驗
多型的概念,等級 21,課堂 4
未開放
多型的概念
多型跟方法多載
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION