策略模式--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.测试结果：