实际开发中常用的设计模式--------策略模式（知识跟业务场景结合）-----小白也能看懂（通俗易懂版本）

本文链接：https://blog.csdn.net/qq_51711443/article/details/131553366

1.策略模式定义：
策略模式是一种行为型设计模式，它允许在运行时动态地改变对象的行为。策略模式将将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换从而使得算法的变化不会影响到客户端
2.简单的策略模式示例代码：

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

public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 冒泡排序算法实现
    }
}

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 快速排序算法实现
    }
}

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[] data) {
        strategy.sort(data);
    }
}

在上述代码中，SortStrategy 表示一个排序策略接口，其中定义了一个 sort() 方法用于对数据进行排序。BubbleSort 和 QuickSort 则表示具体的排序策略类，分别实现了 sort() 方法来进行冒泡排序和快速排序。

而 Sorter 则表示一个排序器类，其中包含一个名为 strategy 的成员变量来存储当前使用的排序策略。通过使用构造函数或者 setter 方法来设置当前使用的排序策略，并且通过调用 sort() 方法来对数据进行排序。

例如，在客户端中可以按照如下方式使用该策略模式：

int[] data = { 5, 2, 4, 6, 1, 3 };
Sorter sorter = new Sorter(new BubbleSort());
sorter.sort(data); // 使用冒泡排序

sorter.setStrategy(new QuickSort());
sorter.sort(data); // 使用快速排序

在上述代码中，我们首先创建了一个数组 data 并且初始化其值。然后创建了一个 Sorter 对象并且使用冒泡排序作为初始的排序策略。最后调用 sort() 方法对数据进行排序，并且通过设置新的排序策略来切换不同的算法。

总之，在策略模式中，我们将不同的算法封装成独立的类，并且使得它们可以互相替换。这样可以使得程序更加灵活和易于维护，并且提高代码复用性和可扩展性。

3.策略模式的基本步骤

策略模式的基本步骤如下：

定义策略接口：定义一个策略接口，其中包含一个或多个方法用于实现不同的算法。
实现具体策略类：针对不同的算法，分别实现具体的策略类，并且实现相应的方法。
定义上下文类：定义一个上下文类，其中包含一个成员变量用于存储当前使用的策略对象，并且提供相应的 setter 方法来设置当前使用的策略对象。
调用上下文类：在客户端中创建上下文对象，并且通过调用其相应的方法来执行算法。

简单的策略模式示例代码，用于计算两个数的和或差：

1.定义策略接口 OperationStrategy：

public interface OperationStrategy {
    int operate(int num1, int num2);
}

2.实现具体策略类 AdditionStrategy 和 SubtractionStrategy：

public class AdditionStrategy implements OperationStrategy {
    @Override
    public int operate(int num1, int num2) {
        return num1 + num2;
    }
}

public class SubtractionStrategy implements OperationStrategy {
    @Override
    public int operate(int num1, int num2) {
        return num1 - num2;
    }
}

3.定义上下文类 Calculator：

public class Calculator {
    private OperationStrategy strategy;

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

    public int calculate(int num1, int num2) {
        return strategy.operate(num1, num2);
    }
}

4.调用上下文类 Calculator：

// 客户端代码
int a = 10;
int b = 5;

Calculator calculator = new Calculator();
calculator.setStrategy(new AdditionStrategy());
int result = calculator.calculate(a, b); // 计算 a + b

calculator.setStrategy(new SubtractionStrategy());
result = calculator.calculate(a, b); // 计算 a - b

在上述代码中，我们首先定义了一个名为 OperationStrategy 的接口，并且包含一个名为 operate() 的方法用于进行加法或减法操作。然后定义了两个具体的策略类，分别实现了相应的方法来完成加法和减法操作。

接着，我们定义了一个名为 Calculator 的上下文类，并且包含一个成员变量用于存储当前使用的策略对象。通过提供相应的 setter 方法来设置当前使用的策略对象，并且通过调用其 calculate() 方法来执行相应的算法。

最后，在客户端中创建一个 Calculator 对象，并且分别设置不同的策略对象来进行加法或减法操作。

4.实际的业务场景：

假设我们正在开发一个在线商城，需要为用户提供不同的支付方式，例如信用卡、支付宝、微信

首先定义一个支付策略接口 PaymentStrategy，其中包含一个名为 pay() 的方法用于进行支付操作。然后定义具体的支付策略类，例如 CreditCardPayment、AlipayPayment 和 WechatPayment 等，并且分别实现 pay() 方法来完成相应的支付流程。

代码如下：

public interface PaymentStrategy {
    void pay(double amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 信用卡支付流程
    }
}

public class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 支付宝支付流程
    }
}

public class WechatPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 微信支付流程
    }
}

在上述代码中，我们首先定义了一个名为 PaymentStrategy 的接口，并且包含一个名为 pay() 的方法用于进行支付操作。然后定义了三个具体的支付策略类，并且分别实现了 pay() 方法来完成相应的支付流程。

最后，在客户端中根据用户选择的支付方式创建相应的支付策略对象，并且调用其 pay() 方法来进行支付操作。例如：

// 客户端代码
double totalPrice = 1000.0;
String paymentMethod = "credit_card"; // 用户选择信用卡付款

if (paymentMethod.equals("credit_card")) {
    PaymentStrategy paymentStrategy = new CreditCardPayment();
    paymentStrategy.pay(totalPrice);
} else if (paymentMethod.equals("alipay")) {
    PaymentStrategy paymentStrategy = new AlipayPayment();
    paymentStrategy.pay(totalPrice);
} else if (paymentMethod.equals("wechat")) {
    PaymentStrategy paymentStrategy = new WechatPayment();
    paymentStrategy.pay(totalPrice);
}