【设计模式】单例模式、工厂模式、策略模式、观察者模式、装饰器模式

1 单例模式
2 工厂模式
3 策略模式
4 观察者模式
5 装饰器模式

1 单例模式

class Singleton:
    """
    单例模式：
    确保一个类只有一个实例，并提供一个全局访问点。
    在需要全局状态或者需要频繁创建和销毁实例会导致性能问题时非常有用。
    """
    _instance = None

    def __new__(cls, *args, **kwargs):
        """
        创建实例时调用，确保只有一个实例。
        :param args: 位置参数
        :param kwargs: 关键字参数
        :return: 唯一实例
        """
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

    def __init__(self, value=None):
        """
        初始化实例属性。
        :param value: 初始化值
        """
        # 使用一个类属性来检查实例是否已初始化
        if not hasattr(self, '_initialized'):
            self.value = value
            self._initialized = True


# 示例用法
singleton1 = Singleton(10)
singleton2 = Singleton(20)

print(singleton1.value)  # 输出: 10
print(singleton2.value)  # 输出: 10
print(singleton1 is singleton2)  # 输出: True

2 工厂模式

class AnimalFactory:
    """
    工厂模式用于创建对象，而不需要指定将要创建的具体类。
    这在需要将对象创建的代码与使用对象的代码分离时非常有用，提高了代码的灵活性和扩展性。
    工厂模式提供了一个方法来创建对象，客户端代码只需调用这个方法，而无需了解如何创建对象的详细信息。
    """
    
    @staticmethod
    def create_animal(animal_type):
        """
        根据指定的动物类型创建并返回对应的动物对象。
        :param animal_type: 要创建的动物类型（'dog' 或 'cat'）
        :return: 对应的动物对象（Dog 或 Cat）
        :raises ValueError: 如果指定的 animal_type 无效，则抛出异常
        """
        if animal_type == 'dog':
            return Dog()  # 创建并返回 Dog 类的实例
        elif animal_type == 'cat':
            return Cat()  # 创建并返回 Cat 类的实例
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")  # 如果 animal_type 无效，抛出异常

# 示例用法
dog = AnimalFactory.create_animal('dog')
print(dog)  # 输出: <__main__.Dog object at ...>

# 如果需要一个 Cat 实例
cat = AnimalFactory.create_animal('cat')
print(cat)  # 输出: <__main__.Cat object at ...>

3 策略模式

class Strategy:
    """
    策略模式定义了一系列算法，并将每一个算法封装起来，使他们可以互换。
    这在需要根据不同情况使用不同算法或行为时非常有用
    """
    def execute(self):
        """
        执行策略的方法，具体策略类需要实现此方法。
        :return: 策略的执行结果
        """
        pass

class ConcreateStrategyA(Strategy):
    """
    具体策略类A：
    实现了 Strategy 接口，定义了特定的策略行为。
    """
    def execute(self):
        """
        实现具体的策略行为。
        :return: 表示具体策略 A 的执行结果
        """
        return "ConcreateStrategyA"

class Context:
    """
    上下文类：
    维护一个 Strategy 对象的引用，并允许在运行时设置或更改策略。
    上下文类依赖于策略接口，并将策略的执行委托给具体的策略类。
    """
    def __init__(self, strategy: Strategy):
        """
        初始化上下文对象时传入一个策略对象。
        :param strategy: 一个 Strategy 类型的策略对象
        """
        self._strategy = strategy

    def set_strategy(self, strategy: Strategy):
        """
        设置或更改策略对象。
        :param strategy: 一个 Strategy 类型的策略对象
        """
        self._strategy = strategy

    def do_action(self):
        """
        执行当前策略的行为。
        :return: 策略的执行结果
        """
        return self._strategy.execute()

# 示例用法
strategy_a = ConcreateStrategyA()  # 创建具体策略 A 的实例
context = Context(strategy_a)  # 使用策略 A 初始化上下文对象
print(context.do_action())  # 输出: ConcreateStrategyA

# 可以更改策略
class ConcreateStrategyB(Strategy):
    """
    具体策略类B：
    实现了 Strategy 接口，定义了另一种策略行为。
    """
    def execute(self):
        """
        实现具体的策略行为。
        :return: 表示具体策略 B 的执行结果
        """
        return "ConcreateStrategyB"

