金三银四面试题（二十五）：策略模式知多少？

什么是策略模式

策略模式（Strategy Pattern）是一种行为型设计模式，旨在定义一系列算法，将每个算法封装到一个独立的类中，使它们可以互换。策略模式让算法的变化独立于使用它们的客户端，使得客户端可以根据需要动态地选择不同的策略。

策略模式的特点

策略的定义：在策略模式中，算法被定义为一组策略，每个策略都封装在一个独立的类中。策略类通常实现一个公共接口，以便客户端可以根据需要使用不同的策略。
客户端使用策略：客户端通过组合策略对象来使用特定的策略。客户端不需要知道具体策略的实现细节，只需要知道如何使用策略接口。
动态切换策略：策略模式允许客户端在运行时动态切换策略。这使得客户端可以根据不同的场景或条件选择不同的策略。
封装：策略模式将算法封装在独立的类中，这样算法的变化不会影响客户端的代码。客户端只需要依赖策略接口，而不是具体的策略实现。

应用场景

需要定义一组算法，并且这些算法之间可以互换。
客户端需要根据不同的条件动态选择不同的策略。
希望将算法的变化独立于使用它们的客户端代码。

优点

开放封闭原则：可以根据需要添加新的策略，而无需修改现有代码。
代码复用：多个客户端可以共享相同的策略。
灵活性：客户端可以在运行时动态切换策略。

缺点

策略类数量增加：每个策略都需要独立的类，这可能导致类的数量增加。
客户端需要了解所有策略：客户端需要知道所有可用的策略，以便选择合适的策略。

举个例子

下面是一个示例程序，展示了策略模式在排序算法中的应用。程序中定义了一个排序策略接口，并实现了两种排序策略：冒泡排序和快速排序。客户端可以根据需要动态选择不同的排序策略。

// 排序策略接口
interface SortStrategy {
    void sort(int[] array);
}

// 冒泡排序策略
class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Sorting using Bubble Sort");
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

// 快速排序策略
class QuickSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Sorting using Quick Sort");
        quickSort(array, 0, array.length - 1);
    }

    private void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pi = partition(array, low, high);
            quickSort(array, low, pi - 1);
            quickSort(array, pi + 1, high);
        }
    }

    private int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) {
                i++;
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }
}

// 上下文类，负责使用排序策略
class SortContext {
    private SortStrategy strategy;

    // 设置排序策略
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    // 使用当前的排序策略对数组进行排序
    public void sortArray(int[] array) {
        strategy.sort(array);
    }
}

// 客户端代码
public class StrategyPatternDemo {
    public static void main(String[] args) {
        // 创建排序上下文
        SortContext context = new SortContext();

        // 设置冒泡排序策略
        context.setStrategy(new BubbleSortStrategy());
        int[] array1 = {5, 2, 9, 1, 5, 6};
        context.sortArray(array1);
        System.out.println("Sorted array using Bubble Sort: " + java.util.Arrays.toString(array1));

        // 设置快速排序策略
        context.setStrategy(new QuickSortStrategy());
        int[] array2 = {5, 2, 9, 1, 5, 6};
        context.sortArray(array2);
        System.out.println("Sorted array using Quick Sort: " + java.util.Arrays.toString(array2));
    }
}

在这个示例中，SortStrategy 是排序策略的接口，定义了一个 sort 方法。BubbleSortStrategy 和 QuickSortStrategy 是两个具体的排序策略类，实现了 SortStrategy 接口。客户端通过创建 SortContext 对象并设置排序策略，来对数组进行排序。在运行时，客户端可以根据需要动态选择不同的排序策略。