策略模式（二）

策略模式： 定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
应用场景：经常会变的需求可以用策略模式，将这些需求的算法抽象出来，形成一个策略类，然后具体的算法实现抽象类方法，完成不同的功能。
举例：商场收银，会进行不同的促销活动，比如打折，满减等。

分析：根据需求，我们可以用简单工厂模式实现，但是每次新增加一个优惠类型就要修改工厂方法，这并不是最好的办法，我们可以使用策略模式解决算法经常变动的问题。

实现：

首先抽象出所有活动的本质CashSuper类，即对传入金额的处理，此类作为基类。

/**
 * 抽象策略：现金收费类，抽象出所有算法的共同点
 */
public class CashSuper {

    /**
     * 接口方法
     * @param money 应收款
     * @return  实收款
     */
    public double acceptCash(double money){
        return money;
    }
}

然后根据不同的需求继承基类，重写acceptCash方法，实现不同的算法。

满减活动CashReturn类：

/**
 * 满减收费
 */
public class CashReturn extends CashSuper {

    /**
     * 需要满足的金额
     */
    private double moneyCondition;

    /**
     * 满减金额
     */
    private double moneyReturn;

    public CashReturn(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

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

打折活动类CashRebate：

/**
 * 打折收费
 */
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 BaseCashContext {
    private CashSuper cashSuper;

    public BaseCashContext(CashSuper cashSuper) {
        this.cashSuper = cashSuper;
    }

    public double getResult(double money){
        return cashSuper.acceptCash(money);
    }
}

上面的代码实现了一个基本的策略模式，下面是测试类：

/**
 * 策略模式测试类
 */
public class StrategyTest {

    public static double baseCashContext(String type, double money){
        BaseCashContext baseCashContext = null;
        switch (type){
            case "正常收费":
                baseCashContext = new BaseCashContext(new CashNormal());
                break;
            case "满300减30":
                baseCashContext = new BaseCashContext(new CashReturn(300, 30));
                break;
            case "打8折":
                baseCashContext = new BaseCashContext(new CashRebate(0.8));
                break;
            default:
                break;
        }
        return baseCashContext.getResult(money);
    }

    public static void main(String[] args){
        String type = "正常收费";
        double money = 300;
        // 基础策略模式
        System.out.println(baseCashContext(type, money));

    }
}

策略模式和简单工厂模式对比：
        简单工厂模式需要客户端认识两个类，即CashSuper和CashFactory，而策略模式只需要客户端认识一个CashContext类。
策略模式的耦合度更低。在策略模式中，客户端实例化CashContext对象，调用的是CashContext的方法getResult()，这使得具体的收费算法彻底与客户端分离，连算法的父类都不需要让客户端认识了。

如果要进一步降低客户端使用的复杂度，可以将策略模式和简单工厂模式相结合，策略类可以写成下面这种方式：

/**
 * 策略模式与简单工厂模式相结合：根据传入策略不同调用不同的方法
 */
public class CashContext {

    private CashSuper cashSuper;

    public CashContext(String type) {
        switch (type){
            case "正常收费":
                cashSuper = new CashNormal();
                break;
            case "满300减30":
                cashSuper = new CashReturn(300, 30);
                break;
            case "打8折":
                cashSuper = new CashRebate(0.8);
                break;
            default:
                break;
        }
    }

    public double getResult(double money){
        return cashSuper.acceptCash(money);
    }
}

测试方法：

/**
 * 策略模式测试类
 */
public class StrategyTest {

    public static double cashContext(String type, double money){
        CashContext cashContext = new CashContext(type);
        return cashContext.getResult(money);
    }

    public static void main(String[] args){
        String type = "正常收费";
        double money = 300;
        // 策略模式与简单工厂模式相结合
        System.out.println(cashContext(type, money));
    }

}

基础策略模式和策略模式&简单工厂模式结合对比：
        基本策略模式中，选择所用具体实现的职责由客户端承担，并转给策略模式的Context对象。这本身并没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context承担，这就最大化地减轻了客户端的职责。
        这已经比起初的策略模式好用了，不过在CashContext中还是用到了switch，也就是说如果增加一种"满200送20"，还是要更改CashContext中的switch，要解决这个问题就要用到反射技术（后续抽象工厂模式中会有）。

策略模式解析：
        策略模式是一种定义一系列算法的方法，从概念上看，所有算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
策略模式的Strategy类层次（即CashSuper类）为Context类定义了一系列可重用的算法或行为。继承有助于析取出这些算法的公共功能（即getResult()方法）。
策略模式的应用：
        策略模式主要的作用就是封装了变化，实际应用中，只要是需要在不同的时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

源码地址：https://gitee.com/nisen6477/design-patterns.git