返回

如何驾驭策略模式：点燃你的设计模式之旅！

后端

策略模式属于行为型设计模式之一，它旨在将算法或行为从一个类中提取出来，使其成为一个独立的策略对象。通过这种方式，我们能够在不改变既有代码的情况下，轻松更换或修改算法或行为，从而实现代码的灵活性、扩展性和复用性。

策略模式的应用场景十分广泛，比如：

  • 当你想要提供多种算法或行为供用户选择时，比如排序算法、搜索算法等。
  • 当你想要将算法或行为从一个类中分离出来，以便独立修改或重用时。
  • 当你想要动态地改变算法或行为，而无需修改既有代码时。

策略模式的实现主要涉及两个角色：

  • 策略（Strategy） ：定义了一系列算法或行为，每个策略对象都实现了相同的接口，但具有不同的实现。
  • 上下文（Context） ：包含一个策略对象，并通过该对象来执行算法或行为。

在策略模式中，策略对象和上下文对象是松耦合的，这意味着我们可以轻松地更换或修改策略对象，而无需修改上下文对象。这种灵活性使得策略模式成为应对变化的绝佳选择。

为了更好地理解策略模式，让我们举一个简单的例子：

假设我们有一个排序算法的程序，该程序需要支持多种排序算法，如冒泡排序、快速排序和归并排序。使用策略模式，我们可以将每种排序算法实现为一个独立的策略对象，然后在程序中动态地选择所需的排序算法。

class SortStrategy:
    def sort(self, data):
        """
        对数据进行排序的抽象方法
        """
        pass

class BubbleSortStrategy(SortStrategy):
    def sort(self, data):
        """
        使用冒泡排序对数据进行排序
        """
        for i in range(len(data)):
            for j in range(i + 1, len(data)):
                if data[i] > data[j]:
                    data[i], data[j] = data[j], data[i]

class QuickSortStrategy(SortStrategy):
    def sort(self, data):
        """
        使用快速排序对数据进行排序
        """
        def partition(data, low, high):
            pivot = data[high]
            i = low - 1
            for j in range(low, high):
                if data[j] <= pivot:
                    i += 1
                    data[i], data[j] = data[j], data[i]
            data[i + 1], data[high] = data[high], data[i + 1]
            return i + 1

        def quick_sort(data, low, high):
            if low < high:
                partition_index = partition(data, low, high)
                quick_sort(data, low, partition_index - 1)
                quick_sort(data, partition_index + 1, high)

        quick_sort(data, 0, len(data) - 1)

class MergeSortStrategy(SortStrategy):
    def sort(self, data):
        """
        使用归并排序对数据进行排序
        """
        def merge(left, right):
            merged = []
            left_index = 0
            right_index = 0

            while left_index < len(left) and right_index < len(right):
                if left[left_index] <= right[right_index]:
                    merged.append(left[left_index])
                    left_index += 1
                else:
                    merged.append(right[right_index])
                    right_index += 1

            merged.extend(left[left_index:])
            merged.extend(right[right_index:])

            return merged

        def merge_sort(data):
            if len(data) <= 1:
                return data

            mid = len(data) // 2
            left = merge_sort(data[:mid])
            right = merge_sort(data[mid:])

            return merge(left, right)

        return merge_sort(data)

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

    def sort(self, data):
        """
        使用策略对象对数据进行排序
        """
        self._strategy.sort(data)

# 使用不同的策略对数据进行排序
data = [5, 3, 1, 2, 4]

# 使用冒泡排序策略
bubble_sort_context = SortContext(BubbleSortStrategy())
bubble_sort_context.sort(data)
print("冒泡排序结果：", data)

# 使用快速排序策略
quick_sort_context = SortContext(QuickSortStrategy())
quick_sort_context.sort(data)
print("快速排序结果：", data)

# 使用归并排序策略
merge_sort_context = SortContext(MergeSortStrategy())
merge_sort_context.sort(data)
print("归并排序结果：", data)

在上面的代码中，我们首先定义了一个SortStrategy抽象类，该类包含了一个抽象方法sort，用于对数据进行排序。然后，我们定义了三个具体的策略类BubbleSortStrategy、QuickSortStrategy和MergeSortStrategy，分别实现了冒泡排序、快速排序和归并排序算法。

接下来，我们定义了一个SortContext类，该类包含一个strategy属性，用于存储策略对象。SortContext类还提供了一个sort方法，该方法通过策略对象对数据进行排序。

最后，我们在代码中实例化了不同的策略对象和上下文对象，并使用这些对象对数据进行排序。输出结果如下：

冒泡排序结果： [1, 2, 3, 4, 5]
快速排序结果： [1, 2, 3, 4, 5]
归并排序结果： [1, 2, 3, 4, 5]

从输出结果可以看出，策略模式可以轻松地实现算法或行为的切换，而无需修改既有代码。这种灵活性使得策略模式成为应对变化的绝佳选择。