策略模式（Strategy Pattern）

策略模式（Strategy Pattern）是一种行为型设计模式，它允许我们定义一系列算法，将每个算法封装起来，使它们之间可以互换。这种模式可以使得算法的变化独立于使用算法的客户端，从而实现了算法的动态性和灵活性。

以下是一个简单的使用策略模式的示例：

public interface SortStrategy {
    void sort(int[] arr);
}

public class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序完成");
    }
}

public class QuickSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
        System.out.println("快速排序完成");
    }
    
    private void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }
    
    private int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i =low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
}

public class Sorter {
    private SortStrategy strategy;

    public Sorter(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void sort(int[] arr) {
        strategy.sort(arr);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 1, 5};

        SortStrategy bubbleSort = new BubbleSortStrategy();
        SortStrategy quickSort = new QuickSortStrategy();

        Sorter sorter = new Sorter(bubbleSort);
        sorter.sort(arr);

        sorter.setStrategy(quickSort);
        sorter.sort(arr);
    }
}

在这个示例中，我们定义了一个`SortStrategy`接口，其中包含一个`sort()`方法，用于排序。然后我们定义了两个实现类：`BubbleSortStrategy`和`QuickSortStrategy`，分别实现了冒泡排序和快速排序算法。

接着我们定义了一个`Sorter`类，它包含一个`SortStrategy`类型的成员变量，并提供了一个`setStrategy()`方法，用于动态设置排序策略。在`Sorter`类的`sort()`方法中，我们调用`SortStrategy`对象的`sort()`方法来完成排序任务。

最后在`Main`类中，我们创建了一个`int`类型的数组，包含5个整数，然后创建了一个`Sorter`对象，初始化时使用`BubbleSortStrategy`作为排序策略。我们调用`Sorter`对象的`sort()`方法，对数组进行排序。然后我们调用`setStrategy()`方法，将排序策略改成`QuickSortStrategy`，并再次进行排序。这样一来，我们就可以动态地切换排序算法了。

需要注意的是，策略模式可以让我们将算法的实现与使用算法的客户端分离开来，从而实现了算法的动态性和灵活性。在本例中，我们使用了接口和实现类来表示不同的排序算法，然后在`Sorter`类中将它们作为成员变量，并使用策略模式来实现不同排序算法的调用。在`Main`类中，我们可以动态地切换排序算法，从而实现了算法的动态性和灵活性。

总的来说，策略模式是一种常见的设计方法，它可以帮助我们实现代码的灵活性和可扩展性，从而更好地应对变化的需求。在Java中，我们通常使用接口和实现类来定义算法的接口和具体实现，在使用这些算法的类中，我们将其作为成员变量，并使用策略模式来实现不同算法的调用。这种方法可以帮助我们实现代码的灵活性和可扩展性，从而更好地应对变化的需求。