CodeGym /課程 /C# SELF /繼承入門

繼承入門

C# SELF
等級 12, 課堂 2
開放

1. 前言

今天這個主題可能一開始會覺得有點抽象,但相信我,沒這個你之後真的會卡住。我們今天要聊聊 繼承 在程式設計裡的用法。今天先簡單碰一下,之後會再深入。

想像你要寫一個動物園管理系統。你有各種動物:獅子、老虎、大象、鸚鵡。牠們都是動物,但每種動物又有自己的特色:

  • 獅子有鬃毛。
  • 老虎有條紋。
  • 大象超大隻還有長鼻子。
  • 鸚鵡會講話。

如果我們每種動物都分開寫 class,code 會超像的:


// 獅子
public class Lion
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Species { get; set; } = "獅子"; // 永遠是"獅子"
    public void Eat() { Console.WriteLine("獅子在吃肉。"); }
    public void Sleep() { Console.WriteLine("獅子在睡覺。"); }
    public void Roar() { Console.WriteLine("獅子在吼!"); }
    public string ManeColor { get; set; } // 獅子的特色 - 鬃毛
}

// 老虎
public class Tiger
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Species { get; set; } = "老虎"; // 永遠是"老虎"
    public void Eat() { Console.WriteLine("老虎在吃肉。"); }
    public void Sleep() { Console.WriteLine("老虎在睡覺。"); }
    public void Stride() { Console.WriteLine("老虎在潛行。"); }
    public string StripePattern { get; set; } // 老虎的特色 - 條紋
}

有沒有發現一堆重複的 code?Name、Age、Eat()、Sleep() —— 這些每個動物都會有啊!如果有 100 種動物怎麼辦?超崩潰!

這時候 繼承 就派上用場啦。

2. C# 裡的 class 繼承是什麼?

繼承 是物件導向程式設計(OOP)最基本的原則之一。它讓你可以根據現有的 class 去創造新的 class。新的 class(子類、子 class、衍生 class)會自動擁有(繼承)父類(基底 class、父 class)的所有屬性(欄位)跟行為(方法)。

就像現實生活一樣:你會遺傳爸媽的一些特徵,但你還是有自己的獨特之處。

在 C# 裡,繼承是用冒號 : 放在子 class 名字後面來寫的:


            // 父類(基底)class - Animal
public class Animal
{
    public string Name { get; set; } // 動物名字
    public int Age { get; set; }     // 動物年齡

    public void Eat()
    {
        Console.WriteLine($"{Name} 在吃東西。");
    }

    public void Sleep()
    {
        Console.WriteLine($"{Name} 在睡覺。");
    }
}

// 子類(衍生)class - Lion 繼承自 Animal
public class Lion : Animal // <-- 這就是繼承!
{
    public string ManeColor { get; set; } // 獅子的獨特屬性

    public void Roar() // 獅子的獨特行為
    {
        Console.WriteLine($"{Name} 在吼:RRRRRR!");
    }
}

// 另一個子類 - Tiger 繼承自 Animal
public class Tiger : Animal
{
    public string StripePattern { get; set; } // 老虎的獨特屬性

    public void Stride() // 老虎的獨特行為
    {
        Console.WriteLine($"{Name} 靜悄悄地潛行。");
    }
}

現在如果我們建立 Lion 或 Tiger 物件,他們自動就有 Name 跟 Age 屬性,還有 Eat() 跟 Sleep() 方法,因為這些都是從 Animal 繼承來的。


class Program
{
    static void Main(string[] args)
    {
        Lion simba = new Lion();
        simba.Name = "辛巴";
        simba.Age = 5;
        simba.ManeColor = "金色";

        simba.Eat();   // 從 Animal 繼承來的方法
        simba.Sleep(); // 從 Animal 繼承來的方法
        simba.Roar();  // Lion 自己的方法

        Console.WriteLine($"{simba.Name} - 年齡: {simba.Age}, 鬃毛顏色: {simba.ManeColor}");

        Tiger shereKhan = new Tiger();
        shereKhan.Name = "謝利汗";
        shereKhan.Age = 7;
        shereKhan.StripePattern = "經典";

        shereKhan.Eat();   // 從 Animal 繼承來的方法
        shereKhan.Sleep(); // 從 Animal 繼承來的方法
        shereKhan.Stride(); // Tiger 自己的方法

        Console.WriteLine($"{shereKhan.Name} - 年齡: {shereKhan.Age}, 條紋: {shereKhan.StripePattern}");
    }
}

繼承的重點:

  1. 重複利用 code(Code Reusability): 把共用邏輯寫在基底 class,就不用一直複製貼上。
  2. 階層結構(Hierarchy): 建立一個很有邏輯的「通用→特殊」結構(Animal → Lion/Tiger)。
  3. 多型(Polymorphism):(先提一下,之後會細講)你可以用基底 class 的 reference 來操作子類物件。比如你有一個 Animal 的 list,裡面可以放獅子、老虎,然後都可以呼叫 Eat() 方法。

3. 呼叫基底 class 的 constructor(base)

當你建立子類物件(像 new Lion()),C# 會自動先呼叫基底 class(這裡是 Animal)的 constructor,然後才呼叫子類的 constructor。這樣可以確保基底的部分都正確初始化。

有時你會想把參數傳給基底 class 的 constructor,這時就要用 base 關鍵字,寫在子類 constructor 的簽名後面。


public class Animal
{
    public string Name { get; set; }
    public int Age { get; set; }

