昨天我們學了 函式 (Functions) 與 Optional。

今天要介紹 物件導向程式設計（OOP, Object-Oriented Programming）。

在程式設計中，OOP 是非常常見的設計方式，具有三大核心特性：

• 封裝 (Encapsulation)：保護資料，避免外部隨意修改。
• 繼承 (Inheritance)：子類別可沿用或改寫父類別的功能。
• 多型 (Polymorphism)：相同方法，不同物件可表現出不同行為。

Swift 本身支援 OOP，我們可以透過 class（類別） 與 struct（結構） 定義型別，並搭配 屬性 (Properties)、方法 (Methods) 來組織程式。

類別與物件（Class & Object）

類別就像是一個藍圖，而物件就是使用類別建立出來的實體。

// 定義類別
class Dog {
    var name: String
    var age: Int

    // 建構子 (initializer)
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    // 方法 (method)
    func bark() {
        print("\(name) : 旺!")
    }
    func getAge() {
        print("\(name) \(age)歲")
    }
}

// 建立物件
let myDog = Dog(name: "小黑", age: 3)
myDog.bark() // 小黑 : 旺!
myDog.getAge() // 小黑 3歲

• Dog 是一個類別
• myDog 是 Dog 的物件（實體）
• name 和 age 是屬性
• bark() 、getAge()是方法

結構（Struct）

Swift 除了 class，還有 struct。

struct Point {
    var x: Int
    var y: Int

    func description() -> String {
        return "(\(x), \(y))"
    }
}

let p = Point(x: 3, y: 5)
print(p.description()) // (3, 5)

• struct 與 class 類似，也有屬性和方法。
• 最大的差異是 class 是「參考型別 (reference type)」，struct 是「值型別 (value type)」。
  • class 建立的物件是共用參考，如果一個地方改了，另一個地方也會跟著改。
  • struct 則是複製一份新的資料。

繼承（Inheritance）

繼承是物件導向的核心。透過繼承，我們可以建立一個子類別（subclass），並且覆寫（override）父類別的功能，又或者使用父類別的功能。

class Animal {
    
    var age: Int
    
    init(age: Int) {
        self.age = age
    }
    
    func speak() {
        print("...")
    }
    
    func getAge() {
        print("age \(age)")
    }
}

class Cat: Animal {
    override func speak() {
        print("喵")
    }
}

class Dog: Animal {
    override func speak() {
        print("旺")
    }
}

let cat = Cat(age: 8)
cat.speak() // 喵
cat.getAge() // age 8

let dog = Dog(age: 10)
dog.speak() // 旺
dog.getAge() // age 10

let animal = Animal(age: 15)
animal.speak() // ...
animal.getAge() // age 15

多型（Polymorphism）

「多型」的意思是：相同的方法呼叫，不同的物件可以有不同的表現。

let animals: [Animal] = [Cat(), Dog(), Animal()]

for animal in animals {
    animal.speak()
}

output:

喵
旺
...

雖然它們都是 Animal 型別，但根據實際的類別不同，會有不同的行為。這就是多型的威力。

封裝（Encapsulation）

封裝就是把資料保護起來，不讓外部隨意更改，通常搭配 存取控制 (Access Control) 使用。

class BankAccount {
    private var balance: Int = 0  // 外部不能直接存取

    func deposit(amount: Int) {
        balance += amount
    }

    func withdraw(amount: Int) {
        if amount <= balance {
            balance -= amount
        } else {
            print("餘額不足！")
        }
    }

    func getBalance() -> Int {
        return balance
    }
}

let account = BankAccount()
account.deposit(amount: 1000)
account.withdraw(amount: 500)
print(account.getBalance()) // 500

Class vs Struct 的選擇

在 Swift 中常會有個問題：到底該用 class 還是 struct？

建議：

• struct：適合比較小、輕量，通常用來表示「資料」。
• class：適合需要「繼承」、「共享狀態」的情境。

例如：

• struct Point：只是單純存放座標，值型別比較安全。
• class ViewController：需要繼承 UIKit / SwiftUI 的類別，必須用 class。

結語

今天學到了 Swift 中物件導向的核心概念：

1. 類別與物件：class 建立藍圖，object 創造實體。
2. 結構體：值型別，適合表示單純資料。
3. 繼承與多型：讓不同子類別可以有不同的表現。
4. 封裝：保護資料不被隨意更動。
5. Class vs Struct：根據需求選擇不同的型別。

掌握這些之後，能更有效率地組織程式架構，寫出乾淨又好維護的程式碼。