设计模式——策略模式

设计模式——策略模式

定义一组算法，将每个算法都封装起来，并且使得他们之间可以相互替换。

先从一个小例子我们慢慢引出策略模式。例如我们经常初学 Java 的时候肯定想着做一个计算器，简单的加减乘除运算，现在我们只考虑简单的两个数字的加减。有非常多的实现方式，但是我们初学时脑海中第一浮现的应该是下面的代码。

class Calculator{
    
    private final static String ADD = "+";
    private final static String SUB = "-";
    
    public int exec(int a, int b,String symbol){
        int result = 0;
        if (ADD.equals(symbol)){
            result = add(a,b);
        }else if (SUB.equals(symbol)){
            result = sub(a,b);
        }
        return result;
    }
    
    private int add(int a,int b){
        return a+b;
    }

    private int sub(int a,int b){
        return a-b;
    }
}

此时我们想要优化代码，因为根据上面对于策略模式的定义，我们可以抽象出其实add和sub方法都是一个算法，我们可以将其抽象出来。

interface Calculator{

    public int exec(int a,int b);
}

//加法
class AddCalculator implements Calculator{

    @Override
    public int exec(int a, int b) {
        return a+b;
    }
}
//减法
class SubCalculator implements Calculator{

    @Override
    public int exec(int a, int b) {
        return a-b;
    }
}

根据定义我们将加法和减法两个算法都封装了起来，那么后面的可以使其相互替换是什么意思呢？其实就是根据传入不同的算法执行相应不同的方法，那么根据此来定义一个中间人进行转换。

class Context{
    
    private Calculator calculator = null;
    
    public Context(Calculator calculator){
        this.calculator = calculator;
    }
    
    public int exec(int a, int b){
        return this.calculator.exec(a,b);
    }
}

这样在使用的时候，可以对于不同算法的转换。

Context context = null;
        context = new Context(new AddCalculator());
        System.out.println(context.exec(3,2));
        context = new Context(new SubCalculator());
        System.out.println(context.exec(3,2));

那么策略模式的类图我们也可以由此推断出来。

上面有三个角色

• Strategy：抽象的策略模式。里面定义了每个具体的策略类要实现的定义。
• ConcreteStrategy：具体的操作。
• Context：承上启下的作用，传入具体的策略类，执行不同的方法。

策略模式就是这么简单，它就是采用了面向对象的继承和多态的机制。其他的没什么玄机。

其实上面的加减法我们还可以进一步的优化，这里就提出了策略枚举的说法。

enum Calculator {

    ADD("+") {
        @Override
        public int exec(int a, int b) {
            return a + b;
        }
    }, 
    SUB("-") {
        @Override
        public int exec(int a, int b) {
            return a - b;
        }
    };
    String value = "";

    private Calculator(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public abstract int exec(int a, int b);
}

我们再进行调用的话就更加简单了。

System.out.println(Calculator.ADD.exec(3,2));
System.out.println(Calculator.SUB.exec(3,2));

为什么上面的代码叫做策略枚举你呢？枚举没问题，因为他是Enum类，那么为什么是策略呢？找找看能不能找到策略的影子在里面。是的我们定义了一个抽象的exec方法。然后在每个枚举成员里面进行了实现。这样是不是和策略模式定义是一样的，对于算法进行了封装有各自实现，并且能够切换。

注意：策略枚举是一个非常优秀和方便的模式，但是它受到枚举类型的限制，每个枚举项都是public、final、static的，扩展性受到了一定的约束，因此在开发中，策略枚举一般担当不经常发生变化的角色。

参考

• 设计模式之禅
• https://www.cnblogs.com/java-my-life/archive/2012/05/10/2491891.html