    // 基底 class 的 constructor
    public Animal(string name, int age)
    {
        Name = name;
        Age = age;
        Console.WriteLine($"Animal 建構子:建立動物 {Name},年齡 {Age}。");
    }

    public void Eat()
    {
        Console.WriteLine($"{Name} 在吃東西。");
    }

    public void Sleep()
    {
        Console.WriteLine($"{Name} 在睡覺。");
    }
}

public class Lion : Animal
{
    public string ManeColor { get; set; }

    // Lion 的 constructor,會呼叫 Animal 的 constructor
    public Lion(string name, int age, string maneColor) : base(name, age) // <-- 這就是 'base'!
    {
        ManeColor = maneColor;
        Console.WriteLine($"Lion 建構子:鬃毛顏色 {ManeColor}。");
    }

    public void Roar()
    {
        Console.WriteLine($"{Name} 在吼:RRRRRR!");
    }
}

            class Program
{
    static void Main(string[] args)
    {
        // 建立 Lion 時,會先呼叫 Animal 的 constructor,再呼叫 Lion 的
        Lion simba = new Lion("辛巴", 5, "金色");
        simba.Roar();
    }
}

執行 new Lion("辛巴", 5, "金色") 會發生什麼事:

  1. 會呼叫 Lion(string name, int age, string maneColor) 的 constructor。
  2. 因為有 : base(name, age),會先跳去執行 Animal(string name, int age) 的 constructor。
  3. 執行 Animal 的 constructor,你會看到 Animal 建構子:建立動物 辛巴,年齡 5。
  4. 然後再回到 Lion 的 constructor。
  5. 執行 Lion 的 constructor,你會看到 Lion 建構子:鬃毛顏色 金色。

這很重要:基底 class 一定會先初始化!

4. is 跟 as operator

在 C# 寫程式時,你常常會遇到要檢查物件型別或嘗試轉型的情況。這時 is 跟 as operator 就超好用。它們在繼承跟多型時特別有用(之後會細講),但現在先學基本用法。

is operator(型別檢查)

is operator 可以檢查一個物件是不是某個型別。如果可以轉型,會回傳 true,不行就 false。

語法: 表達式 is 型別


static void AnalyzeObject(object obj)
{
    if (obj is string)
    {
        Console.WriteLine("這是字串!");
    }
    else if (obj is int)
    {
        Console.WriteLine("這是整數!");
    }
    else
    {
        Console.WriteLine("這是其他東西。");
    }
}

static void Main()
{
    AnalyzeObject("哈囉,世界!");      // 這是字串!
    AnalyzeObject(123);                 // 這是整數!
    AnalyzeObject(3.14);                // 這是其他東西。
    AnalyzeObject(new int[] { 1, 2 });  // 這是其他東西。
}

is + pattern matching:

現在的 C# 可以用 is 不只檢查型別,還能直接宣告一個變數接住轉型後的值,這叫「pattern matching」,寫起來超簡潔。


static void AnalyzeObjectWithPatternMatching(object obj)
{
    if (obj is string message) // 如果 obj 是字串,就存到 message
    {
        Console.WriteLine($"這是字串,長度是:{message.Length}");
    }
    else if (obj is int number) // 如果 obj 是 int,就存到 number
    {
        Console.WriteLine($"這是數字,乘 2 是:{number * 2}");
    }
    else
    {
        Console.WriteLine("型別不認得。");
    }
}

static void Main()
{
    AnalyzeObjectWithPatternMatching("範例"); // 這是字串,長度是:2
    AnalyzeObjectWithPatternMatching(50);       // 這是數字,乘 2 是:100
    AnalyzeObjectWithPatternMatching(new object()); // 型別不認得。
}

這種 is + pattern matching 的寫法比傳統先轉型再判斷 null 安全又好讀。

as operator(安全轉型)

as operator 會嘗試把物件轉成指定型別。如果可以轉,就回傳轉型後的物件;不行就回傳 null,不會丟 exception。所以 as 是「安全」的轉型方式。

語法: 表達式 as 型別


static void ProcessData(object data)
{
    string text = data as string; // 嘗試把 data 轉成 string
    
    if (text != null) // 判斷有沒有轉成功
    {
        Console.WriteLine($"處理字串:{text.ToUpper()}");
    }
    else
    {
        Console.WriteLine("資料不是字串。");
    }
}

static void Main()
{
    ProcessData("hello");      // 處理字串:HELLO
    ProcessData(123);          // 資料不是字串。
    ProcessData(null);         // 資料不是字串。
}

什麼時候用 as,什麼時候用直接轉型 (型別)表達式:

  • 安全性: 如果你不確定物件一定是那個型別,用 as 可以避免 InvalidCastException,拿到 null 再自己處理。
  • 只能用在 reference type: as 只能用在 reference type(class、interface、delegate、array),不能拿來轉 value type(像 int 轉 double)。

重點: 如果你很確定物件一定是那個型別,或你要轉 value type,就用直接轉型 (型別)表達式。如果轉不過去,直接轉型會丟 exception(InvalidCastException),這有時候反而是你想要的,因為型別錯誤就是邏輯 bug。

2
任務
C# SELF, 等級 12, 課堂 2
上鎖
建立基礎類別與其繼承類別
建立基礎類別與其繼承類別
2
任務
C# SELF, 等級 12, 課堂 2
上鎖
繼承類別中的建構函式
繼承類別中的建構函式
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION