设计模式之策略模式

1.刘备江东娶妻，赵云他容易吗？

大家还记得江东取妻的故事吗？
孙权有个妹妹——孙尚香，准备招刘备做女婿，然后孙权想办法把 刘备软禁起来，孙权的想法还是很单纯的嘛，就是不让你刘备回西川，然后我东吴想干啥就 干啥，夺荆州，吞西川也不是不可能的。东吴的想法是好的，无奈中间多了智谋无敌的诸葛 亮，他早就预测了东吴有此招数，于是在刘备去东吴招亲之前，特授以伴郎赵云三个锦囊， 说是按天机拆开解决棘手问题。
这三个妙计分别是：1.，找乔国老帮忙（也就是走后门了）;2.求吴国太放行（诉苦）;3.孙 夫人断后。想想看，这三个计谋有什么相似之处，他们都是告诉赵云要怎么执行，也就是说这三个计谋都 有一个方法是执行，具体执行什么内容，每个计谋当然不同了，分析到这里，我们是不是就 有这样一个设计思路：三个妙计应该实现的是同一个接口？聪明！是的。

2.代码实现

(1) 三个计谋

这是非常简单的类图，在这个场景中的三个主要角色都已经有了，每个妙计都提供了一 个可执行的方法，我们先来看接口。
妙计接口代码如下：
public interface IStrategy {
//每个锦囊妙计都是一个可执行的算法
public void operate();
}
接口很简单，定义了一个方法operate，每个妙计都是可执行的，否则那叫什么妙计。
第一个妙计——乔国老开后门代码如下：
public class BackDoor implements IStrategy {
public void operate() {
System.out.println(“找乔国老帮忙，让吴国太给孙权施加压力”);
}
}
第二个妙计——找吴国太哭诉，给自己开绿灯
public class GivenGreenLight implements IStrategy {
public void operate() { System.out.println(“求吴国太开绿灯,放行！”);
}
}
第三个妙计——逃跑的时候，让孙夫人断后，谁来砍谁
public class BlockEnemy implements IStrategy {
public void operate() { System.out.println(“孙夫人断后，挡住追兵”);
}
}
三个妙计都有了，那还缺少两个配角：
第一，妙计肯定要放到一个地方吧，这么重要的东西要保管呀，也就是承装妙计的锦囊，所以俗称锦囊妙计嘛；
第二，这些 妙计都要有一个执行人吧，是谁？当然是赵云了，妙计是小亮给的，执行者是赵云。赵云就是一个干活的人，从锦囊中取出妙计，执行，然后获胜。过程非常清晰，我们把完整的过程设计出来.

(2)锦囊

在类图中增加了一个Context封装类（也就是锦囊），其作用是承装三个策略，方便赵云使用，我们来看Context代码：
public class Context {
//构造函数，你要使用哪个妙计
private IStrategy straegy;
public Context(IStrategy strategy){
this.straegy = strategy;
}
//使用计谋了，看我出招了
public void operate(){
this.straegy.operate();
}
}
通过构造函数把策略传递进来，然后用operate()方法来执行相关的策略方法。三个妙计有了，锦囊也有了，然后就是赵云雄赳赳地揣着三个锦囊，拉着已步入老年行列的、还想着娶纯情少女的刘老爷子去入赘了。嗨，还别说，小亮同志的三个妙计还真是不错!

我们的赵云登场了

public class ZhaoYun {
    //赵云出场了，他根据诸葛亮给他的交代，依次拆开妙计
    public static void main(String[] args) {
    Context context;
    //刚刚到吴国的时候拆第一个
    System.out.println("---刚刚到吴国的时候拆第一个---"); context = new Context(new BackDoor()); //拿到妙计 context.operate();  //拆开执行
    System.out.println("\n\n\n\n\n\n\n\n");
    //刘备乐不思蜀了，拆第二个了
    System.out.println("---刘备乐不思蜀了，拆第二个了---");
    context = new Context(new GivenGreenLight());
    context.operate();  //执行了第二个锦囊
    System.out.println("\n\n\n\n\n\n\n\n");
    //孙权的小兵追来了，咋办？拆第三个
    System.out.println("---孙权的小兵追来了，咋办？拆第三个---");
    context = new Context(new BlockEnemy());
    context.operate();  //孙夫人退兵
    System.out.println("\n\n\n\n\n\n\n\n");
    }
}

