軟體設計原則是確保程式碼品質的關鍵。本文探討的幾個核心原則能有效提升程式碼的健壯性與可維護性。這些原則並非互相獨立，而是相輔相成，共同作用以構建更優良的軟體架構。理解並應用這些原則，能幫助開發者寫出更具彈性、易於擴充套件和維護的程式碼，同時降低開發成本和技術債。隨著專案規模的增長，這些原則的重要性將更加凸顯。
軟體設計基礎原則
軟體設計原則是構建良好架構軟體的基礎。它們如同指引開發者建立可維護、可擴充套件和健全應用程式的燈塔，同時避免不良設計的陷阱。
在本章中，我們將探討所有開發者都應該瞭解並在專案中應用的核心設計原則。我們將深入四個基礎原則。首先是「封裝變化」，教導如何隔離程式碼中易變的部分，使應用程式更易於修改和擴充套件。接著，「偏好組合」原則讓我們理解為何透過組合簡單物件來構建複雜物件往往優於繼承功能。第三個原則「針對介面程式設計」展示了相較於針對具體類別程式設計，採用介面程式設計如何增強靈活性和可維護性。最後，透過「鬆散耦合」原則，我們將理解減少元件間依賴的重要性，使程式碼更易於重構和測試。
本章主要涵蓋以下主題：
- 遵循「封裝變化」原則
- 遵循「偏好組合而非繼承」原則
- 遵循「針對介面而非實作程式設計」原則
- 遵循「鬆散耦合」原則
透過本章的學習，讀者將對這些基礎原則及其在Python中的實作有深入的理解，為閱讀本文其餘部分奠定堅實的基礎。
遵循「封裝變化」原則
軟體開發中最大的挑戰之一是應對變化。需求變更、技術進步或使用者行為的變化都可能對現有系統造成衝擊。「封裝變化」原則提供了一種策略來隔離這些變化，使系統更具彈性和可維護性。
實作「封裝變化」
要實作「封裝變化」，首先需要識別系統中哪些部分最容易變化。這些變化可能源於多種因素，如業務規則的變更、使用者介面的變更或後端資料函式庫的變更。一旦識別出這些易變的部分，就應該將它們封裝在獨立的模組或類別中。
from abc import ABC, abstractmethod
# 定義抽象類別
class PaymentGateway(ABC):
@abstractmethod
def process_payment(self, amount):
pass
# 具體實作類別
class PayPalPaymentGateway(PaymentGateway):
def process_payment(self, amount):
print(f"Processing PayPal payment of ${amount}")
class StripePaymentGateway(PaymentGateway):
def process_payment(self, amount):
print(f"Processing Stripe payment of ${amount}")
# 使用者端程式碼
class ShoppingCart:
def __init__(self, payment_gateway: PaymentGateway):
self.payment_gateway = payment_gateway
def checkout(self, amount):
self.payment_gateway.process_payment(amount)
# 使用範例
if __name__ == "__main__":
paypal_gateway = PayPalPaymentGateway()
stripe_gateway = StripePaymentGateway()
cart1 = ShoppingCart(paypal_gateway)
cart1.checkout(100)
cart2 = ShoppingCart(stripe_gateway)
cart2.checkout(200)
圖表翻譯：支付處理流程
此圖表展示了在購物車結帳過程中如何根據選擇的支付方式進行不同的支付處理。透過抽象支付介面，我們可以靈活地支援多種支付方式，並且能夠輕鬆新增或替換支付處理器，展現了「封裝變化」原則的應用。
遵循「偏好組合而非繼承」原則
在軟體設計中，繼承是一種常見的程式碼重用機制。然而，過度使用繼承可能導致類別層次結構過於複雜，難以維護。「偏好組合而非繼承」原則建議透過組合簡單物件來構建複雜物件，而不是透過繼承來擴充套件功能。
實作「組合優於繼承」
# 組合範例
class Engine:
def start(self):
print("Engine started")
class Car:
def __init__(self):
self.engine = Engine()
def start_car(self):
self.engine.start()
print("Car started")
# 使用範例
if __name__ == "__main__":
car = Car()
car.start_car()
圖表翻譯：汽車啟動流程
此圖表清晰地展示了汽車啟動的流程，透過組合Engine類別到Car類別中，實作了汽車啟動的功能，同時保持了各個類別職責的單一性。
遵循「針對介面而非實作程式設計」原則
「針對介面而非實作程式設計」原則強調了使用抽象介面而非具體實作類別進行程式設計的重要性。這種方法提高了程式碼的靈活性，使得在不修改客戶端程式碼的情況下，可以輕鬆替換或新增實作。
實作「針對介面程式設計」
from abc import ABC, abstractmethod
# 定義抽象介面
class Logger(ABC):
@abstractmethod
def log(self, message):
pass
# 具體實作類別
class ConsoleLogger(Logger):
def log(self, message):
print(f"Console: {message}")
class FileLogger(Logger):
def log(self, message):
print(f"File: {message}")
# 使用者端程式碼
class Application:
def __init__(self, logger: Logger):
self.logger = logger
def run(self):
self.logger.log("Application started")
# 使用範例
if __name__ == "__main__":
console_logger = ConsoleLogger()
file_logger = FileLogger()
app1 = Application(console_logger)
app1.run()
app2 = Application(file_logger)
app2.run()
圖表翻譯：日誌記錄流程
此圖表展示了應用程式如何根據不同的日誌記錄需求，靈活地選擇不同的日誌記錄器，體現了「針對介面而非實作程式設計」原則的優勢。
遵循「鬆散耦合」原則
「鬆散耦合」原則旨在減少系統中各個元件之間的依賴關係，提高系統的彈性和可維護性。實作鬆散耦合的關鍵在於透過介面和抽象層來隔離元件之間的直接依賴。
實作「鬆散耦合」
from abc import ABC, abstractmethod
# 定義抽象資料儲存介面
class DataStore(ABC):
@abstractmethod
def save(self, data):
pass
# 具體實作類別
class DatabaseDataStore(DataStore):
def save(self, data):
print(f"Saving data to database: {data}")
class FileDataStore(DataStore):
def save(self, data):
print(f"Saving data to file: {data}")
# 使用者端程式碼
class DataProcessor:
def __init__(self, data_store: DataStore):
self.data_store = data_store
def process_and_save(self, data):
# 模擬資料處理
processed_data = data.upper()
self.data_store.save(processed_data)
# 使用範例
if __name__ == "__main__":
db_store = DatabaseDataStore()
file_store = FileDataStore()
processor1 = DataProcessor(db_store)
processor1.process_and_save("example data")
processor2 = DataProcessor(file_store)
processor2.process_and_save("example data")
圖表翻譯：資料處理與儲存流程
此圖表展示了資料處理流程中如何透過抽象的資料儲存介面實作不同的儲存方式，體現了「鬆散耦合」原則在提高系統彈性方面的優勢。
封裝變化：軟體設計的核心原則
在軟體開發過程中，需求變更是不可避免的。技術的不斷進步和使用者需求的變化，使得編寫能夠適應變化的程式碼變得至關重要。封裝變化（Encapsulate What Varies）原則正是為瞭解決這個問題而提出的。
封裝變化的意義
封裝變化的核心思想是將程式碼中可能變化的部分隔離出來，並將其封裝起來。這樣做的好處是，當需求變更時，只需要修改封裝的部分，而不會影響到其他程式碼，從而減少了引入錯誤的風險。
封裝變化的好處
封裝變化帶來了多個好處，主要包括：
- 易於維護：當需求變更時，只需要修改封裝的部分，降低了引入錯誤的風險。
- 增強靈活性：封裝的元件可以輕易地被替換或擴充套件，提供了一個更具適應性的架構。
- 提高可讀性：封裝使得程式碼更加有組織，更容易被理解。
實作封裝的技術
在Python中，實作封裝的關鍵技術包括多型（Polymorphism）和 getter/setter 方法。
多型
多型是物件導向程式設計（OOP）中的一個核心概念，它允許不同類別的物件被視為同一超類別的物件。多型使得一個介面可以代表不同的型別，從而實作了乾淨、可維護的程式碼。
Getter 和 Setter 方法
Getter 和 Setter 方法是類別中用於控制屬性存取的特殊方法。Getter 方法允許讀取屬性值，而 Setter 方法允許修改屬性值。透過這些方法，可以新增驗證邏輯或日誌記錄等，從而實作封裝。
Python中的@property裝飾器提供了一種更優雅的方式來實作 Getter 和 Setter 方法的功能。它允許將屬性存取轉換為方法呼叫，從而實作資料封裝和驗證。
範例：使用多型實作封裝
假設我們正在開發一個支付處理系統，支付方式可能會有所不同。在這種情況下，我們可以將每種支付方式封裝在自己的類別中。
from abc import ABC, abstractmethod
class PaymentBase(ABC):
def __init__(self, amount: int):
self.amount: int = amount
@abstractmethod
def process_payment(self):
pass
class CreditCard(PaymentBase):
def process_payment(self):
msg = f"信用卡支付：{self.amount}"
print(msg)
class PayPal(PaymentBase):
def process_payment(self):
msg = f"PayPal支付：{self.amount}"
print(msg)
if __name__ == "__main__":
payments = [CreditCard(100), PayPal(200)]
for payment in payments:
payment.process_payment()
程式碼解密：
此範例展示瞭如何使用多型實作支付方式的封裝。我們定義了一個抽象基礎類別PaymentBase，其中包含一個抽象方法process_payment。然後，我們建立了兩個具體的支付類別CreditCard和PayPal，它們繼承自PaymentBase並實作了process_payment方法。在主程式中，我們建立了一個包含不同支付物件的列表，並對每個物件呼叫process_payment方法。多型使得我們可以統一處理不同類別的支付物件。
圖表翻譯：
此圖示展示了支付處理流程。首先，系統會根據選擇的支付方式進行不同的處理。如果選擇信用卡支付，則執行信用卡支付的邏輯；如果選擇PayPal支付，則執行PayPal支付的邏輯。無論選擇哪種支付方式，最終都會完成支付處理。
範例：使用@property實作封裝
接下來，我們定義一個Circle類別，並展示如何使用Python的@property技術為其半徑屬性建立Getter和Setter方法。
class Circle:
def __init__(self, radius: float):
self._radius = radius
@property
def radius(self) -> float:
return self._radius
@radius.setter
def radius(self, value: float):
if value < 0:
raise ValueError("半徑不能為負數")
self._radius = value
if __name__ == "__main__":
circle = Circle(5.0)
print(circle.radius) # 輸出：5.0
circle.radius = 10.0
print(circle.radius) # 輸出：10.0
try:
circle.radius = -1.0
except ValueError as e:
print(e) # 輸出：半徑不能為負數
程式碼解密：
此範例展示瞭如何使用@property裝飾器為Circle類別的半徑屬性實作封裝。我們定義了一個私有屬性_radius，並使用@property裝飾器建立了一個名為radius的屬性。該屬性的Getter方法傳回_radius的值，而Setter方法則在設定_radius值之前進行了負數檢查，從而確保了半徑的合法性。
圖表翻譯：
此圖示展示了存取Circle類別半徑屬性的流程。當存取半徑屬性時，如果是讀取操作，則直接傳回半徑值；如果是設定操作，則會檢查新值是否為負數。如果是負數，則丟擲ValueError；如果不是負數，則設定新的半徑值。這個流程確保了半徑屬性的合法性。
物件導向設計原則在Python中的應用
物件導向程式設計（OOP）是一種強大的程式設計正規化，它透過封裝、繼承和多型性來提高程式碼的可維護性和可擴充套件性。在Python中，物件導向設計原則的應用對於構建高效、靈活的軟體系統至關重要。本文將深入探討幾個關鍵的設計原則，包括封裝、組合優於繼承以及針對介面而非實作進行程式設計。
封裝的實作
封裝是物件導向程式設計中的一個基本概念，它涉及將資料和操作資料的方法繫結在一起。在Python中，我們可以透過使用類別和屬性裝飾器來實作封裝。
class Circle:
def __init__(self, radius: int):
self._radius: int = radius
@property
def radius(self):
return self._radius
@radius.setter
def radius(self, value: int):
if value < 0:
raise ValueError("半徑不能為負數！")
self._radius = value
if __name__ == "__main__":
circle = Circle(10)
print(f"初始半徑：{circle.radius}")
circle.radius = 15
print(f"新的半徑：{circle.radius}")
內容解密：
此程式碼定義了一個名為Circle的類別，用於表示圓形。透過使用@property裝飾器，我們實作了對radius屬性的封裝。radius的getter方法傳回半徑的值，而setter方法允許修改半徑，但在修改前會進行有效性檢查，確保半徑不為負數。這種封裝機制使得我們可以在不影響外部程式碼的情況下，修改內部的實作細節。
組合優於繼承原則
在物件導向程式設計中，繼承是一種常見的程式碼重用機制。然而，過度使用繼承可能導致程式碼變得緊密耦合，難以維護和擴充套件。組合優於繼承原則建議我們應該優先使用組合來構建複雜物件，而不是透過繼承。
@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle
title 軟體設計基礎原則實踐
package "資料視覺化流程" {
package "資料準備" {
component [資料載入] as load
component [資料清洗] as clean
component [資料轉換] as transform
}
package "圖表類型" {
component [折線圖 Line] as line
component [長條圖 Bar] as bar
component [散佈圖 Scatter] as scatter
component [熱力圖 Heatmap] as heatmap
}
package "美化輸出" {
component [樣式設定] as style
component [標籤註解] as label
component [匯出儲存] as export
}
}
load --> clean --> transform
transform --> line
transform --> bar
transform --> scatter
transform --> heatmap
line --> style --> export
bar --> label --> export
note right of scatter
探索變數關係
發現異常值
end note
@enduml圖表翻譯：
此圖示展示了組合與繼承在構建複雜物件時的差異。組合提供了更高的靈活性和可重用性，而繼承可能導致程式碼變得緊密耦合，難以維護。透過選擇組合，我們可以更輕鬆地更換或更新個別元件，而不會影響整體系統。
class Engine:
def start(self):
print("引擎已啟動")
class Car:
def __init__(self):
self.engine = Engine()
def start(self):
self.engine.start()
print("汽車已啟動")
if __name__ == "__main__":
my_car = Car()
my_car.start()
內容解密：
在這個範例中，Car類別透過組合包含了Engine類別的例項。這種設計使得我們可以輕鬆地更換引擎型別，而不需要修改Car類別本身。透過組合，我們實作了程式碼的靈活性和可維護性。
針對介面而非實作進行程式設計
在軟體設計中，過度關注實作細節可能導致程式碼變得緊密耦合，難以修改。針對介面而非實作進行程式設計的原則提供了一種解決方案。
from abc import ABC, abstractmethod
class PaymentGateway(ABC):
@abstractmethod
def process_payment(self, amount: float):
pass
class StripePaymentGateway(PaymentGateway):
def process_payment(self, amount: float):
print(f"透過Stripe處理支付：${amount}")
class PayPalPaymentGateway(PaymentGateway):
def process_payment(self, amount: float):
print(f"透過PayPal處理支付：${amount}")
def process_transaction(gateway: PaymentGateway, amount: float):
gateway.process_payment(amount)
if __name__ == "__main__":
stripe_gateway = StripePaymentGateway()
paypal_gateway = PayPalPaymentGateway()
process_transaction(stripe_gateway, 100.0)
process_transaction(paypal_gateway, 200.0)
內容解密：
這個範例展示瞭如何使用抽象基礎類別（ABC）來定義介面。PaymentGateway是一個抽象基礎類別，定義了process_payment方法。具體的支付閘道（如Stripe和PayPal）實作了這個介面。透過針對介面進行程式設計，我們可以輕鬆地在不同的支付閘道之間切換，而不需要修改使用這些閘道的程式碼。
