设计模式的学习(10)策略模式

最新推荐文章于 2021-06-18 21:16:19 发布

weixin_34075268

最新推荐文章于 2021-06-18 21:16:19 发布

阅读量168

点赞数

文章标签：设计模式 python java

原文链接：https://my.oschina.net/xiaoyoung/blog/2994589

版权

2019独角兽企业重金招聘Python工程师标准>>>

策略模式

策略模式（Strategy Pattern），定义可相互替换的一系列算法类，将算法封装起来，使得算法独立于客户而变化。又叫政策模式，是一种对象行为型模式。

举例

为什么要使用策略模式呢？那我们想想如果不使用的话有什么问题呢。就以公共交通计算出行费用为例。如图所示，公交出行的费用计算规则是10公里内2块钱，超过10公里，每加1块钱可以座5公里。而地铁的规则则是6公里内3块钱，6-12公里内4块钱，12-22公里5块钱，22-32公里6块钱，超过32公里，每加1块钱可以座20公里

package work.johntsai.designpattern.strategy;

public class TrafficCostCalculate {

    public static final int TYPE_BUS = 1;
    public static final int TYPE_METRO = 2;

    private int getBusCost(int distance) {
        if (distance <= 0) {
            throw new IllegalArgumentException();
        } else if (distance <= 10) {
            return 2;
        } else {
            int exceed = distance - 10;
            return 2 + exceed / 5 + (exceed % 5 > 0 ? 1 : 0);
        }
    }

    private int getMetroCost(int distance) {
        if (distance <= 0) {
            throw new IllegalArgumentException();
        } else if (distance <= 6) {
            return 3;
        } else if (distance <= 12) {
            return 4;
        } else if (distance <= 22) {
            return 5;
        } else if (distance <= 32) {
            return 6;
        } else {
            int exceed = distance - 32;
            return 6 + exceed / 20 + exceed % 20 > 0 ? 1 : 0;
        }
    }

    public int getTrafficCost(int type, int distance) {
        switch (type){
            case TYPE_BUS:
                return getBusCost(distance);
            case TYPE_METRO:
                return getMetroCost(distance);
            default:
                throw new IllegalArgumentException();
        }
    }

    public static void main(String[] args) {

        TrafficCostCalculate costCalculate = new TrafficCostCalculate();
        int buscost = costCalculate.getTrafficCost(TYPE_BUS,18);
        int metrocost = costCalculate.getTrafficCost(TYPE_METRO,18);

        System.out.println("18公里公交花费"+buscost+"元");
        System.out.println("18公里地铁花费"+metrocost+"元");

    }

}

上面的代码包含了公交和地铁两种公共交通的价格计算的方式。如果想新增一种出租车的计算，则需要直接修改这个类的代码，导致后期难以维护。所以显然不符合开闭原则。TrafficCostCalculate这个类既负责计算公交，也负责计算地铁，也不符合单一指责原则。

用策略模式优化上面代码，在优化之前，先要学习一些概念。

如图所示：
策略模式主要有以下三种角色：

1.Strategy：抽象策略类。声明了抽象方法，是所有策略类的父类。
2.StrategyA:具体策略类。实现了抽象策略类中定义的抽象方法。
3.Context：环境类，用于操作策略的上下文环境。

首先实现的是抽象策略类，通过给定出行举例，计算出价格：

package work.johntsai.designpattern.strategy;

/**
 * 出行价格抽象策略类
 */
public interface CostStrategy {

    /**
     * 抽象方法，给定距离，计算出出行价格
     * @param distance 出行距离
     * @return 价格
     */
     int calculate(int distance);

}

然后就要实现公交和地铁的具体策略类：

package work.johntsai.designpattern.strategy;

/**
 * 公交出行价格策略类
 */
public class BusCostStrategy implements CostStrategy {
    @Override
    public int calculate(int distance) {
        if (distance <= 0) {
            throw new IllegalArgumentException();
        } else if (distance <= 10) {
            return 2;
        } else {
            int exceed = distance - 10;
            return 2 + exceed / 5 + (exceed % 5 > 0 ? 1 : 0);
        }
    }
}

package work.johntsai.designpattern.strategy;

/**
 * 地铁出行价格策略类
 */
public class MetroCostStrategy implements CostStrategy {
    @Override
    public int calculate(int distance) {
        if (distance <= 0) {
            throw new IllegalArgumentException();
        } else if (distance <= 6) {
            return 3;
        } else if (distance <= 12) {
            return 4;
        } else if (distance <= 22) {
            return 5;
        } else if (distance <= 32) {
            return 6;
        } else {
            int exceed = distance - 32;
            return 6 + exceed / 20 + exceed % 20 > 0 ? 1 : 0;
        }
    }
}

接下来就是要实现持有抽象策略对象的环境类了：

/**
 * 环境类
 * 持有一个抽象策略对象，用于定义采用的策略
 */
public class TrafficCalculateContext {

    private CostStrategy costStrategy;

    public void setCostStrategy(CostStrategy costStrategy){
        this.costStrategy = costStrategy;
    }

    public int calculate(int distance){
        if(this.costStrategy != null){
            return this.costStrategy.calculate(distance);
        }else {
            throw new RuntimeException("计算交通出行价格之前，必须要指定出行方式");
        }
    }

}

最后来测试一下具体的客户端使用：

package work.johntsai.designpattern.strategy;

public class Client {

    public static void main(String[] args) {

        TrafficCalculateContext calculateContext = new TrafficCalculateContext();

        calculateContext.setCostStrategy(new BusCostStrategy());
        int busCost = calculateContext.calculate(18);

        calculateContext.setCostStrategy(new MetroCostStrategy());
        int metroCost = calculateContext.calculate(18);

        System.out.println("18公里公交花费" + busCost + "元");
        System.out.println("18公里地铁花费" + metroCost + "元");

    }

}

通过以上策略模式的改写，我们将一个TrafficCostCalculate类拆分成了CostStrategy,BusCostStrategy,MetroCostStrategy,TrafficCalculateContext四个类。当我们想计算其他出行方式的价格时，我们只需要新增一个对应的策略类去实现calculate方法即可。不需要修改已有的代码。而且每个类只负责相应的职责，没有上帝类的存在。

总结

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

与状态模式的比较

状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。

状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。

转载于:https://my.oschina.net/xiaoyoung/blog/2994589