物件導向（OOP）與程式設計的風格

這個單元我一直很想學習，物件導向 Object Oriented Programming 聽起來是個很酷的功能，而且是只有 Python 可以使用，沒想到事實是：

物件導向是一種程式設計的概念，而Python 是一種物件導向語言是「不正確」的說法

學校老師沒教你 OOP 物件導向的秘密 Why is Java NOT an OOP Language? 【電腦說人話】(CC字幕)

簡單來說，物件導向程式設計就像創立一個「烤餅乾的模板」（Class），而每個用這個模板烤出來的餅乾就是「物件」（Instance）。餅乾裡的內餡可以依照需求調整，但是外型是根據 Class 為基底創造，這代表每個物件都可以有不同的屬性。

更精確地來說是 OOP 的核心是 State and message 跟物件 Ｏbject 這個詞沒有直接關係。State（狀態） 指的是物件的屬性值（Attributes），用來描述物件（例如某學生）當前的數據或狀態。再透過Message（訊息） ，物件之間的溝通方式，透過方法呼叫（Method Call） 傳送訊息，改變物件的狀態或要求物件執行某些行為（例如更新成績）。

物件導向的設計適合用於建立遊戲角色，都會有基本的名字、年齡、技能。如果我不用物件導向的方式設計程式，我就要在每個角色都複製貼上名字、年齡、技能，再更改數值。

1. Class & Method (類別與方法)

Class 是用來定義物件的模板，裡面可以包含屬性（特性）和方法（功能）。

• 屬性（Attributes）：物件的特性，如名字、年齡等。
• 方法（Methods）：物件的行為或功能，如走路、說話等。方法是需要被「呼叫」而不是像屬性一開始就建立好。我覺得用「行動」來解釋會比方法

接下來，我們來看如何建構「模板」Class 吧!

2. __init__ (建構子方法)、self

• 建構子方法（Initializer）
  • __init__ 是 Python 中的建構子方法，也叫「初始化方法」。
  • 它會在建立物件的瞬間自動執行，用來設定物件的屬性（資料）就會馬上帶入姓名、學號。例如我建立一個學生的基本資訊會有姓名、學號，當我建立學生 A，只要依序輸入「bicky, 10530」，程式就知道我輸入的是姓名和學號。
  • 小提醒：字要拼對，我一開始寫 initi 所以一直跑不出來
• self 是物件本身
  • self 代表這個物件的自己，就像你在補習班的個人資料表。
  • 任何屬性都要寫成 self.屬性名稱 = 值，這樣物件才能記住你的資料。
• 自動呼叫，無需手動啟動
  • 當你用 物件 = 類別(參數...) 來創造物件時，__init__ 方法就會自動被呼叫。
  • 你只需要把必要的參數傳進去，程式會幫你完成初始化的設定。

Q1：一定要有 self 嗎？

A：是的，self 是 Python 的規範，代表物件自己，要去接住之後創立的實體。不

Q2：如果沒寫 __init__ 會怎樣？

A：物件還是可以被創造，但沒有任何屬性被初始化，等於一個「空白資料表」。

程式碼範例：創造補習班學生名單

程式解釋

1. 當 student1 = Student("小明", "高三", "數學") 被執行時：
2. • Python 自動呼叫 __init__，幫 student1 設定：self.name = "小明"self.grade = "高三"self.course = "數學"
2. 當我們呼叫 student1.show_info() 時（我把"."想成發動某功能），物件會記住這些屬性並輸出：

   姓名: 小明, 年級: 高三, 課程: 數學

# 定義一個學生類別
class Student:
    # 初始化方法 (告訴程式，第一個第二第三個值個別是什麼」
    def __init__(self, name, grade, course):
        self.name = name      # 記錄學生名字. 可以解釋成「的」
        self.grade = grade    # 記錄學生年級
        self.course = course  # 記錄報名的課程
    
    # 定義一個方法：顯示學生資料
    def show_info(self):
        print(f"姓名: {self.name}, 年級: {self.grade}, 課程: {self.course}")

# 創建學生物件
student1 = Student("小明", "高三", "數學")
student2 = Student("老楊", "高二", "英文")

# 顯示學生資料
student1.show_info()
student2.show_info()

3. Abstraction (抽象化)

抽象化 是指隱藏不必要的細節，僅保留物件的核心功能。

抽象化的核心概念：

• 隱藏細節，展示功能。
• 使用者不需要知道內部的運作，只要知道怎麼用即可。
• 程式設計應用場景：
  • 設計抽象類別，規範子類別的行為，不需要在抽象類別中實作功能。
  • 子類別根據具體需求實作抽象方法。

在程式中，如果我們要設計一個「動物」的模板，但不想指定每種動物的具體叫聲（因為每個動物的叫聲不同），就可以使用抽象化（Abstraction）。

例子：建立不同動物的行為 (不用知道這個聲音怎麼發出來)

^{此程式碼由 ChatGPT 產生}

# 引入抽象類別模組
from abc import ABC, abstractmethod

