概述

在策略模式中一个类的行为或者算法可以在运行时更改，这种类型的设计模式属于行为型模式。

在策略模式中定义了一系列的算法和策略，并将每个算法封装在独立的类中，使得他们能够互相替换，通过使用策略模式可以在运行时选择不同的算法，而不需要修改客户端代码。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象，策略对象改变 context 对象的执行算法。

举个通俗的例子

现在给我两个数字，我们想计算这两个数字的加减乘除的结果，每一种运算都是一种策略，可以将所有都实现出来，然后进行选择使用哪种。

应用场景

1. 出门旅行的交通工具选择。比如有火车-飞机，有火车-汽车-飞机。都是不同的策略。

2. 比如折扣。满500减50，和满500打8折，都是策略可供选择。

优缺点

优点：

算法可以自由切换，避免了多重复杂的条件语句。

缺点：

每增加一个策略都需要再实现一个策略类。并且策略都是对外公开的。

模式结构

1. 策略接口（抽象策略）：定义了实现策略对象的接口，规定了策略必须实现的方法，比如计算两个数必须实现计算方法。

2. 具体实现（具体策略）：实现了抽象接口，并且具体实现了接口的方法，不同策略实现的方法体不同，比如加减乘除。

3. 环境（Context）：维护对策略的引用，负责给调用方委派所需的实现策略。可以通过依赖注入（踩坑：@Service 版本）、简单工厂的方法获取具体策略。

示例代码

策略接口和具体实现

public interface Strategy {

    /**
     * 计算策略
     *
     * @param num1
     * @param num2
     * @return
     */
    int calculate(int num1 , int num2);
}

//加法策略
public class CalculateAdd implements Strategy{
    @Override
    public int calculate(int num1, int num2) {
        System.out.println("执行加法策略");
        return num1 + num2;
    }
}
//减法策略
public class CalculateSubtract implements Strategy{
    @Override
    public int calculate(int num1, int num2) {
        System.out.println("执行减法运算");
        return num1 - num2;
    }
}
//乘法策略
public class CalculateMultiply implements Strategy{
    @Override
    public int calculate(int num1, int num2) {
        System.out.println("执行乘法策略");
        return num1 * num2;
    }
}

 Context

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(int num1, int num2) {
        System.out.println(strategy.calculate(num1, num2));
    }

}

Main

public class test {
    public static void main(String[] args) {
        Context context = new Context(new CalculateAdd());
        context.setStrategy(4, 2);

        Context context1 = new Context(new CalculateMultiply());
        context1.setStrategy(4, 2);

        Context context2 = new Context(new CalculateSubtract());
        context2.setStrategy(4, 2);

    }
}

执行结果