strategy_b = ConcreateStrategyB()  # 创建具体策略 B 的实例
context.set_strategy(strategy_b)  # 将上下文的策略更改为策略 B
print(context.do_action())  # 输出: ConcreateStrategyB

4 观察者模式

class Subject:
    """
    观察者模式定义了对象之间一对多依赖关系，当一个对象状态发送改变时，
    所有依赖于他的对象都会得到通知并自动更新
    这在需要实现时间驱动的系统时非常有用
    """

    def __init__(self):
        """
        初始化主题对象，创建一个空的观察者列表。
        """
        self._observers = []  # 存储所有注册的观察者对象

    def attach(self, observer):
        """
        将一个新的观察者对象添加到观察者列表中。
        :param observer: 需要注册的观察者对象
        """
        self._observers.append(observer)

    def detach(self, observer):
        """
        从观察者列表中移除一个观察者对象。
        :param observer: 需要移除的观察者对象
        """
        self._observers.remove(observer)

    def notify(self):
        """
        通知所有观察者，调用它们的 update 方法。
        """
        for observer in self._observers:
            observer.update()  # 调用每个观察者的 update 方法


class Observer:
    """
    观察者（Observer）抽象类：
    定义了一个更新接口，具体的观察者类需要实现该接口以响应主题的通知。
    """

    def update(self):
        """
        当主题通知时，调用此方法以更新观察者的状态。
        具体观察者类需要实现此方法。
        """
        pass


class ConcreateObserverA(Observer):
    """
    具体观察者A（ConcreateObserverA）类：
    实现了 Observer 接口，并定义了具体的更新行为。
    """

    def update(self):
        """
        实现观察者的更新行为，当主题通知时调用。
        """
        print('ConcreateObserverA notified')  # 打印通知信息


# 示例用法
subject = Subject()  # 创建主题对象
observer_a = ConcreateObserverA()  # 创建具体观察者A的实例
subject.attach(observer_a)  # 将观察者A注册到主题中

# 当主题状态发生变化时，通知所有观察者
subject.notify()  # 输出: ConcreateObserverA notified

5 装饰器模式

class Component:
    """
    装饰器模式允许所有用户在不修改对象的情况下，向对象添加新的龚
    这在需要动态地给对象添加功能时非常有用
    
    组件抽象类（Component）：
    定义一个接口，用于所有具体组件和装饰器类。
    装饰器模式允许在不修改对象本身的情况下，动态地为对象添加新的功能。
    这在需要扩展对象的功能且不希望影响其他对象时非常有用。
    """

    def do_something(self):
        """
        执行某种操作的方法。具体组件和装饰器类都需要实现这个方法。
        """
        pass


class ConcreteComponent(Component):
    """
    具体组件类（ConcreteComponent）：
    实现了 Component 接口，定义了具体的行为。
    装饰器将为这个类动态地添加额外的功能。
    """

    def do_something(self):
        """
        实现具体的操作。在装饰器模式中，装饰器将在此操作的基础上添加额外的功能。
        """
        print("ConcreteComponent's behavior")


class DecoratorA(Component):
    """
    具体装饰器类A（DecoratorA）：
    继承自 Component 并包含一个 Component 对象的引用。
    通过组合的方式，将额外的功能添加到该组件中。
    """

    def __init__(self, component: Component):
        """
        初始化装饰器，并将一个 Component 对象传入。
        :param component: 被装饰的组件对象
        """
        self._component = component  # 持有被装饰组件的引用

    def do_something(self):
        """
        执行被装饰组件的原有操作，并添加额外的行为。
        """
        self._component.do_something()  # 调用被装饰组件的原有操作
        self.additional_behavior()  # 添加装饰器A的额外行为

    def additional_behavior(self):
        """
        定义装饰器A的额外行为。
        此方法在装饰器的 do_something 方法中调用，作为对原有操作的扩展。
        """
        print('Additional behavior of DecoratorA')


# 示例用法
component = ConcreteComponent()  # 创建具体组件实例
decorator = DecoratorA(component)  # 使用 DecoratorA 装饰组件
decorator.do_something()  # 输出: ConcreteComponent's behavior
#       Additional behavior of DecoratorA