设计模式——策略模式

策略模式简介

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以互换。策略模式使得算法可以独立于使用它的客户端而变化。

策略模式的关键思想是将行为从环境类中分离出来，使得它们能够独立变化。客户端可以在运行时选择不同的策略，而无需修改客户端的代码。

策略模式的组成部分

1. 策略接口（Strategy）：定义一个公共接口，各种具体策略类都实现这个接口。
2. 具体策略（Concrete Strategy）：实现策略接口的不同算法。
3. 上下文（Context）：持有一个策略对象的引用，客户端通过上下文调用策略接口的方法来执行具体策略。

策略模式的结构

class Strategy:
    def execute(self, data):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self, data):
        print("Executing strategy A")

class ConcreteStrategyB(Strategy):
    def execute(self, data):
        print("Executing strategy B")

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

    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy

    def execute_strategy(self, data):
        self._strategy.execute(data)

# 使用策略模式
context = Context(ConcreteStrategyA())
context.execute_strategy(data)

context.set_strategy(ConcreteStrategyB())
context.execute_strategy(data)

策略模式的应用场景

1. 需要在多种算法中进行选择时：

   • 当一个类定义了多种行为，并且这些行为在类的操作中以多种方式出现时，可以使用策略模式将这些行为封装在不同的策略类中，以实现算法的互换。

2. 避免使用条件语句（if-else 或 switch-case）：

   • 当多个类只有在行为上稍有不同的时候，可以使用策略模式来减少条件语句的使用，从而提高代码的可维护性和扩展性。

3. 行为在运行时需要改变：

   • 当需要在运行时根据具体情况选择不同的算法或行为时，可以使用策略模式来动态地改变对象的行为。

使用策略模式解决的问题举例

1. 排序算法的选择

假设你有一个数据处理系统，需要根据不同的数据量选择不同的排序算法，例如在数据量小的时候使用插入排序，在数据量大的时候使用快速排序。

class SortStrategy:
    def sort(self, data):
        pass

class InsertionSort(SortStrategy):
    def sort(self, data):
        print("Using Insertion Sort")
        # 插入排序算法实现
        return sorted(data)

class QuickSort(SortStrategy):
    def sort(self, data):
        print("Using Quick Sort")
        # 快速排序算法实现
        return sorted(data)

class SortContext:
    def __init__(self, strategy: SortStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: SortStrategy):
        self._strategy = strategy

    def sort_data(self, data):
        return self._strategy.sort(data)

data = [5, 3, 8, 6, 2]

context = SortContext(InsertionSort())
sorted_data = context.sort_data(data)

context.set_strategy(QuickSort())
sorted_data = context.sort_data(data)

2. 数据压缩算法

在文件压缩工具中，可以选择不同的压缩算法，比如 ZIP、RAR、TAR 等。使用策略模式，可以让用户根据需要选择不同的压缩算法。

class CompressionStrategy:
    def compress(self, files):
        pass

class ZipCompression(CompressionStrategy):
    def compress(self, files):
        print("Compressing using ZIP")
        # ZIP压缩算法实现

class RarCompression(CompressionStrategy):
    def compress(self, files):
        print("Compressing using RAR")
        # RAR压缩算法实现

class CompressionContext:
    def __init__(self, strategy: CompressionStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: CompressionStrategy):
        self._strategy = strategy

    def compress_files(self, files):
        self._strategy.compress(files)

files = ["file1.txt", "file2.txt"]

context = CompressionContext(ZipCompression())
context.compress_files(files)

context.set_strategy(RarCompression())
context.compress_files(files)

3. 支付方式

在电子商务系统中，用户可以选择不同的支付方式，比如信用卡支付、PayPal支付、比特币支付等。使用策略模式，可以灵活地添加和切换不同的支付方式。

class PaymentStrategy:
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paying {amount} using Credit Card")

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paying {amount} using PayPal")

class BitcoinPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paying {amount} using Bitcoin")

class PaymentContext:
    def __init__(self, strategy: PaymentStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: PaymentStrategy):
        self._strategy = strategy

    def pay_amount(self, amount):
        self._strategy.pay(amount)

context = PaymentContext(CreditCardPayment())
context.pay_amount(100)

context.set_strategy(PayPalPayment())
context.pay_amount(200)

context.set_strategy(BitcoinPayment())
context.pay_amount(300)

通过使用策略模式，这些示例展示了如何在运行时灵活地选择和切换不同的算法或行为，从而提高代码的可维护性和可扩展性。