商场促销——策略模式

策略模式(Strategy)：它定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。(策略模式是对算法的包装，是把使用算法的责任和算法本身分割开，委派给不同的对象管理。)

Stragegy类，定义所有支持的算法的公共接口
ConcreteStrategy，封装了具体的算法或行为，继承于Strategy
Context，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少各种算法类与使用算法类之前的耦合。其中Strategy类层次为Context类定义了一系列可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。策略模式中的每个算法都有自己的类，可以通过自己的接口单独测试。当不同的行为堆砌在一个类当中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。

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

但仅仅使用策略模式的话，选择所用具体实现方式的职责仍然由客户端对象承担，并转给策略模式的context对象。而策略模式和简单工厂模式相结合以后，选择具体实现方式的职责就可以由context对象来承担，这极大地减轻了客户端的职责。
如一下代码：

 * 现金收费抽象类
 *****************************************************************/
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=1d;

    public CashRebate(String moneyRebate) {
        this.moneyRebate =Double.parseDouble(moneyRebate) ;
    }

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

* 返利收费子类
 * 返利收费，初始化时候输入返利条件和返利值
 * 若大于返利条件，则能减去返利值
 *****************************************************************/
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>this.moneyCondition){
            result=money-Math.floor(money/moneyCondition)*moneyReturn;
        }
        return result;
    }
}

 * 现金收费工厂类
 *****************************************************************/
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;
    }
}

 * 工厂类客户端
 *****************************************************************/
public class FactoryCilent {
    public static void main(String[] args) {
        CashSuper cashSuper=CashFactory.createCashAccept("正常收费");
        System.out.println(  cashSuper.acceptCash(400));
        CashSuper cashSuper1=CashFactory.createCashAccept("满300返100");
        System.out.println(  cashSuper1.acceptCash(400));
        CashSuper cashSuper2=CashFactory.createCashAccept("打8折");
        System.out.println(  cashSuper2.acceptCash(400));

    }
}

* 策略加工厂模式
 *****************************************************************/
public class CashContext {
         CashSuper cs;
    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);
        }
}

 * 工厂类和策略类结合客户端
 ****************************m*************************************/
public class StrategyCilent {
    public static void main(String[] args) {
        CashContext cashContext =new CashContext("正常收费");
    System.out.println(  cashContext.GetResult(400));
    CashContext cashContext1=new CashContext("满300返100");
    System.out.println(  cashContext1.GetResult(400));
    CashContext cashContext2=new CashContext("打8折");
    System.out.println(  cashContext2.GetResult(400));

}
}

如上看出简单工厂模式实现需要客户端认识2个类，而策略加工厂模式只需一个类。
不完美的是还是用到了switch代码如每次增加一种算法就要更改CashContenxt的switch的代码。可以使用反射代替。或者下面方法实现

public class CashAgency {
    private static Map<String, Object> maps;
    // 绑定方法
    static {
        maps = new HashMap<String,Object >();
        try {
            // maps.put("参数", "方法名")
            maps.put("正常收费", new CashNormal());
            maps.put("满300返100", new  CashReturn("300","100"));
            maps.put("打8折", new CashRebate("0.8"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

         CashSuper cs;
    public CashAgency(String type){
        try {
            // 判断Map集合中是否存在
            if(maps.containsKey(type)) {
                // 获取方法对象
                Object className = maps.get(type);
                // 调用方法
                cs= (CashSuper) className;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }



    }
        public double GetResult(double money){
            return cs.acceptCash(money);
        }
}

public class AgencyCilent {
    public static void main(String[] args) {
        CashAgency cashContext =new CashAgency("正常收费");
    System.out.println(  cashContext.GetResult(400));
        CashAgency cashContext1=new CashAgency("满300返100");
    System.out.println(  cashContext1.GetResult(400));
        CashAgency cashContext2=new CashAgency("打8折");
    System.out.println(  cashContext2.GetResult(400));

}
}

这里添加新的算法的话只需在map加上新的put对象就可以。无需更改跟客户端关联的代码。