2026-05-14 C# 學習 面向對象編程（OOP）

發表於 分類於 閱讀次數：
2026-05-14 C# 學習 面向對象編程（OOP）

2026-05-14 C# 學習 面向對象編程（OOP）

我:
請進入 進入第六階段，學習 面向對象編程（OOP）

GPT:
太好了！現在讓我們進入 第六階段：面向對象編程（OOP）。面向對象編程是 C# 中非常重要的一部分，它幫助我們更好地組織代碼，使其更加模組化、可重用且易於擴展。

在這個階段，我們會學習以下內容：

  1. 什麼是面向對象編程（OOP）
  2. 類別和物件
  3. 屬性與方法
  4. 建構函數
  5. 封裝、繼承、多態

1. 什麼是面向對象編程（OOP）？

面向對象編程（OOP） 是一種以物件為中心來設計和編寫程式碼的方法。OOP 有助於將現實世界的概念映射到程式中，使得代碼結構更直觀、更模組化。OOP 的核心概念包括 封裝、繼承 和 多態。

  • 封裝（Encapsulation）：將數據和操作數據的方法封裝在一起，隱藏內部的實現，對外只提供必要的介面。
  • 繼承（Inheritance）：允許一個類別從另一個類別繼承屬性和方法，使得代碼更加可重用。
  • 多態（Polymorphism）：允許不同類別的物件以相同的介面做出不同的行為，使得代碼更具彈性。

2. 類別和物件

  • 類別（Class） 是對一類物件的抽象，是物件的藍圖或模板。
  • 物件（Object） 是類別的具體實例，它包含了類別的屬性和行為。

類別的定義範例：

1
2
3
4
5
6
7
8
9
10
11
12
public class Person
{
    // 屬性
    public string Name;
    public int Age;

    // 方法
    public void Greet()
    {
        Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
    }
}

創建物件範例：

1
2
3
4
5
6
7
8
9
10
11
12
class Program
{
    static void Main(string[] args)
    {
        // 創建類別的實例（物件）
        Person person1 = new Person();
        person1.Name = "Alice";
        person1.Age = 25;

        person1.Greet(); // 輸出: Hello, my name is Alice and I am 25 years old.
    }
}

在這裡，Person 是一個類別，而 person1 是這個類別的具體物件。Name 和 Age 是屬性，Greet 是這個物件的方法。

3. 屬性與方法

  • 屬性 是類別的數據成員，描述物件的特徵。
  • 方法 是類別的行為，描述物件可以執行的操作。

我們可以使用屬性來設置或獲取物件的狀態，並使用方法來執行操作。

改進的屬性（使用 get 和 set）：

1
2
3
4
5
6
7
8
9
10
11
12
public class Car
{
    // 使用屬性來封裝字段
    public string Brand { get; set; }
    public string Color { get; set; }

    // 方法
    public void ShowCarInfo()
    {
        Console.WriteLine($"This car is a {Color} {Brand}.");
    }
}

創建物件並設置屬性：

1
2
3
4
5
Car myCar = new Car();
myCar.Brand = "Toyota";
myCar.Color = "Red";

myCar.ShowCarInfo(); // 輸出: This car is a Red Toyota.

4. 建構函數（Constructor）

建構函數 是一種特殊的方法，用於在創建物件時初始化物件的狀態。建構函數與類別同名，且不會有返回值。

  • 建構函數的範例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    public class Person
    {
        public string Name;
        public int Age;

        // 建構函數，用於初始化屬性
        public Person(string name, int age)
        {
            Name = name;
            Age = age;
        }

        public void Greet()
        {
            Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 使用建構函數創建物件並初始化屬性
            Person person2 = new Person("Bob", 30);
            person2.Greet(); // 輸出: Hello, my name is Bob and I am 30 years old.
        }
    }

在這個範例中，Person 類別有一個建構函數，可以在創建物件時為 Name 和 Age 設定初始值。

5. 封裝、繼承和多態

封裝：通過訪問修飾符（例如 public、private）來控制屬性和方法的可見性，保護數據並隱藏實現細節。

  • 私有屬性和公開方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class BankAccount
    {
        private decimal balance;

        public void Deposit(decimal amount)
        {
            if (amount > 0)
            {
                balance += amount;
                Console.WriteLine($"存入 {amount} 元，目前餘額為 {balance} 元");
            }
        }

        public decimal GetBalance()
        {
            return balance;
        }
    }

繼承：允許子類別從父類別繼承屬性和方法，從而實現代碼的重用。

  • 範例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    public class Animal
    {
        public void Eat()
        {
            Console.WriteLine("Eating...");
        }
    }

    public class Dog : Animal
    {
        public void Bark()
        {
            Console.WriteLine("Barking...");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Dog myDog = new Dog();
            myDog.Eat();  // 繼承自父類別 Animal
            myDog.Bark(); // 自己的方法
        }
    }

多態：允許不同的類別以相同的方式響應相同的消息。通常使用方法覆寫（override）來實現。

  • 範例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    public class Animal
    {
        public virtual void MakeSound()
        {
            Console.WriteLine("Some generic animal sound");
        }
    }

    public class Cat : Animal
    {
        public override void MakeSound()
        {
            Console.WriteLine("Meow");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Animal myAnimal = new Animal();
            myAnimal.MakeSound(); // 輸出: Some generic animal sound

            Animal myCat = new Cat();
            myCat.MakeSound(); // 輸出: Meow (多態)
        }
    }

在這裡，Cat 類別繼承了 Animal 類別，並覆寫了 MakeSound 方法，這樣即使使用 Animal 型別，也能調用 Cat 的實現。

實戰練習

練習 1：定義類別和創建物件

  1. 定義一個類別 Book，包含屬性 Title 和 Author，以及方法 DisplayInfo，用來顯示書名和作者。
  2. 使用這個類別創建一個物件，並輸出書的信息。

練習 2：使用建構函數

  1. 為 Book 類別添加建構函數，用來初始化 Title 和 Author。
  2. 使用建構函數創建物件並輸出書的信息。

練習 3：繼承與覆寫

  1. 定義一個類別 Vehicle，包含方法 StartEngine。
  2. 創建一個子類別 Car，繼承 Vehicle，並覆寫 StartEngine 方法以顯示特定的消息。

問題

  1. 問題： 為什麼 OOP 中需要封裝數據？
  2. 問題： 繼承如何幫助代碼的重用？

完成這些練習後，如果有任何問題或需要更深入的解釋，請隨時告訴我！我們可以進一步探討 OOP 的概念，或者學習其他編程主題，例如接口和抽象類。