策略模式-StrategyPattern-使用案例

The Strategy pattern is a behavioral design pattern that allows you to define a family of algorithms, encapsulate each one as a separate class, and make them interchangeable. It enables clients to choose from different algorithms at runtime without tightly coupling the client code to specific implementations.

In real development scenarios, the Strategy pattern is commonly used when you have multiple algorithms or variations of an algorithm that can be used interchangeably. It helps in promoting code reusability, maintainability, and flexibility by encapsulating the algorithms and allowing them to be easily swapped without modifying the client code.

Here's a detailed use case of the Strategy pattern in Java, where we'll implement a sorting algorithm that can be dynamically chosen at runtime.

// Step 1: Define the strategy interface
interface SortingStrategy {
    void sort(int[] array);
}

// Step 2: Implement concrete strategy classes
class BubbleSortStrategy implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        // Implementation of bubble sort algorithm
        // ...
        System.out.println("Bubble sort strategy applied.");
    }
}

class MergeSortStrategy implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        // Implementation of merge sort algorithm
        // ...
        System.out.println("Merge sort strategy applied.");
    }
}

// Step 3: Create a context class that uses the strategy
class SortingContext {
    private SortingStrategy sortingStrategy;

    public void setSortingStrategy(SortingStrategy sortingStrategy) {
        this.sortingStrategy = sortingStrategy;
    }

    public void sortArray(int[] array) {
        sortingStrategy.sort(array);
    }
}

// Step 4: Demonstrate the usage of the strategy pattern
public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 7, 1, 3};

        SortingContext context = new SortingContext();

        // Use bubble sort strategy
        context.setSortingStrategy(new BubbleSortStrategy());
        context.sortArray(array);

        // Use merge sort strategy
        context.setSortingStrategy(new MergeSortStrategy());
        context.sortArray(array);
    }
}

In this example, we have a SortingStrategy interface that defines the contract for sorting algorithms. We then create two concrete strategy classes, BubbleSortStrategy and MergeSortStrategy, that implement the sorting algorithm using their respective strategies.

The SortingContext class acts as a context and is responsible for sorting the array using the chosen strategy. It has a method setSortingStrategy() to set the strategy dynamically, and sortArray() method that delegates the sorting task to the current strategy.

In the Main class, we demonstrate the usage of the strategy pattern. We create an instance of SortingContext and set the sorting strategy to BubbleSortStrategy, and then invoke the sortArray() method. Similarly, we change the sorting strategy to MergeSortStrategy and invoke the sortArray() method again.

By using the Strategy pattern, we can easily switch between different sorting algorithms without modifying the client code. This allows for flexibility and extensibility in our application, as we can add new strategies or modify existing ones without impacting the existing codebase.

source：https://chat.openai.com