什么是策略模式
策略模式（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 对象并设置排序策略，来对数组进行排序。在运行时，客户端可以根据需要动态选择不同的排序策略。
总结
策略模式通过定义一系列策略，将每个策略封装成独立的类，使得客户端可以根据需求动态切换不同的策略，提高代码的灵活性和可维护性。
