设计模式之策略模式

定义:

 策略模式类图：

直接上代码：

本例将策略模式与简单工厂模式相结合

收费的抽象父类：

@Data
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;

    /**
     * 初始化对象的时候需要传入打几折
     * @param 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;

    /**
     * 初始化时需要传入 消费达多少元 返回多少元
     * @param moneyCondition  消费达多少元
     * @param moneyReturn 返回多少元
     */
    public CashReturn(double moneyCondition,double moneyReturn){
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }
    @Override
    public double acceptCash(double money) {
        if (money >= moneyCondition) {
          return money -= ((int)(money/moneyCondition))*moneyReturn;
        }
        return money;
    }
}

CashContext类：

public class CashContext {
    private CashSuper cashSuper;

    /**
     *
     * @param type 收费类型
     */
    public CashContext(String type) {
        switch (type){
            case "打八折":
                cashSuper = new CashRebate(0.8);
                break;
            case "返利收费":
                cashSuper = new CashReturn(300,100);
                break;
            default:
                cashSuper = new CashNormal();
                break;
        }
    }

    /**
     * 收费方法
     * @param money 本应收多少钱
     * @return 活动过后应收的钱
     */
    public double getResult(double money){
       return cashSuper.acceptCash(money);
    }
}

客户端：

public class Test {
    public static void main(String[] args) {
        double price = 100; //商品单价
        double number = 5;  //购买数量

        CashContext context = new CashContext("打八折");
        double result = context.getResult(price * number);
        System.out.println("经活动后应收：" + result); //经活动后应收：400.0

    }
}

本例关系图：

简单工厂模式我需要让客户端认识两个类CashSuper和 CashFactory，而策略模式与简单工厂结合的用法，客户端就只需要认识一个类CashContext就可以了，调用的是 CashContext的方法GetResult，耦合更加降低。这使得具体的收费算法彻底地与客户端分离，连算法的父类 CashSuper都不让客户端认识了。（结合迪米特原则思考）

收费的抽象父类是抽象的策略，而打折，返利等类就是具体的策略

结合简单工厂的好处就是把判断的过程从客户端转移走了，也就是说我们写的这个CashContext类的构造器其实应该传的是一个具体的收费子类，也就是一个具体的策略，与简单工厂结合过后将判断的责任从客户端移给了CashContext类了

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试