策略模式--Java篇

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

　　下面将以商场打折为例子，说明策略模式。商场收银如何促销，用打折还是返利其实都是一些算法，用简单工厂来生产算法对象，这没有错，但算法本身只是一种策略，最重要的是这些算法是随时都可能互相替换的，这就是变化点，而封装变化点是我们面向对象的一种很重要的思维方式。

　　1.Strategy类，定义所有支持的算法的公共接口：

　　

 package com.lujie;
 //抽象算法类
 public interface CashSuper {
     //算法方法
     public abstract double acceptCash(double money);
 }

　　2.ConcreteStrategy,封装了具体的算法或行为，继承与strategy

package com.lujie;
//打折收费子类
public class CashRebate implements CashSuper{
    private double moneyRebate=1d;
    public void setMoneyRebat(double moneyRebat) {
        this.moneyRebate = moneyRebat;
    }
    public double getMoneyRebat() {
        return moneyRebate;
    }
    @Override
    public double acceptCash(double money) {
        return money*moneyRebate;
    }
    public CashRebate(String moneyRebate) {
        // TODO Auto-generated constructor stub
        this.moneyRebate=Double.valueOf(moneyRebate).doubleValue();
    }
}

 package com.lujie;

 //返利收费子类
 public class CashReturn implements CashSuper{

     private double moneyCondition=0.0d;
     private double moneyReturn=0.0d;
     public void setMoneyCondition(double moneyCondition) {
         this.moneyCondition = moneyCondition;
     }
     public void setMoneyReturn(double moneyReturn) {
         this.moneyReturn = moneyReturn;
     }
     public double getMoneyCondition() {
         return moneyCondition;
     }
     public double getMoneyReturn() {
         return moneyReturn;
     }
     public CashReturn(String moneyCondition,String moneyReturn) {
         // TODO Auto-generated constructor stub
         this.moneyCondition=Double.valueOf(moneyCondition).doubleValue();
         this.moneyReturn=Double.valueOf(moneyReturn).doubleValue();
     }
     @Override
     public double acceptCash(double money) {
         // TODO Auto-generated method stub
         double result=money;
         if(money>=moneyCondition)
             result=money-Math.floor(money/moneyCondition)*moneyReturn;
         return result;
     }
 }

 package com.lujie;
 //正常收费子类
 public class CashNormal implements CashSuper{
     @Override
     public double acceptCash(double money) {
         // TODO Auto-generated method stub
         return money;
     }
 }

3.Context，用一个ContreteStrategy来配置，维护一个对strategy对象的引用。

 package com.lujie;
 //策略模式
 public class CashContext {
     private CashSuper cs;//声明一个CashSuper对象
     public CashContext(String type) {//注意参数不是具体的收费策略对象，
                                     //而是一个字符串，表示收费类型
                                    //初始化时，传入具体的策略对象
         switch (type) {
         case "正常收费":
             CashNormal cs0=new CashNormal();//根据具体的策略对象，调用器算法的方法
             cs=cs0;
             break;
         case "满300返100":
             CashReturn cs1=new CashReturn("300","100");
             cs=cs1;
             break;
         case "打8折":
             CashRebate cs2=new CashRebate("0.8");
             cs=cs2;
             break;
         //将实例化具体策略的过程由客户端转移到Context类中，简单工厂的应用
         }
     }
     public double getResult(double money) {
         return cs.acceptCash(money);
     }
 }

4.测试用例：

 package com.lujie;

 public class testStrategyMethod {

     public static void main(String[] args) {
         testStrategyMethod test=new testStrategyMethod();
         test.getResult("正常收费");
         test.getResult("满300返100");
         test.getResult("打8折");
     }
     public void getResult(String type) {
         double total=0.0d;
         // TODO Auto-generated method stub
         CashContext csSuper=new CashContext(type);
         double totalPrices=0d;
         totalPrices=csSuper.getResult(3000);
         total=total+totalPrices;
         System.out.println(type+"为："+total);
     }

 }

5.测试结果：