# 抽象類別: Animal
class Animal(ABC):
    # 抽象方法 (沒有實作)
    @abstractmethod
    def make_sound(self):
        pass  # 這裡什麼都不做，等子類別來實作

# 繼承抽象類別
class Dog(Animal):
    def make_sound(self):
        print("汪汪！")  # 實作叫聲方法

class Cat(Animal):
    def make_sound(self):
        print("喵喵！")  # 實作叫聲方法

# 創建物件並呼叫方法
dog = Dog()
cat = Cat()

dog.make_sound()  # 輸出: 汪汪！
cat.make_sound()  # 輸出: 喵喵！

Inheritance 的三大重點：

我會用徒弟承襲師傅的武功，又可以更改部分內容創造自己的武功，再傳給自己的徒弟。

1. 繼承功能，避免重複程式碼
   子類別可以直接使用父類別的屬性與方法，不必重新寫一遍。
2. 擴展功能（方法覆寫）
   子類別可以重新定義（覆寫）父類別的方法，修改其行為。
3. 多層繼承（進階概念）
   子類別還能再被其他類別繼承，形成「多層繼承」結構。

程式範例：動物與寵物 (Inheritance)

1. 設計父類別：Animal

# 定義父類別 (父母)
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self): #method吃東西
        print(f"{self.name} 正在吃東西。")

2. 設計子類別：Dog 與 Cat

# 定義子類別 (繼承父類別 Animal)
class Dog(Animal):
    def bark(self):
        print(f"{self.name} 說：汪汪！")

class Cat(Animal):
    def meow(self):
        print(f"{self.name} 說：喵喵！")

3. 使用物件：創造狗和貓的實例

# 創建物件
dog = Dog("小黑")
cat = Cat("小白")

# 呼叫繼承的屬性與方法
dog.eat()      # 繼承自 Animal 類別
dog.bark()     # 子類別的方法

cat.eat()      # 繼承自 Animal 類別
cat.meow()     # 子類別的方法

輸出結果：

小黑 正在吃東西。
小黑 說：汪汪！
小白 正在吃東西。
小白 說：喵喵！

解釋發生了什麼？

1. 定義父類別 Animal：
2. • 它擁有 name 屬性，還有一個方法 eat()。
2. 繼承父類別：
3. • Dog 和 Cat 繼承了 Animal，因此不需要再次定義 eat() 方法。
3. 擴展功能：
4. • Dog 類別擁有一個 bark() 方法，專屬於狗。
   • Cat 類別擁有一個 meow() 方法，專屬於貓。
4. 創建物件並使用：
5. • 創建 dog 和 cat 物件後，可以使用從 Animal 繼承來的 eat() 方法，以及各自的新功能 bark() 和 meow()。

進階概念：覆寫 (Method Overriding)

有時候，子類別可能需要改寫（覆寫）父類別的方法，例如重新設計行為：

範例：覆寫父類別方法

class Animal:
    def __init__(self, name):
        self.name = name
    
    def sound(self):
        print("動物發出聲音。")

# 子類別覆寫父類別的方法
class Dog(Animal):
    def sound(self): #sound改成直接說汪汪
        print(f"{self.name} 說：汪汪！")

class Cat(Animal):
    def sound(self):
        print(f"{self.name} 說：喵喵！")

# 創建物件並測試
dog = Dog("小黑")
cat = Cat("小白")

dog.sound()  # 輸出: 小黑 說：汪汪！
cat.sound()  # 輸出: 小白 說：喵喵！

5. Encapsulation (封裝)

在程式設計中，封裝 就是隱藏物件的內部資料，只讓外界透過受控的方式存取和修改。

白話文的比喻是 封裝（Encapsulation） 就像老師會保管學生的個人成績，不讓其他學生直接查看，但允許合法查詢，例如家長來問時，老師會提供「經過篩選的資料」。

補習班的比喻：成績資料庫

• 學生成績存在學校的「成績資料庫」中，屬於隱私資料。
• 學生或家長不能直接改成績，因為這樣不安全。
• 如果學生想知道自己的成績，必須合法查詢，如：
• • 查詢接口（Getter）：詢問成績，老師會讀取並回報。
  • 修改接口（Setter）：如果成績有錯誤，家長提出申訴，老師經過核對後可以更改。

封裝的三大重點：

1. 隱藏資料（資料保護）
2. • 透過私有屬性 (private attributes)，不讓外界直接存取物件內部資料。
2. 受控存取（安全操作）
3. • 提供Getter（讀取資料）和Setter（修改資料）來管理資料存取。
3. 避免錯誤（資料驗證）
4. • 可以在 Setter 中加入條件檢查，確保資料正確。

程式範例：學生成績管理 (Encapsulation)

1. 定義學生類別 Student

