设计模式——策略模式的学习

最新推荐文章于 2024-08-21 17:27:05 发布

原创最新推荐文章于 2024-08-21 17:27:05 发布 · 2.9k 阅读

4 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了策略模式的概念及其在支付方式中的应用案例。策略模式通过定义一系列的算法并将其封装成独立的对象来解决算法的选择和变更问题，使得算法可以独立于使用它的客户而变化。

策略模式

定义一系列的算法，把每一个算法封装起来，并且使它们可以相互替换。这个模式中使得各个算法可以独立于使用它的客户而变化。
策略模式的构成：
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);
    }
}