设计模式【行为型】-- 策略模式

策略模式（Strategy Pattern）

策略模式是一种行为型设计模式，它定义了一系列的算法，并使得这些算法可以互相替换。通过将算法封装成独立的策略类，客户端可以根据需要选择不同的策略来完成特定的任务。

概念：

策略模式由三个主要组件组成：上下文（Context）、策略接口（Strategy）和具体策略类（Concrete Strategies）。上下文是客户端与策略类之间的中介，它持有一个策略接口的引用，用于执行具体的策略。策略接口定义了策略类的行为，具体策略类实现了策略接口，提供了具体的算法实现。

优点：

1. 策略模式实现了算法的解耦，使得算法可以独立于客户端使用，并且可以灵活地替换算法，提高了代码的可维护性和可扩展性。
2. 策略模式遵循开闭原则，允许新增策略类而无需修改上下文类的代码，符合面向对象设计的原则。
3. 策略模式将算法的选择逻辑从客户端代码中抽离出来，使得客户端更加简洁和清晰。

缺点：

1. 如果策略类过多或策略类的代码较复杂，可能会导致类的个数增加和代码的复杂性增加。
2. 客户端需要了解所有的策略类，以便在运行时选择合适的策略，增加了客户端的复杂性。

适用场景：

1. 当一个系统需要在多个算法中选择一种，并且这些算法之间的差异较大时，可以使用策略模式。
2. 当一个类需要根据不同的条件执行不同的行为时，可以使用策略模式。
3. 当需要避免使用大量的条件语句来选择不同行为时，策略模式提供了一种更加清晰和可扩展的方式。

案例一、

下面是一个结合策略模式的Java示例：

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

// 具体策略类A
class BubbleSortStrategy implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用冒泡排序算法对数组进行排序");
        // 具体的冒泡排序实现
    }
}

// 具体策略类B
class QuickSortStrategy implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用快速排序算法对数组进行排序");
        // 具体的快速排序实现
    }
}

// 上下文类
class ArraySorter {
    private SortingStrategy sortingStrategy;

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

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

// 使用示例
public class Main {
    public static void main(String[] args) {
        ArraySorter sorter = new ArraySorter();

        SortingStrategy bubbleSort = new BubbleSortStrategy();
        sorter.setSortingStrategy(bubbleSort);
        int[] array1 = {5, 3, 1, 4, 2};
        sorter.sortArray(array1);

        SortingStrategy quickSort = new QuickSortStrategy();
        sorter.setSortingStrategy(quickSort);
        int[] array2 = {9, 7, 8, 6, 10};
        sorter.sortArray(array2);
    }
}

在上述代码中，SortingStrategy 是策略接口，定义了一个 sort() 方法。BubbleSortStrategy 和 QuickSortStrategy 是具体的策略类，实现了 SortingStrategy 接口，并提供了具体的排序算法实现。

ArraySorter 是上下文类，持有一个 SortingStrategy 的引用，并在 sortArray() 方法中调用策略对象的 sort() 方法来执行具体的排序算法。

在 Main 类的示例中，我们首先创建一个 ArraySorter 对象，然后分别创建了 BubbleSortStrategy 和 QuickSortStrategy 对象，并通过调用 setSortingStrategy() 方法将不同的策略对象设置给 ArraySorter。最后，我们调用 sortArray() 方法，传入不同的数组进行排序，可以看到不同的策略被应用于排序过程。

策略模式适用于需要在多个算法中选择一种的情况，以及需要根据不同的条件执行不同行为的情况。它可以将算法的选择逻辑从客户端代码中解耦出来，使得客户端更加简洁和清晰，并提供了一种可扩展的方式。

案例二、

下面是一个使用策略模式实现支付功能的Java示例，包括普通支付、微信支付、支付宝支付和银联支付的具体策略类：

// 策略接口
interface PaymentStrategy {
    void pay(double amount);
}

// 具体策略类：普通支付
class RegularPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用普通支付方式，支付金额：" + amount);
        // 实现普通支付逻辑
    }
}

// 具体策略类：微信支付
class WeChatPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付方式，支付金额：" + amount);
        // 实现微信支付逻辑
    }
}

// 具体策略类：支付宝支付
class AliPayPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付方式，支付金额：" + amount);
        // 实现支付宝支付逻辑
    }
}

// 具体策略类：银联支付
class UnionPayPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用银联支付方式，支付金额：" + amount);
        // 实现银联支付逻辑
    }
}

// 上下文类
class PaymentContext {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void executePayment(double amount) {
        paymentStrategy.pay(amount);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext();

        PaymentStrategy regularPayment = new RegularPaymentStrategy();
        context.setPaymentStrategy(regularPayment);
        context.executePayment(100.0);

        PaymentStrategy weChatPayment = new WeChatPaymentStrategy();
        context.setPaymentStrategy(weChatPayment);
        context.executePayment(200.0);

        PaymentStrategy aliPayPayment = new AliPayPaymentStrategy();
        context.setPaymentStrategy(aliPayPayment);
        context.executePayment(300.0);

        PaymentStrategy unionPayPayment = new UnionPayPaymentStrategy();
        context.setPaymentStrategy(unionPayPayment);
        context.executePayment(400.0);
    }
}

在上述代码中，PaymentStrategy 是策略接口，定义了一个 pay() 方法。RegularPaymentStrategy、WeChatPaymentStrategy、AliPayPaymentStrategy 和 UnionPayPaymentStrategy 是具体的策略类，分别实现了 PaymentStrategy 接口，并提供了不同的支付逻辑。

PaymentContext 是上下文类，持有一个 PaymentStrategy 的引用，并在 executePayment() 方法中调用策略对象的 pay() 方法来执行具体的支付逻辑。

在 Main 类的示例中，我们首先创建一个 PaymentContext 对象，然后分别创建了普通支付、微信支付、支付宝支付和银联支付的策略对象，并通过调用 setPaymentStrategy() 方法将不同的策略对象设置给 PaymentContext。最后，我们调用 executePayment() 方法，传入不同的支付金额进行支付，可以看到不同的支付策略被应用于支付过程。

通过使用策略模式，我们实现了支付功能的灵活扩展，可以根据需要选择不同的支付方式。策略模式将支付算法封装到具体的策略类中，使得客户端代码更加简洁、可维护，并且具有较好的扩展性。