设计模式——策略模式

策略模式的定义

策略模式（Strategy Pattern）是一种比较简单的模式，也叫政策模式（Policy Pattern）其定义如下：Define a family of algorithms each one , and make them interchangeable(定义一组算法，将每个算法都封装起来，并且使他们之间可以互换)
这个定义很清晰、明确，”定义一组算法“就是定义了3个计谋，”将每个算法封装起来“，封装类Context的作用，”使他们可以互换“，因为都实现的是相同的接口。

策略模式通用类图
策略模式使用的是面向对象的继承和多态机制
▶Context封装角色：
它也叫做上下文角色，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，封装能存在着变化
▶Strategy抽象策略角色：
策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。类图中的AlgorithmInterface是运算法则+接口的意思。
▶ConcreteStrategy：
实现抽象策略中的操作，该类含有具体算法。

抽象的策略角色
是一个普通的接口。

public interface Strategy {
    //策略模式的运算法则
    public void doSomething();
}

具体策略角色
具体策略角色也是非常普通的一个实现类，只要实现接口中的方法就可以

public class ConcreteStrategy1 implements Strategy{
    @Override
    public void doSomething() {
        System.out.println("具体策略1的运算法则");
    }
    
}
public class ConcreteStrategy1 implements Strategy{
    @Override
    public void doSomething() {
        System.out.println("具体策略1的运算法则");
    }
    
}

封装角色
策略模式的重点就是封装角色，它是借助了代理模式的思路，差别就是策略模式的封装角色和被封装的策略类不用是同一个接口，如果是同一个接口那就成为了代理模式

//封装角色
public class Context {
    //抽象策略
    private Strategy strategy = null;
    //构造函数设置具体策略
    public Context(Strategy _strategy){
        this.strategy = _strategy;
    }
    //封装后的策略方法
    public void doAnything(){
        this.strategy.doSomething();
    }
}

高层模块
知道要用哪个策略，产生出他的对象，然后放到封装角色中

public class Client {
    public static void main(String[] args) {
        //声明一个具体策略
        Strategy strategy = new ConcreteStrategy1();
        //声明上下文对象
        Context context = new Context(strategy);
        //执行封装后的方法
        context.doAnything();
    }
}

---

策略模式的应用

策略模式的优点：

▶算法可以自由切换
这是策略模式本身定义，只要实现抽象类，他就成为策略家族的一个成员，通过封装角色对其进行封装，保证对外提供”可自由切换的模式“的策略。
▶避免使用多重条件判断
可以由其他模块决定采用何种策略，策略家族对外提供的访问接口就是封装类，简化了操作，，同时避免了条件语句判断。
▶扩展性良好
在现有系统中增加一个策略十分容易，只要实现接口就可以，其他都不用修改，类似于一个可反复拆卸的插件，也符合OCP原则（开闭原则）

策略模式的缺点：

▶策略类数量多
每一个策略都是一个类，复用可能性很小，类的数量增多。
▶所有策略都需要对外暴露
上层模块必须知道有哪些策略，然后才能决定使用哪一个策略，这与迪米特法则是相违背的。我们可以使用其他的模式来修正这个缺点，如工厂模式、代理模式、享元模式。

策略模式的使用场景：

▶多个类只有在算法或行为上稍有不同的场景
▶算符需要自由切换的场景
▶需要屏蔽算法规则的场景

策略模式的注意事项：

如果系统中的一个策略家族的具体策略数量超过4个，则需要考虑使用混合模式，解决策略膨胀和对外暴露的问题。

---

策略模式的扩展

输入3个参数，进行加减法运算，参数中两个是int型，剩下的一个参数是String类型的，只有”+“、”-“两个符合可以选择，不要考虑什么复杂校验，进行白箱测试，输入的就是标准的int 类型和String类型。

枚举策略

public enum Calculator {
    // 加法
    ADD("+") {
        public int exec(int a, int b) {
            return a+b;
        }
    },
    // 减法
    SUB("-") {
        public int exec(int a, int b) {
            return a-b;
        }
    };
    String value = "";
    // 定义成员值类型
    private Calculator(String _value) {
        this.value = _value;
    }
    // 获取枚举成员的值
    public String getValue(){
        return this.value;
    }
    // 声明一个抽象函数
    public abstract int exec(int a,int b);
}

为什么叫策略枚举？首先它是一个枚举类。策略呢?我们定义了一个抽象的方法exec(int a ,int b)然后在每个枚举成员中进行实现，如果不实现就不能编译。把原有定义在抽象策略中的方法移植到枚举中，每个枚举成员就成为一个具体策略
枚举策略定义如下：

• 它是一个枚举。
• 它是一个浓缩了的策略模式的枚举。

public class Client {
    public static void main(String[] args) {
        int a = 1;
        String symbol = "+";
        int b = 2;
        System.out.println(a+symbol+b+"="+Calculator.ADD.exec(a, b));
    }
}