常用的几种设计模式

常用的设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。每种模式都有适用的场景和优势。以下是每种设计模式的简要介绍和 Python 案例示例。

创建型模式

工厂模式（Factory Pattern）

用途：定义一个创建对象的接口，让子类决定实例化哪一个类。
案例：交通工具工厂，生成 Car 和 Bicycle。

from abc import ABC, abstractmethod

class Transport(ABC):
    @abstractmethod
    def move(self):
        pass

class Car(Transport):
    def move(self):
        return "Car is moving"

class Bicycle(Transport):
    def move(self):
        return "Bicycle is moving"

class TransportFactory(ABC):
    @abstractmethod
    def create_transport(self):
        pass

class CarFactory(TransportFactory):
    def create_transport(self):
        return Car()

class BicycleFactory(TransportFactory):
    def create_transport(self):
        return Bicycle()

factory = CarFactory()
transport = factory.create_transport()
print(transport.move())

单例模式（Singleton Pattern）

用途：确保一个类只有一个实例，常用于配置管理、数据库连接等场景。
案例：配置管理类。

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

config1 = Singleton()
config2 = Singleton()
print(config1 is config2)  # 输出 True

建造者模式（Builder Pattern）

用途：分步骤创建复杂对象，允许用户一步步设置对象的组成部分。
案例：创建一个复杂的计算机配置。

class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu
        return self

    def set_ram(self, ram):
        self.computer.ram = ram
        return self

    def build(self):
        return self.computer

builder = ComputerBuilder()
computer = builder.set_cpu("Intel").set_ram("16GB").build()
print(computer.cpu, computer.ram)

结构型模式

适配器模式（Adapter Pattern）

用途：将一个类的接口转换为客户端期望的接口，通常用于接口不兼容的类之间的协作。
案例：电源适配器，将220V转换为110V。

class EuropeanPlug:
    def connect(self):
        return "220V"

class Adapter:
    def __init__(self, european_plug):
        self.european_plug = european_plug

    def connect(self):
        return "Converting " + self.european_plug.connect() + " to 110V"

plug = EuropeanPlug()
adapter = Adapter(plug)
print(adapter.connect())  # 输出 Converting 220V to 110V

装饰器模式（Decorator Pattern）

用途：动态地给对象添加新功能，适合扩展类的功能而不修改类。
案例：给消息添加装饰。

class Message:
    def __init__(self, content):
        self.content = content

    def get_content(self):
        return self.content

class BoldDecorator:
    def __init__(self, message):
        self.message = message

    def get_content(self):
        return "<b>" + self.message.get_content() + "</b>"

message = Message("Hello")
bold_message = BoldDecorator(message)
print(bold_message.get_content())  # 输出 <b>Hello</b>

代理模式（Proxy Pattern）

用途：提供一个类的代理，以控制对原对象的访问，可以延迟加载、访问控制。
案例：保护代理，用于控制对某个类的访问权限。

class RealObject:
    def request(self):
        return "Data from real object"

class Proxy:
    def __init__(self):
        self.real_object = RealObject()

    def request(self):
        # 可以加访问控制
        return self.real_object.request()

proxy = Proxy()
print(proxy.request())

行为型模式

观察者模式（Observer Pattern）

用途：定义对象间的一对多依赖关系，当一个对象改变时，其所有依赖者都会收到通知。
案例：订阅-发布系统。

class Publisher:
    def __init__(self):
        self.subscribers = []

    def subscribe(self, subscriber):
        self.subscribers.append(subscriber)

    def notify(self, message):
        for subscriber in self.subscribers:
            subscriber.update(message)

class Subscriber:
    def update(self, message):
        print(f"Received: {message}")

publisher = Publisher()
subscriber1 = Subscriber()
publisher.subscribe(subscriber1)
publisher.notify("New event!")

策略模式（Strategy Pattern）

用途：定义一系列算法，将它们封装，使得它们可以相互替换。
案例：支付方式选择。

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        return f"Paid {amount} using Credit Card."

class PaypalPayment(PaymentStrategy):
    def pay(self, amount):
        return f"Paid {amount} using Paypal."

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_payment(self, amount):
        return self.strategy.pay(amount)

payment = Context(PaypalPayment())
print(payment.execute_payment(100))

状态模式（State Pattern）

用途：允许对象在内部状态改变时改变其行为，使得对象看起来是更改了它的类。
案例：订单状态管理。

class OrderState(ABC):
    @abstractmethod
    def next(self):
        pass

class Ordered(OrderState):
    def next(self):
        return Shipped()

class Shipped(OrderState):
    def next(self):
        return Delivered()

class Delivered(OrderState):
    def next(self):
        return None  # 已完成

state = Ordered()
state = state.next()  # 转换为 Shipped
state = state.next()  # 转换为 Delivered
print(type(state).__name__)  # 输出 Delivered

以上是常见的设计模式和 Python 案例示例，理解这些模式并根据需求选择适合的模式，可以帮助我们设计出更易维护和扩展的代码。

土豆不吃鱼

常用的几种设计模式

创建型模式

结构型模式

行为型模式

最近开始裁员