23种设计模式之策略模式

策略模式的定义：
策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们还可以相互替换，策略模式让算法独立于使用它的客户端而独立变化。
策略模式的使用场景：

• 针对同一类型问题的多种处理方式，仅仅是具体行为有差别时
• 需要安全地封装多种同一类型的操作时
• 出现同一抽象类有多个子类，而又需要使用if-else或者 switch-case 来选择具体子类时

类图：

• Context：用来操作策略的上下文环境
• Stragety：策略的抽象
• ConcreteStragegyA,ConcreteStragegyB,ConcreteStragegyC：具体的策略实现
  简单实现：
  通常如果一个问题有多个解决方案时，比较简单的方式就是利用if-else或者switch-case 方式来根据不同的场景选择不同的解决方案，ＯＫ，咱们以北京的公交车为例，参考《Ａｎｄｒｏｉｄ源码设计模式》，首先看下通常的编写方式

public class PriceCalculator {    //公交车类型    private static final int BUS = 1;    //地铁类型    private static final int SUBWAY = 2;    public static void main(String[] args) {        PriceCalculator calculator = new PriceCalculator();        System.out.println("坐16公里的公交车票价位：" + calculator.calculatePrice(16, BUS));    }    /**     * 北京公交车，十公里之内一元钱，超过十公里之后每加一元钱可以乘5公里     *     * @param km     * @return     */    private int busPrice(int km) {        //超过十公里的距离        int extraTotal = km - 10;        //超过的距离对5公里倍数        int extraFactor = extraTotal / 5;        //超过的距离对5公里取余        int fraction = extraTotal % 5;        //价格计算        int price = 1 + extraFactor * 1;        return fraction > 0 ? ++price : price;    }    /**     * 6公里（含）内3元，6~12公里（含）4元，12~22公里（含）5元，22~32公里（含）6元     *     * @param km     * @return     */    private int subwayPrice(int km) {        if (km <= 6) {            return 3;        } else if (km < 12) {            return 4;        } else if (km < 22) {            return 5;        } else if (km < 32) {            return 6;        }        return 7;    }    private int calculatePrice(int km, int type) {        if (type == BUS) {            return busPrice(km);        } else if (type == SUBWAY) {            return subwayPrice(km);        }        return 0;    }}

如果想增加一个选择，只能在ｅｌｓｅ－ｉｆ中添加

    private int calculatePrice(int km, int type) {        if (type == BUS) {            return busPrice(km);        } else if (type == SUBWAY) {            return subwayPrice(km);        }else if(type == TAXT) {            return taxiPrice(km);        }        return 0;    }

很明显，PriceCalculator 类不是单一职责，１．计算公交车和地铁乘坐价格的职责。２.还有就是通过ｉｆ－ｅｌｓｅ的形式来判断使用哪种计算形式。当增加一种出行方式时，就需要增加一个方法。如上代码所示。整体代码比较混乱，这就是我们的主人公—策略模式登场的时候了。我们可以把每一种情景独立成一个函数，然后外部调用方法即可，但是这也是另一种耦合形式，对于可变性较大的算法族来说还是不太适合。
策略模式代码重构如下：

//计算接口public interface CalculateStrategy {    /**     * 按距离来计算价格     * @param km     * @return     */    int calculatePrice(int km);}//公交车价格计算策略public class BusStrategy implements CalculateStrategy {    @Override    public int calculatePrice(int km) {        //超过十公里的距离        int extraTotal = km - 10;        //超过的距离对5公里倍数        int extraFactor = extraTotal / 5;        //超过的距离对5公里取余        int fraction = extraTotal % 5;        //价格计算        int price = 1 + extraFactor * 1;        return fraction > 0 ? ++price : price;    }}//地铁价格计算策略public class SubwayStrategy implements CalculateStrategy {    @Override    public int calculatePrice(int km) {        if (km <= 6) {            return 3;        } else if (km < 12) {            return 4;        } else if (km < 22) {            return 5;        } else if (km < 32) {            return 6;        }        return 7;    }}

我们再创建一个扮演角色Context角色的类

//公交出行价格计算器public class TranficCalculator {    public static void main(String[] args){        TranficCalculator calculator = new TranficCalculator();//        //设置策略模式        calculator.setStrategy(new BusStrategy());        //计算价格        System.out.println("公交车乘16公里的价格："+calculator.calculatePrice(16));        //设置策略模式        calculator.setStrategy(new TaxiStrategy());        //计算价格        System.out.println("出租车乘16公里的价格："+calculator.calculatePrice(16));    }    CalculateStrategy mStrategy;    public void setStrategy(CalculateStrategy mStrategy) {        this.mStrategy = mStrategy;    }    public int calculatePrice(int km){        return mStrategy.calculatePrice(km);    }}

这样代码就重构完成了，代码逻辑非常清晰，而且耦合性降低了，可扩展性变强了，现在如果增加一个出租车的方式，

//出租车计算策略public class TaxiStrategy implements CalculateStrategy {    @Override    public int calculatePrice(int km) {        return 2 * km;    }}

总结：
策略模式主要是用来分离算法，在相同的行为抽象下有不同的具体实现策略。这个模式很好地展示了开闭原则，也就是定义抽象，注入不同的实现，从而达到很好的可扩展性。
优点：

• 结构清晰明了，使用简单直观
• 耦合度相对而言较低，扩展方便

• 操作封装也更为彻底，数据更安全

  缺点：

• 随着策略模式的增加，子类也会变得繁多
• 客户端必须知道所有的策略类，并自行决定使用哪一个策略类
• Strategy和Context之间的通信开销

策略模式就到这里，大家对策略模式是不是又有了新的看法呢？
该文章参考《android源码设计模式解析与实战》这本书。