场景描述：

商场收银软件，商场经常进行满减，打折等一系列活动

定义

它定义了一组算法，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

类型：

行为类模式

策略模式结构图

策略模式结构解析

• 封装类：也叫上下文，对策略进行二次封装，目的是避免高层模块(客户端)对策略的直接调用。
• 抽象策略：通常情况下是一个接口(也可以用抽象类)，当各个实现类中存在着重复的逻辑时，则使用抽象类来封装这部分公共的代码。
• 具体策略：具体策略角色通常由一组封装了算法的类来担任，这些类之间可以根据需要*替换。

抽象策略类

public abstract class CashSuper {

    public abstract double acceptCash(double money);

}

具体策略类-正常收费类

public class CashNormal extends CashSuper {
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

具体策略类-打折收费类

public class CashRebate extends CashSuper {

    private double moneyRebate;

    public CashRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double acceptCash(double money) {
        return money * moneyRebate;
    }
}

具体策略类-满减收费类

public class CashReturn extends CashSuper {

    private double moneyCondition;
    private double moneyReturn;

    /**
     * 每满moneyCondition减moneyReturn
     *
     * @param moneyCondition
     * @param moneyReturn
     */
    public CashReturn(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double acceptCash(double money) {
        double v = 0.;
        if (money >= moneyCondition)
            v = money - Math.floor(money / moneyCondition) * moneyReturn;
        return v;
    }
}

封装类

**
 * @Description: 环境/封装类：用来操作策略的上下文环境
 * @Author: qjc
 * @Date: 2020/5/29
 */
public class CashContext {

    private CashSuper cashSuper;//声明一个收银对象

    //普通的策略模式：通过构造方法，传入具体的收费策略
    public CashContext(CashSuper cashSuper) {
        this.cashSuper = cashSuper;
    }

    //结合工厂模式的策略模式：通过构造方法，传入具体的收费类型，根据收费类型返回具体的策略。(简单工厂的应用)
//    public CashContext(String type) {
//        switch (type) {
//            case "1":
//                //正常收费
//                cashSuper = new CashNormal();
//                break;
//            case "2":
//                //满300返100
//                cashSuper = new CashReturn(300., 100.);
//                break;
//            case "3":
//                //打8折
//                cashSuper = new CashRebate(0.8);
//                break;
//        }
//
//    }

    public double GetResult(double money) {  //根据收费的策略不同，获得计算结果
        return cashSuper.acceptCash(money);
    }

}

测试客户端

public class StrategyModeTest {

    public static void main(String[] args) {
        //普通的策略模式
        CashContext cashContext = new CashContext(new CashReturn(300., 100.));
        //结合工厂模式的策略模式
//        CashContext cashContext = new CashContext("3");
        double v = cashContext.GetResult(600.);
        System.err.println(v);
    }

}

策略模式的优缺点 优点：

• 策略类之间可以*切换，由于是仙子同一个抽象，所以他们之间可以*切换。
• 易于扩展，增加一个新的策略对策略模式来说非常容易，基本上可以在不改变原有代码的基础上进行扩展。
• 避免使用多重条件，如果不使用策略模式，对于所有的算法，必须使用条件语句进行连接，通过条件判断来决定使用哪一种算法，使用多重条件判断非常不容易维护。

缺点：

• 维护各个策略类会给开发带来额外开销，一般来说，策略类的数量超过5个，就比较令人头疼了。
• 必须客户端(调用者)暴露所有的策略类，因为使用哪种策略是由客户端来决定的，而且客户端还需要知道都有什么策略，各个策略都是干什么的。