设计模式是软件开发中常见的、可复用的解决方案，能够提高代码的可维护性、可读性和可扩展性。设计模式主要分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns） 和 行为型模式（Behavioral Patterns）。

目录：

  1. 创建型模式
    • 工厂方法模式（Factory Method）
    • 抽象工厂模式（Abstract Factory）
    • 单例模式（Singleton）
    • 建造者模式（Builder）
    • 原型模式（Prototype）
  2. 结构型模式
    • 适配器模式（Adapter）
    • 桥接模式（Bridge）
    • 组合模式（Composite）
    • 装饰器模式（Decorator）
    • 外观模式（Facade）
    • 享元模式（Flyweight）
    • 代理模式（Proxy）
  3. 行为型模式
    • 责任链模式（Chain of Responsibility）
    • 命令模式（Command）
    • 解释器模式（Interpreter）
    • 迭代器模式（Iterator）
    • 中介者模式（Mediator）
    • 备忘录模式（Memento）
    • 观察者模式（Observer）
    • 状态模式（State）
    • 策略模式（Strategy）
    • 模板方法模式（Template Method）
    • 访问者模式（Visitor）
  4. 出站链接
  5. 站内链接
  6. 参考资料

1. 创建型模式（Creational Patterns）

创建型模式用于管理和封装对象的创建，避免直接实例化对象，提高代码的灵活性和可扩展性。

1.1 工厂方法模式（Factory Method）

定义：定义一个创建对象的接口，由子类决定实例化哪一个具体类。

适用场景：

  • 需要创建对象，但具体类在编译时不确定。
  • 代码需要遵循开闭原则（OCP），避免直接依赖具体类。

示例（Python）：

from abc import ABC, abstractmethod

class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteProductA(Product):
    def operation(self):
        return "ConcreteProductA"

class ConcreteProductB(Product):
    def operation(self):
        return "ConcreteProductB"

class Factory(ABC):
    @abstractmethod
    def create_product(self):
        pass

class ConcreteFactoryA(Factory):
    def create_product(self):
        return ConcreteProductA()

class ConcreteFactoryB(Factory):
    def create_product(self):
        return ConcreteProductB()

# 客户端代码
factory = ConcreteFactoryA()
product = factory.create_product()
print(product.operation())  # Output: ConcreteProductA

1.2 抽象工厂模式（Abstract Factory）

定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定其具体类。

示例（Python）：

class AbstractFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_checkbox(self):
        pass

class WindowsFactory(AbstractFactory):
    def create_button(self):
        return WindowsButton()

    def create_checkbox(self):
        return WindowsCheckbox()

class MacFactory(AbstractFactory):
    def create_button(self):
        return MacButton()

    def create_checkbox(self):
        return MacCheckbox()

# 客户端
factory = WindowsFactory()
button = factory.create_button()
print(button.render())  # 假设 WindowsButton 有 render 方法

1.3 单例模式（Singleton）

定义：确保某个类只有一个实例，并提供一个全局访问点。

示例（Python，基于 __new__ 方法）：

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)  # Output: True

2. 结构型模式（Structural Patterns）

结构型模式用于组织类和对象，确保代码结构的灵活性和可扩展性。

2.1 适配器模式（Adapter）

定义：将一个接口转换成客户端希望的另一个接口，使得原本不兼容的类可以协同工作。

示例（Python）：

class Target:
    def request(self):
        return "Target behavior"

class Adaptee:
    def specific_request(self):
        return "Adaptee behavior"

class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        return self.adaptee.specific_request()

adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())  # Output: Adaptee behavior

3. 行为型模式（Behavioral Patterns）

行为型模式关注对象间的通信与职责分配，提高系统的灵活性。

3.1 观察者模式（Observer）

定义：定义对象间的一对多依赖关系，使得当一个对象的状态改变时，所有依赖者都会收到通知。

示例（Python）：

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

class ConcreteObserver:
    def update(self, subject):
        print("Observer updated with", subject)

subject = Subject()
observer1 = ConcreteObserver()
subject.attach(observer1)
subject.notify()  # Output: Observer updated with <__main__.Subject object at ...>

4. 出站链接

5. 站内链接

6. 参考资料

  • Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
  • Martin, R. C. (2009). Clean Code: A Handbook of Agile Software Craftsmanship. Prentice Hall.

这份文档详细介绍了设计模式的概念，并列举了常见的模式及其 Python 实现示例。如果你需要更详细的内容，欢迎进一步讨论！