掌握策略模式，让抽象类模块发挥最大效能

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

策略模式的基本结构

策略模式主要包含以下四个角色：

Context（环境类）：维护一个策略对象的引用，负责策略的设置和获取。
Strategy（策略接口）：定义所有支持的算法的公共接口。
ConcreteStrategy（具体策略类）：实现策略接口，定义所有支持的算法。
Client（客户端）：通常是一个使用某种策略的客户，它根据需要设置上下文对象使用的策略。

策略模式的实现步骤

定义策略接口：定义一个策略接口，声明所有支持的算法的公共方法。
实现具体策略类：根据实际需求实现具体的策略类，每个具体策略类实现策略接口的方法。
创建环境类：创建一个环境类，包含一个策略对象的引用，并提供设置和获取策略的方法。
客户端使用策略：客户端根据需要选择合适的策略，并将其设置到环境类中。

示例：使用策略模式实现排序算法

以下是一个使用策略模式实现几种排序算法的示例：

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

// 具体策略类：冒泡排序
class BubbleSortStrategy implements SortStrategy {
    public void sort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

// 具体策略类：快速排序
class QuickSortStrategy implements SortStrategy {
    public void sort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }

    private void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(array, low, high);
            quickSort(array, low, pivotIndex - 1);
            quickSort(array, pivotIndex + 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 sort(int[] array) {
        if (strategy != null) {
            strategy.sort(array);
        }
    }
}

// 客户端
public class StrategyPatternDemo {
    public static void main(String[] args) {
        SortContext context = new SortContext();
        int[] array = {5, 2, 9, 1, 5, 6};

        // 使用冒泡排序
        context.setStrategy(new BubbleSortStrategy());
        context.sort(array);
        System.out.println("After Bubble Sort: ");
        printArray(array);

        // 使用快速排序
        context.setStrategy(new QuickSortStrategy());
        context.sort(array);
        System.out.println("After Quick Sort: ");
        printArray(array);
    }

    private static void printArray(int[] array) {
        for (int value : array) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

策略模式的优势

提高模块复用性：通过将算法封装在策略类中，可以提高模块的复用性。
提高模块可维护性：当需要修改算法时，只需要修改具体的策略类，而无需修改使用算法的客户代码。
提高模块可扩展性：可以通过添加新的策略类来扩展系统的功能，而不需要修改现有的代码。

总结

掌握策略模式可以帮助我们更好地组织代码，提高代码的复用性、可维护性和可扩展性。通过将算法封装在策略类中，我们可以轻松地切换和扩展算法，从而提高代码的灵活性和可维护性。