设计模式——策略模式

策略模式

定义一系列的算法，把每一个算法封装起来，并且使它们可以相互替换。这个模式中使得各个算法可以独立于使用它的客户而变化。
策略模式的构成：
1.抽象策略角色：策略类，通常由一个接口或者抽象类实现。
2.具体策略角色：包装了相关的算法和行为，实现策略接口或继承抽象类。
3.环境角色：context，运行时持有一个策略类的引用，最终给客户端调用。
对应的uml图片为：
策略模式让算法独立于使用它的客户而独立变化。策略模式重点是封装不同的算法和行为，不同的场景下可以相互替换。策略模式是开闭原则的体现，开闭原则讲的是一个软件实体应该对拓展开放对修改关闭。因为策略模式在加入新的策略时，不会影响其他类的修改，增加了拓展性，也就是对拓展是开放的；对于调用场景来说，只依赖于抽象，而不依赖于具体实现，所以对修改是关闭的。
策略模式的优点和缺点
优点：
（1）调用策略中的方法在context中，没有和各个策略的实现耦合在一起，各个实现策略的不同子类可以去拓展、修改和切换。
（2）避免写很多if else代码，提高了可观性。同时可以结合抽象类（策略类）去使用，Java支持很好。
缺点：
（1）客户端调用时必须知道所有的策略类，并且感知到要调用哪一种策略实现。
（2）一旦抽象，必然会对一些特殊场景难以处理。并且这里去加入了很多的策略实现类，也有Context类的加入，增加了开销。

代码示例

比如现在支付方式有四种，这其中每一种方式都对应着不同的最后费用。这样可以应用策略模式。

Strategy.java

package design_pattern.strategy_pattern.intf;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;

/**
 * 抽象策略角色Strategy接口
 * @author 夸克
 * @create 2018/7/23 17:56
 */
public interface Strategy {
    // 定义计算recharge的方法
    Double calRecharge(Double charge);
}

2.StrategyContext.java

package design_pattern.strategy_pattern.context;

import design_pattern.strategy_pattern.factory.StrategyFactory;
import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.intf.Strategy;

/**
 * 策略模式中的环境角色 context
 * @author 夸克
 * @create 2018/7/24 14:57
 */
public class Context {

    private Strategy strategy;

    public Double calRecharge(Double charge, Integer type) {
        // 利用一个工厂去生成对应的策略
        strategy = StrategyFactory.getInstance().creator(ReChargeTypeEnum.from(type));
        if (strategy == null) {
            throw new RuntimeException("策略生成错误");
        }
        return strategy.calRecharge(charge);
    }
}

3.策略工厂，返回对应的策略

package design_pattern.strategy_pattern.factory;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.intf.Strategy;
import design_pattern.strategy_pattern.strategy.BusiAcctStrategy;
import design_pattern.strategy_pattern.strategy.CardStrategy;
import design_pattern.strategy_pattern.strategy.EBankStrategy;
import design_pattern.strategy_pattern.strategy.MobileStrategy;
import java.util.HashMap;
import java.util.Map;

/**
 * 策略工厂 负责Strategy实例的创建 根据传入的type实现创建不同的策略
 * @author 夸克
 * @create 2018/7/24 15:01
 */
public class StrategyFactory {

    private static StrategyFactory factory = new StrategyFactory();

    private static Map<ReChargeTypeEnum, Strategy> map = new HashMap<>();
    static {
        map.put(ReChargeTypeEnum.E_BANK, new EBankStrategy());
        map.put(ReChargeTypeEnum.BUSI_ACCOUNTS, new BusiAcctStrategy());
        map.put(ReChargeTypeEnum.MOBILE, new MobileStrategy());
        map.put(ReChargeTypeEnum.CARD_RECHARGE, new CardStrategy());
    }
    /**
     * getInstance方法进行初始化
     * @return
     */
    public static StrategyFactory getInstance() {
        return factory;
    }

    public Strategy creator(ReChargeTypeEnum type) {
        return map.get(type);
    }

}

四种策略的实现：

package design_pattern.strategy_pattern.strategy;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.intf.Strategy;

/**
 * @author 夸克
 * @create 2018/7/24 14:53
 */
public class BusiAcctStrategy implements Strategy {

    @Override
    public Double calRecharge(Double charge) {
        return charge * 0.9;
    }
}

package design_pattern.strategy_pattern.strategy;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.intf.Strategy;

/**
 * @author 夸克
 * @create 2018/7/24 14:57
 */
public class CardStrategy implements Strategy {

    @Override
    public Double calRecharge(Double charge) {
        return charge + charge * 0.01;
    }
}

package design_pattern.strategy_pattern.strategy;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.intf.Strategy;

/**
 * @author 夸克
 * @create 2018/7/24 14:52
 */
public class EBankStrategy implements Strategy {

    @Override
    public Double calRecharge(Double charge) {
        return charge * 0.85;
    }
}

package design_pattern.strategy_pattern.strategy;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.intf.Strategy;

/**
 * @author 夸克
 * @create 2018/7/24 14:54
 */
public class MobileStrategy implements Strategy {

    @Override
    public Double calRecharge(Double charge) {
        return charge;
    }
}

Main.java

package design_pattern.strategy_pattern.main;

import design_pattern.strategy_pattern.constant.ReChargeTypeEnum;
import design_pattern.strategy_pattern.context.Context;

/**
 * @author 夸克
 * @create 2018/7/26 23:30
 */
public class StrategyMain {

    public static void main(String[] args) {
        Context context = new Context();

        /**
         * 计算四种计算方式
         */
        Double aDouble = context.calRecharge(100D, ReChargeTypeEnum.E_BANK.getValue());
        Double bDouble = context.calRecharge(100D, ReChargeTypeEnum.BUSI_ACCOUNTS.getValue());
        Double cDouble = context.calRecharge(100D, ReChargeTypeEnum.MOBILE.getValue());
        Double dDouble = context.calRecharge(100D, ReChargeTypeEnum.CARD_RECHARGE.getValue());

        System.out.println(aDouble + "\t" + bDouble + "\t" + cDouble + "\t" + dDouble);
    }
}

github

代码已经上传至我的github：https://github.com/zhanglijun1217/java8/tree/master/src/design_pattern/strategy_pattern

引用

https://www.jianshu.com/p/71feb016ac05