大话数据模式（2） 商场促销-策略模式

2.1 商场收银软件

　　简单实现，当增加新的打折手段时，又要重新修改代码

2.2 增加打折

　　使用switch 与 下拉框简单增加功能实现，当增加功能时，还是需要重写代码

2.3 简单工厂实现

　　使用工厂模式将打一折到打九折整合到一起

　　面向对象的编程，并不是类越多越好，类的划分是为了封装，但是分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类

　　但是，当增加全新的非打折功能时，之前的工厂类就需要重写，这里可以有更好的解决办法

package com.zjk.code2Strategy;

/**
 * @author zhoujiankang5
 * @date 2020/9/2 18:23
 */
public abstract class CashSuper {
    public abstract double acceptCash(double money);
}

class CashNormal extends CashSuper{

    @Override
    public double acceptCash(double money) {
        return money;
    }
}

class CashRebate extends CashSuper{
    private double moneyRebate=1.0d;

    public CashRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

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

class CashReturn extends CashSuper{
    private double moneyCondition=0.0d;
    private double moneyReturn=0.0d;

    public CashReturn(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double acceptCash(double money) {
        double result=money;
        if(money>=moneyCondition){
            return money-Math.floor(money/moneyCondition)*moneyReturn;
        }
        return result;
    }
}

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;
    }
}

class Agent{
    public static void main(String[] args) {
        CashSuper cs=CashFactory.createCashAccept("打8折");
        double totalPrices=0.0d;
        totalPrices=cs.acceptCash(100.0d);
        System.out.println(totalPrices);
    }

}

2.4 策略模式

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

package com.zjk.code2Strategy;

/**
 * @author zhoujiankang5
 * @date 2020/9/2 18:40
 */
public abstract class Strategy {
    public abstract void AlgorithmInterface();
}

class ConcreteStrategyA extends Strategy{

    @Override
    public void AlgorithmInterface() {
        System.out.println("算法A");
    }
}

class ConcreteStrategyB extends Strategy{

    @Override
    public void AlgorithmInterface() {
        System.out.println("算法B");
    }
}

class ConcreteStrategyC extends Strategy{

    @Override
    public void AlgorithmInterface() {
        System.out.println("算法C");
    }
}

class Context{
    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void ContextInterface(){
        strategy.AlgorithmInterface();
    }
}

class Agent022{
    public static void main(String[] args) {
        Context context;
        context=new Context(new ConcreteStrategyA());
        context.ContextInterface();

        context=new Context(new ConcreteStrategyB());
        context.ContextInterface();

        context=new Context(new ConcreteStrategyC());
        context.ContextInterface();
    }
}

2.5 策略模式实现

　　CashSuper、CashNormal、CashRebate就是三个具体的策略（算法）

　　但是，当前只是用策略模式会出现判断使用哪一种算法，在客户端进行判断

2.6 策略与简单工厂

　　简单工厂模式我需要让客户端认识两个类【CashSuper和CashFactory】，而策略模式与简单工厂模式结合的用法，客户端只需要认识一个CashContext即可，耦合性更低

package com.zjk.code2Strategy;

/**
 * @author zhoujiankang5
 * @date 2020/9/4 19:31
 */
public class StrategyFactory {
    public static void main(String[] args) {
        CashContext cc=CashContext.createContext("打八折");
        System.out.printf("最终付款:"+cc.getResult(100.0d));
    }
}

class CashContext{
    CashSuper cs=null;
    public CashContext(String type){
        switch (type){
            case "正常收费":
                cs=new CashNormal();
                break;
            case "满300返100":
                cs=new CashReturn(300,100);
                break;
            case "打八折":
                cs=new CashRebate(0.8);
                break;
        }
    }
    public double getResult(double money){
        return cs.acceptCash(money);
    }

    public static CashContext createContext(String type){
        return new CashContext(type);
    }
}

2.7 策略模式解析

　　策略模式封装了变化！