设计模式-策略模式

策略模式（Strategy Pattern）

策略模式（Strategy Pattern）是一种行为型设计模式，它允许在运行时选择算法的实现。策略模式将每一个算法封装成一个独立的类，并让它们可以互换。通过策略模式，客户端可以在不同的策略之间进行切换，而无需修改算法本身。

策略模式的结构

1. Context（上下文）：持有一个 Strategy 对象，并且可以在运行时切换策略。上下文通过 Strategy 接口来与不同的具体策略进行交互。
2. Strategy（策略接口）：定义了一个公共接口，所有具体策略类都需要实现这个接口，从而确保上下文可以在不依赖于具体实现的情况下，调用 Strategy 提供的功能。
3. ConcreteStrategy（具体策略）：实现 Strategy 接口的具体类，每个具体策略都封装了一个特定的算法。

策略模式的优点：

• 算法的独立性：不同的算法被封装在不同的策略类中，算法的变化不会影响到使用这些算法的客户。
• 易于扩展：新的策略可以被轻松地添加，而无需修改现有的代码（符合开放/封闭原则）。
• 避免条件判断语句：通过多态替代了复杂的条件判断语句，使代码更简洁。

策略模式的缺点：

• 类的数量增多：每增加一种新的策略，就需要创建一个新的策略类，导致类的数量增多。
• 客户端必须了解不同的策略：客户端需要知道不同的策略，并且能够选择合适的策略。

策略模式的UML图

     +---------------------+
     |       Context       |
     +---------------------+
     | - strategy: Strategy |
     +---------------------+
     | + setStrategy(s: Strategy) |
     | + executeStrategy()        |
     +---------------------+
                ^
                |
                |
  +--------------------------+
  |      Strategy (Interface) |
  +--------------------------+
  | + algorithm()            |
  +--------------------------+
      ^            ^            ^
      |            |            |
+------------------+  +------------------+  +------------------+
| ConcreteStrategyA |  | ConcreteStrategyB |  | ConcreteStrategyC |
+------------------+  +------------------+  +------------------+
| + algorithm()    |  | + algorithm()    |  | + algorithm()    |
+------------------+  +------------------+  +------------------+

策略模式的Python实现

假设我们有一个简单的支付系统，可以选择不同的支付策略，比如信用卡支付、微信支付和支付宝支付。我们可以通过策略模式来实现这一功能：

from abc import ABC, abstractmethod

# 策略接口
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount: float):
        pass

# 具体策略A：信用卡支付
class CreditCardPayment(PaymentStrategy):
    def pay(self, amount: float):
        return f"Paid {amount} using Credit Card."

# 具体策略B：微信支付
class WeChatPayment(PaymentStrategy):
    def pay(self, amount: float):
        return f"Paid {amount} using WeChat."

# 具体策略C：支付宝支付
class AlipayPayment(PaymentStrategy):
    def pay(self, amount: float):
        return f"Paid {amount} using Alipay."

# 上下文
class PaymentContext:
    def __init__(self, strategy: PaymentStrategy):
        self._strategy = strategy
    
    # 可以在运行时设置不同的策略
    def set_strategy(self, strategy: PaymentStrategy):
        self._strategy = strategy
    
    def execute_payment(self, amount: float):
        return self._strategy.pay(amount)

# 客户端代码
if __name__ == "__main__":
    # 创建上下文并选择支付策略
    context = PaymentContext(CreditCardPayment())
    
    # 进行支付
    print(context.execute_payment(100.0))  # 输出：Paid 100.0 using Credit Card.
    
    # 更改支付策略为微信支付
    context.set_strategy(WeChatPayment())
    print(context.execute_payment(200.0))  # 输出：Paid 200.0 using WeChat.
    
    # 更改支付策略为支付宝支付
    context.set_strategy(AlipayPayment())
    print(context.execute_payment(300.0))  # 输出：Paid 300.0 using Alipay.

解释：

1. PaymentStrategy（支付策略接口）：定义了一个统一的 pay() 方法，所有具体的支付方式都需要实现这个方法。
2. CreditCardPayment、WeChatPayment、AlipayPayment（具体支付策略类）：每个类实现了 PaymentStrategy 接口，封装了各自的支付方式逻辑。
3. PaymentContext（上下文）：上下文持有一个 PaymentStrategy 对象，可以在运行时动态改变策略，执行相应的支付操作。

运行结果：

Paid 100.0 using Credit Card.
Paid 200.0 using WeChat.
Paid 300.0 using Alipay.

总结：

• 策略模式是通过将算法封装成独立的策略类，使得客户端可以在运行时选择具体的策略，并且能够在不修改客户端代码的情况下扩展新的策略。
• 这种模式的应用非常广泛，尤其是在需要频繁改变行为或算法的场景中，策略模式使得代码更加清晰、可维护和易于扩展。
• 策略模式解决了在不同场景下使用不同算法的需求，减少了条件判断，使得代码更加符合开放/封闭原则。