/**
 * 现金收费抽象类
 * @author Monica
 *
 */
public abstract class CashSuper {
    /**
     * 现金收取超类的抽象方法
     * @param money 收取现金，参数为原价
     * @return 返回当前价
     */
    public abstract double acceptCash(double money);
}

/**
 * 正常收费子类
 * @author Monica
 *
 */
public class CashNormal extends CashSuper{

    /**
     * 正常收费，原价返回
     */
    @Override
    public double acceptCash(double money) {
        return money;
    }

}

/**
 * 打折收费子类
 * @author Monica
 *
 */
public class CashRebate extends CashSuper{
    private double moneyRebate = 1d;
    
    public CashRebate(String moneyRebate) {
        /*
         * 打折收费，初始化时，必须输入折扣费，如八折，就是0.8
         */
        this.moneyRebate = Double.parseDouble(moneyRebate);
    }

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

}

/**
 * 返回收费子类
 * @author Monica
 *
 */
public class CashReturn extends CashSuper {
    //返利条件
    private double moneyCondition = 0.0d;
    //返利值
    private double moneyReturn = 0.0d;

    public CashReturn(String moneyCondition, String moneyReturn) {
        this.moneyCondition = Double.parseDouble(moneyCondition);
        this.moneyReturn = Double.parseDouble(moneyReturn);
    }
    
    @Override
    public double acceptCash(double money) {
        double result = money;
        if (money >= moneyCondition) {
            //若大于返利条件，则需要减去返利值
            result = money - Math.floor(money / moneyCondition) * moneyReturn; 
        }
        return result;
    }
}

/**
 * 现金收费工厂类
 * @author Monica
 *
 */
public class CashFactory {
    public static CashSuper createCashAccept(String type) {
        CashSuper cs = null;
        switch (type) {
        case "正常收费":
            cs = new CashNormal();
            break;
        case "满300返回100":
            cs = new CashReturn("300", "100");
            break;
        case "打8折":
            cs = new CashRebate("0.8");
            break;
        }
        return cs;
    }
}

不利点：每次维护和扩展收费方式，都要改动这个工厂。
进阶：策略模式

 

/**
 * 策略与简单工厂结合
 * @author Monica
 *
 */
public class CashContext {
    CashSuper cs = null;
    
    public CashContext(String type) {
        switch (type) {
        case "正常收费":
            cs = new CashNormal();
            break;
        case "满300返回100":
            cs = new CashReturn("300", "100");
            break;
        case "打8折":
            cs = new CashRebate("0.8");
            break;
        }
    }
    
    public double GetResult(double money) {
        return cs.acceptCash(money);
    }
}

//客户端
    public static void main(String[] args) {
        CashContext csuper = new CashContext("打8折");
        double totalPrices = 0d;
        totalPrices = csuper.GetResult(Double.parseDouble("800"));
    }

 

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

优点：

策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。

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

当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。

策略模式就是用来封装算法的，但在实践中，我们可以用它来封装几乎任务类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。

 

任务需求的变更都是需要成本的

（更改需要还是需要更改switch，这个办法可以用到  反射技术  ）