我们来看看这段故事，运行结果如下：
—刚刚到吴国的时候拆第一个—
找乔国老帮忙，让吴国太给孙权施加压力
—刘备乐不思蜀了，拆第二个—
求吴国太开个绿灯，放行！
—孙权的小兵追来了，咋办？拆第三个—
孙夫人断后，挡住追兵
恩，不错，就这三招，搞得孙权是“赔了夫人又折兵”。那我们描述这个故事的过程就是策略模式。

总结

定义

策略模式：定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。
这个定义是非常明确、清晰的，“定义一组算法”，看看我们的三个计谋是不是三个算 法？“将每个算法都封装起来”，封装类Context不就是这个作用吗？“使它们可以互换”当然可 以互换了，都实现是相同的接口，那当然可以相互转化了。
策略模式就是这么简单，偷着乐吧，它就是采用了面向对象的继承和多态机制，其他没什么玄机。想想看，你真实的业务环境有这么简单吗？一个类实现多个接口很正常，你要有 火眼金睛看清楚哪个接口是抽象策略接口，哪些是和策略模式没有任何关系，这就是你作为 系统分析师的价值所在。

扩展

介绍一个策略枚举：
大家想想如何进行加减运算呢？

方法1：

public class Calculator {
    //加符号
    private final static String ADD_SYMBOL = "+";
    //减符号
    private final static String SUB_SYMBOL = "-";
    public int exec(int a,int b,String symbol){
        int result =0;
        if(symbol.equals(ADD_SYMBOL)){
            result = this.add(a, b);
        }else if(symbol.equals(SUB_SYMBOL)){
            result = this.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;
    }
}

方法2:

public int exec(int a,int b,String symbol){
    return symbol.equals(ADD_SYMBOL)?a+b:a-b;
}

方法3：（引入策略模式）

interface Calculator {
    public int exec(int a,int b);
}
public class Add implements Calculator {
    //加法运算
    public int exec(int a, int b) {
    return a+b;
    }
}
public class Sub implements Calculator {
    //减法运算
    public int exec(int a, int b) {
    return a-b;
    }
}
public class Context {
    private Calculator cal = null;
    public Context(Calculator _cal){
        this.cal = _cal;
    }
    public int exec(int a,int b,String symbol){
        return this.cal.exec(a, b);
    }
}

public void client() {
    //输入的两个参数是数字
    int a = 1; 

    int b = 2; 
    Context context = null;
//判断初始化哪一个策略
if(symbol.equals("+")){
    context = new Context(new Add());
}else if(symbol.equals("-")){
    context = new Context(new Sub());
} 
    System.out.println("运行结果为："+a+symbol+b+"="+context.exec(a,b,symb

}

策略枚举：

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);
}
public void client() {
    //输入的两个参数是数字
    int a = 1; 
    String symbol = args[1];    //符号
    int b = 2; 
    System.out.println("输入的参数为：+");
    System.out.println("运行结果为："+a+"+"+b+"="+Calculator.ADD.exec(a,b));
}

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

结尾

好了，就讲到这里吧，策略模式是一个非常简单的模式。它在项目中使用得非常多，但它单独使用的地方就比 较少了，因为它有致命缺陷：所有的策略都需要暴露出去，这样才方便客户端决定使用哪一 个策略。例如，在例子中的赵云，实际上不知道使用哪个策略，他只知道拆第一个锦囊，而 不知道是BackDoor这个妙计。是的，诸葛亮已经在规定了在适当的场景下拆开指定的锦囊， 我们的策略模式只是实现了锦囊的管理，但是我们没有严格地定义“适当的场景”拆开“适当 的锦囊”，在实际项目中，我们一般通过工厂方法模式来实现策略类的声明，读者可以参考 混编模式。