Java 8重构策略模式

策略模式

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

image.png

这个模式涉及到三个角色：

●　　环境(Context)角色：持有一个Strategy的引用。

●　　抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

●　　具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。
　　
商场打折案例:

    /**
     * 抽象算法类
     */
    public interface CashStrategy {
    
        double acceptCash(double money);
    }

    /**
     * 返利200返100等
     */
    public class CashReturnStrategy implements CashStrategy {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;
    
        public CashReturnStrategy(double moneyCondition, double moneyReturn) {
            this.moneyCondition = moneyCondition;
            this.moneyReturn = moneyReturn;
        }
    
        @Override
        public double acceptCash(double money) {
            if(money >= moneyCondition){
                money = money - (int)(money / moneyCondition) * moneyReturn;
            }
            return money;
        }
    }

    /**
     * 打折
     */
    public class CashRebateStrategy implements CashStrategy {
        private double moneyRebate = 1d;//打折额度
    
        public CashRebateStrategy(double moneyRebate) {
            this.moneyRebate = moneyRebate;
        }
    
        @Override
        public double acceptCash(double money) {
            return money * moneyRebate;
        }
    }

    /**
     * 正常价格
     */
    public class CashNomalStrategy implements CashStrategy{
    
        @Override
        public double acceptCash(double money) {
            return money;
        }
    }

    /**
     * Created by huang on 17-4-12.
     */
    public class CashContext {
    
        private CashStrategy cashStrategy;
    
        public CashContext(CashStrategy cashStrategy) {
            this.cashStrategy = cashStrategy;
        }
    
        public double getResult(double money){
            return cashStrategy.acceptCash(money);
        }
    }

    public class Main {
        public static void main(String[] args) {
        /**
         * Java 8前策略模式使用
         */
        CashStrategy cashStrategy = new CashReturnStrategy(500, 200);
        CashContext cashContext = new CashContext(cashStrategy);
        double price = cashContext.getResult(400.6);
        System.out.println("Java 8 以前策略模式计算金额 price=" + price);

        /**
         * Java 8 重构策略模式
         */
        CashContext cashContext1 = new CashContext(money -> money - (int)(money / 500) * 200);
        System.out.println("Java 8 以后简便写法计算金额 price=" + cashContext1.getResult(400.6));
      }
    }

打印结果为：

Java 8 以前策略模式计算金额 price=400.6
Java 8 以后简便写法计算金额 price=400.6

可以看出使用Java8重构策略模式后，就不需要具体的策略实现，通过Lambda表达式传递给构造函数。因此实现策略模式只需要，定义一个CashStrategy抽象类，以及一个CashContext类，然后就可以直接使用它。