class Student:
    def __init__(self, name, score):
        self.name = name              # 公開屬性
        self.__score = score          # 私有屬性（封裝）在屬性前面加雙底線__

    # Getter 方法（讀取分數）
    def get_score(self):
        return self.__score    #return後不能賦值操作

    # Setter 方法（修改分數，並檢查分數是否合法）
    def set_score(self, score):
        if 0 <= score <= 100:          # 確保分數範圍在 0~100
            self.__score = score
        else:
            print("分數必須在 0 到 100 之間！")

    # 顯示學生資訊
    def show_info(self):
        print(f"學生: {self.name}, 分數: {self.__score}")

2. 測試物件：建立與操作 Student

# 建立學生物件
student1 = Student("小明", 85)
student1.show_info()   # 輸出: 學生: 小明, 分數: 85

# 嘗試直接修改私有屬性（錯誤操作）
student1.__score = 95   # 沒有效果，因為 __score 被封裝了
student1.show_info()    # 輸出仍為: 學生: 小明, 分數: 85

# 使用 Setter 方法合法修改
student1.set_score(95)  # 修改成功
student1.show_info()    # 輸出: 學生: 小明, 分數: 95

# 嘗試輸入無效分數
student1.set_score(150) # 輸出: 分數必須在 0 到 100 之間！

解釋發生了什麼？

1. 資料保護：
2. • self.__score 被定義為私有屬性（前面加上雙底線 __），外部無法直接存取和更改。
2. 受控存取：
3. • get_score() 是一個Getter，用來讀取分數。
   • set_score() 是一個Setter，用來修改分數，並檢查分數範圍是否正確。
3. 錯誤預防：
4. • 如果分數不在 0 到 100 之間，set_score() 會顯示錯誤訊息，防止無效資料。

6. Polymorphism (多型)

多型 表示不同的類別可以有相同的方法名稱，但表現不同的行為。例如，狗和貓都能發出聲音，但聲音不同。

程式碼範例：

class Dog:
    def speak(self):
        print("汪汪！")

class Cat:
    def speak(self):
        print("喵喵！")

# 多型實作
def make_sound(animal):
    animal.speak()

make_sound(Dog())  # 汪汪！
make_sound(Cat())  # 喵喵！

總結：

物件導向程式設計幫助我們組織程式碼，更容易維護和擴展。關鍵概念包括：

• 類別與物件：建立資料模型。
• 方法與屬性：定義物件行為與特性。
• 建構子與 self：自動初始化物件屬性。
• 抽象化、繼承、封裝與多型：設計更彈性、更易於管理的應用程式

小比較：

• Abstraction（抽象化）是告訴你「功能怎麼用，細節不需要知道。」
• Encapsulation（封裝）是保護資料，「不該讓外部亂改，資料只能安全存取。」

既然提到程式風格，我再補充一些常聽到的程式設計觀念：

常見的程式設計觀念

Imperative vs Declarative Programming

1. Imperative Programming (命令式程式設計)

什麼是命令式程式設計？

重點：描述「如何做」，一步步執行每個操作。

簡單比喻：煮泡麵的命令式操作

1. 煮水
2. 放入泡麵
3. 等待 3 分鐘
4. 倒入調味包
5. 攪拌均勻

命令式程式碼範例（Python）

# 計算從 1 到 5 的總和（命令式）
total = 0
for i in range(1, 6):
    total += i
print(f"總和是: {total}")

2. Declarative Programming (聲明式程式設計)

什麼是聲明式程式設計？

你只需要描述想要的結果，不必關心怎麼實現。

簡單比喻：外送點餐的聲明式操作

• 點餐 App：「我要一個珍珠奶茶。」
• 不需要知道如何準備珍奶，外送員直接幫你送過來。

聲明式程式碼範例（Python - 使用 sum()）

# 計算從 1 到 5 的總和（聲明式）
total = sum(range(1, 6))
print(f"總和是: {total}")

3. Procedural Programming (程序式程式設計)

什麼是程序式程式設計？

程序式程式設計就像補習班每天上課的流程：

1. 進入教室
2. 開始點名
3. 上課教學
4. 下課擦黑板

重點： 把程式分成具體步驟的程序或功能，重複使用。

程序式程式碼範例（Python）

# 程序式設計：計算圓的面積
import math

# 定義一個函數（程序）
def calculate_area(radius):
    return math.pi * radius ** 2

# 使用程序
area = calculate_area(5)
print(f"圓的面積是: {area:.2f}")

4. Functional Programming (函數式程式設計)

什麼是函數式程式設計？

簡單比喻：點飲料機（功能固定）

• 飲料機只專注於輸入與輸出：
• • 投幣 + 選擇飲料 → 出飲料（結果總是一樣）。

函數式程式碼範例（Python - 使用 map()）

# 使用函數式程式設計（map）
numbers = [1, 2, 3, 4, 5]

# 定義一個函數，將數字平方
def square(n):
    return n ** 2

# 使用函數式程式設計應用
squared_numbers = list(map(square, numbers))
print(squared_numbers)

重點總結：

• Imperative (命令式)：一步步指示，描述怎麼做。
• Declarative (聲明式)：只描述想要的結果，不關心怎麼實現。
• Procedural (程序式)：按固定程序與功能模組執行。
• Functional (函數式)：專注純函數運算，沒有副作用。