大话设计模式——第二章（策略模式JAVA版）

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

/**
 * @author zdy
 * @create 2018-11-15 22:53
 */
public abstract class CashSuper {
    public abstract double acceptCash(double money);
}

/**
 * @author zdy
 * @create 2018-11-15 22:54
 */
public class CashNormal extends CashSuper {
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

/**
 * @author zdy
 * @create 2018-11-15 22:55
 */
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*moneyRebate;
    }
}

/**
 * @author zdy
 * @create 2018-11-15 22:58
 */
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 zdy
 * @create 2018-11-15 23:11
 */
public class CashContext {
    CashSuper cs = null;
    public CashContext(String type)
    {
/* 将实例化具体策略的过程由客户端转移到Context类中。简单工厂模式和策略模式中的Context相结合；基本的策略模式中，选择所具有实现的职责由客户端对象所承担，并转给策略模式的Context对象，这还是需要利用客户端对象承担，但是将策略模式和简单工厂模式结合之后，选择具体实现的职责就由Context来承担，这就简化了客户端的职责。*/
//        策略模式中的Context是为了对CashSuper对象的引用
        switch(type)
        {
            case "正常收费":
                CashNormal cashNormal = new CashNormal();
                cs = cashNormal;
                break;
            case "满300返100":
                CashReturn cashReturn = new CashReturn("300", "100");
                cs = cashReturn;
                break;
            case "打8折":
                CashRebate cashRebate = new CashRebate("0.8");
                cs = cashRebate;
                break;
        }
    }
//    根据具体的策略对象调用其accepCash()方法
    public double getResult(double money){
        return cs.acceptCash(money);
    }
}

/**
 * @author zdy
 * @create 2018-11-15 23:16
 */
public class CashTest {
   public static  void main(String args[]){
       CashContext cs = new CashContext("打8折");
       System.out.println(cs.getResult(300));
   }
}

根据上面的代码，可以知道策略模式就是将算法定义在接口中，再实现接口从而生成多个实现类来定义不同的算法和构造函数，在Context上下文类中结合简单工厂模式，来构造不同的实现类，再利用测试类来实现不同的实现类从而调用不同的算法。
本文部分内容来自大话设计模式，仅供参考，欢迎在评论区交流交流。