[Python教學] 中級：物件導向程式設計（OOP）

Python 的物件導向程式設計 (Object-Oriented Programming, OOP) 是其最強大和靈活的特性之一。通過 OOP 的思想，我們可以組織、抽象並簡化程式碼結構，以達到更好的可維護性和可擴展性。本篇教學文章將深入介紹 Python 中的類別與物件、繼承、多型、封裝等面向對象的核心概念，並詳細解說方法與屬性的使用。

1. 類別與物件

在 Python 中，類別 是一種模版，用於定義某種對象應該具有的屬性和方法；物件 是類別的實例化結果，每個物件都可以有自己的屬性數據。

1.1 類別定義與物件實例化

我們可以使用 class 關鍵字來定義一個類別，並在類別內部定義屬性與方法。

# 定義類別
class Dog:
    # 初始化方法，用於設置物件屬性
    def __init__(self, name, age):
        self.name = name  # 屬性
        self.age = age    # 屬性
    
    # 方法：定義物件行為
    def bark(self):
        print(f"{self.name} says: Woof!")
        
# 創建物件（實例化類別）
my_dog = Dog("Buddy", 3)
print(f"My dog's name is {my_dog.name} and he's {my_dog.age} years old.")
my_dog.bark()

在這段程式碼中：

• Dog 是一個類別，定義了狗的 name 和 age 屬性，並且有一個 bark() 方法。
• __init__ 方法稱為 初始化方法，每當創建物件時自動調用，以設置物件的初始屬性值。
• my_dog 是 Dog 類別的物件，它的 name 是 "Buddy"，age 是 3，並可以調用 bark() 方法。

2. 屬性與方法

2.1 屬性

屬性可以理解為物件的特徵或狀態，例如「年齡」或「名字」。在 Python 中，屬性通常在初始化方法 __init__ 中使用 self 進行定義：

class Car:
    def __init__(self, model, year):
        self.model = model
        self.year = year

2.2 方法

方法是定義在類別中的函式，用於描述物件的行為。方法的第一個參數通常為 self，表示對當前物件的引用。

class Car:
    def __init__(self, model, year):
        self.model = model
        self.year = year

    def start(self):
        print(f"{self.model} is starting.")

# 使用方法
my_car = Car("Toyota", 2020)
my_car.start()

3. 繼承 (Inheritance)

繼承 是一種將現有類別的屬性和方法傳承至新類別的方式。通過繼承，子類別可以獲得父類別的屬性和方法，同時也能新增自己的屬性和方法。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Some sound")

class Dog(Animal):  # Dog 繼承 Animal 類別
    def speak(self):  # 覆寫父類別方法
        print(f"{self.name} says: Woof!")

class Cat(Animal):  # Cat 繼承 Animal 類別
    def speak(self):  # 覆寫父類別方法
        print(f"{self.name} says: Meow!")

dog = Dog("Buddy")
cat = Cat("Whiskers")

dog.speak()  # Buddy says: Woof!
cat.speak()  # Whiskers says: Meow!

這裡，Dog 和 Cat 都繼承了 Animal 的屬性和方法，但覆寫了 speak() 方法，以提供各自的特定行為。

4. 多型 (Polymorphism)

多型 允許不同類別的物件在呼叫相同方法時表現出不同的行為。在 Python 中，多型的概念通常與繼承和方法覆寫結合使用。

在上例中，Dog 和 Cat 都擁有 speak() 方法。無論哪一種物件，當我們呼叫 speak() 時，它們會各自表現出不同的行為，這就是多型。

# 定義一個接受多型的函式
def animal_sound(animal):
    animal.speak()

animal_sound(dog)  # Buddy says: Woof!
animal_sound(cat)  # Whiskers says: Meow!

這樣，我們可以通過 animal_sound 函數對不同類別的物件進行相同的操作，這就是多型的應用。

5. 封裝 (Encapsulation)

封裝 是將類別的屬性和方法保護起來，使得它們無法在類別外部被直接訪問和修改。這樣可以限制外部程式對類別內部的干涉，確保數據的安全性。Python 透過以下方式來實現封裝：

• 單下劃線 _attribute：屬性或方法被視為「保護」。
• 雙下劃線 __attribute：屬性或方法被視為「私有」。

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有屬性

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

account = Account("John", 100)
account.deposit(50)
print(account.get_balance())  # 150

在此例中，__balance 是一個私有屬性，外部無法直接存取，只能透過 get_balance 取得。

6. 綜合範例：完整的類別設計

綜合以上概念，以下是一個使用類別、屬性、方法、繼承、多型及封裝的完整範例：

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.__salary = salary  # 私有屬性

    def get_salary(self):
        return self.__salary

    def work(self):
        print(f"{self.name} is working.")

class Manager(Employee):  # 繼承 Employee
    def work(self):  # 覆寫方法
        print(f"{self.name} is managing.")

class Developer(Employee):  # 繼承 Employee
    def work(self):  # 覆寫方法
        print(f"{self.name} is developing.")

def employee_task(employee):
    employee.work()

manager = Manager("Alice", 5000)
developer = Developer("Bob", 4000)

# 執行工作
employee_task(manager)     # Alice is managing.
employee_task(developer)   # Bob is developing.

# 獲取薪水
print(manager.get_salary())  # 5000
print(developer.get_salary())  # 4000

此範例展示了：

• 類別與物件：Employee、Manager 和 Developer 類別。
• 屬性與方法：name 屬性和 work() 方法。
• 繼承：Manager 和 Developer 繼承自 Employee。
• 多型：employee_task() 函數接收不同類別的物件並執行其 work() 方法。
• 封裝：__salary 屬性為私有屬性，外部無法直接存取。

小結

Python 的物件導向程式設計可以讓我們在處理複雜專案時，更加組織化和模組化。透過類別與物件、繼承、多型和封裝，我們能夠創建靈活的程式碼結構，使程式易於擴展與維護。學習 OOP 會讓你的 Python 程式設計技能更上層樓，使你能夠處理更為複雜的專案需求。