第2章-商城促销 - 策略模式

一、商城收银模拟

商城收银系统

代码实现

public class ShopingCharge {
    
    public static double total = 0; //总价
    
    public static StringBuilder objectList = new StringBuilder(""); //货物清单显示文档
    
    //点击OK按钮，每点击一次就将Form中的单价和数量获取并计算结果
    public static void button_OK_clicked(Form form) {
        double totalPrice = new BigDecimal(form.getPrice() * form.getNum()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        total += totalPrice;
        objectList.append("单价：" + form.getPrice() + " 数量：" + form.getNum() + " 合计：" + totalPrice + "\n");
    }
    //在界面上展示
    public static void show() {
        System.out.println(objectList);
        System.out.println("总价：" + total);
    }
    
    public static void main(String[] args) {
        //模拟10次点击OK按钮
        for (int i = 1; i <= 5; i++) {
            Form form = new Form(i, new BigDecimal(i + Math.random()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
            button_OK_clicked(form);
        }
        show();
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain=true)
class Form {
    
    private int num;
    
    private double price;
    
}

二、增加打折策略

带打折策略的收银台界面

代码实现

public class ShopingCharge2 {
    
    static Map<Integer,String> strategy = new HashMap<>();
    
    static {
        strategy.put(1, "正常收费");
        strategy.put(2, "打八折");
        strategy.put(3, "打七折");
        strategy.put(4, "打五折");
        
        System.out.println("----初始化打折策略-----");
    }
    
    public static double total = 0; //总价
    
    public static StringBuilder objectList = new StringBuilder(""); //货物清单显示文档
    
    //点击OK按钮，每点击一次就将Form中的单价和数量获取并计算结果
    public static void button_OK_clicked(Form2 form) {
        double totalPrice = new BigDecimal(form.getPrice() * form.getNum()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        
        switch (form.getStrategy()) {
            case 1:
                break;
            case 2:
                totalPrice = totalPrice * 0.8;
                break;
            case 3:
                totalPrice = totalPrice * 0.7;
                break;
            case 4:
                totalPrice = totalPrice * 0.5;
                break;
            default:
                break;
        }
        
        totalPrice = new BigDecimal(totalPrice).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        total += totalPrice;
        objectList.append("单价：" + form.getPrice() + " 数量：" + form.getNum() + " 合计：" + totalPrice + "\n");
    }
    //在界面上展示
    public static void show() {
        System.out.println(objectList);
        System.out.println("总价：" + total);
    }
    
    public static void main(String[] args) {
        //模拟次点击OK按钮
        for (int i = 1; i < 5; i++) {
            Form2 form = new Form2(i, new BigDecimal(i + Math.random()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(),i);
            button_OK_clicked(form);
        }
        show();
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain=true)
class Form2 {
    
    private int num;
    
    private double price;
    
    private int strategy;
    
}

思考

修改了主类，商城的打折策略是千变万化的，难道要每变一次打折策略就修改一次，然后重新编译到收银机器上吗？

改进：简单工厂实现

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

1. 现金收费抽象类

public interface CashSuper {
    public double acceptCash(double money);
}

2. 正常收费子类

class NormalCash implements CashSuper {

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

3. 折扣子类

@AllArgsConstructor
class CashRate implements CashSuper {
    
    private double rate = 1;

    @Override
    public double acceptCash(double money) {
        return new BigDecimal(money * rate).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    
}

4. 满减子类

@AllArgsConstructor
class CashReturn implements CashSuper {
    
    private double moneyCondition = 0;
    
    private double moneyReturn =0;

    @Override
    public double acceptCash(double money) {
        if(money > moneyCondition)
            return money - moneyReturn;
        else
            return money;
    }
}

5. 现金工厂类

class CashFactory {
     public static CashSuper createCashAccept(int type) {
         CashSuper cash = null;
         switch (type) {
            case 1: //"正常收费"
                cash = new NormalCash();
                break;
            case 2: //"打8折"
                cash = new CashRate(0.8);
                break;
            case 3: //"满300返100"
                cash = new CashReturn(300, 100);
                break;
            default:
                cash = new NormalCash();
                break;
        }
        return cash;
     }
    
}

6. 简单工厂测试类

class Test {
    public static double total = 0; //总价
    
    public static StringBuilder objectList = new StringBuilder(""); //货物清单显示文档
    
    //点击OK按钮，每点击一次就将Form中的单价和数量获取并计算结果
    public static void button_OK_clicked(Form2 form) {
        CashSuper cash = CashFactory.createCashAccept(form.getStrategy());  //根据下拉框中选择的打折策略从现金工厂中拿对象
        double totalPrice = new BigDecimal(cash.acceptCash(form.getPrice()) * form.getNum()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        total += totalPrice;
        objectList.append("单价：" + form.getPrice() + " 数量：" + form.getNum() + " 合计：" + totalPrice + "\n");
    }
    
    //在界面上展示
    public static void show() {
        System.out.println(objectList);
        System.out.println("总价：" + total);
    }
    
    //模拟多次收银
    public static void test() {
        //模拟次点击OK按钮
        for (int i = 1; i < 5; i++) {
            Form2 form = new Form2(i, new BigDecimal(i + Math.random()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(),i);
            button_OK_clicked(form);
        }
        show();
    }
    
}

简单工厂模式的问题

这个模式只解决了对象的创建问题，而且由于工厂本身包含了所有的收费方式，而商城又经常更改打折额度和返利额度，那么 $\color{red}{每次维护和拓展收费方式都要改动这个工厂类，以至于代码需要重新编译部署}$ 。这是很糟糕的处理方式。面对算法的经常变动，应该有更好的处理方式。

策略模式（Strategy）

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

策略模式概念图

策略模式代码简义

1. 抽象算法类

public interface Strategy {
   //Algorithm 美[ˈælɡərɪðəm] n.    算法; 计算程序;
   public void AlgorithmInterface();
}

2. 不同的实现策略

class ConcreteStrategyA implements Strategy  {

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

class ConcreteStrategyB implements Strategy  {

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

class ConcreteStrategyC implements Strategy  {

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

3. 上下文类，封装了策略引用

class Context   {
    Strategy strategy;
    
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void AlgorithmInterface() {
        strategy.AlgorithmInterface();
    }
}

4. 客户端调用

public class StrategyBasicTest {

    public static void main(String[] args) {
        Context context = null;
        context = new Context(new ConcreteStrategyA());
        context.AlgorithmInterface();
        
        context = new Context(new ConcreteStrategyB());
        context.AlgorithmInterface();
        
        context = new Context(new ConcreteStrategyC());
        context.AlgorithmInterface();

    }

}

现金收银的策略模式实现

1. 创建现金收银的策略模式上下文

class CashContext {
    
    private CashSuper cs;

    public CashContext(CashSuper cs) {
        this.cs = cs;
    }
    
    public double getResult(double money) {
        return cs.acceptCash(money);
    }   
}

2. 客户端代码点击按钮函数修改

//点击OK按钮，每点击一次就将Form中的单价和数量获取并计算结果
public static void button_OK_clicked(Form2 form) {
    double totalPrice = new BigDecimal(form.getPrice() * form.getNum()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    
    switch (form.getStrategy()) {
        case 1:
            break;
        case 2:
            totalPrice = new CashContext(new NormalCash()).getResult(form.getPrice());
            break;
        case 3:
            totalPrice = new CashContext(new CashRate(0.7)).getResult(form.getPrice());
            break;
        case 4:
            totalPrice = new CashContext(new CashRate(0.5)).getResult(form.getPrice());
            break;
        case 5:
            totalPrice = new CashContext(new CashReturn(100, 20)).getResult(form.getPrice());
            break;
        default:
            break;
    }
        
    totalPrice = new BigDecimal(totalPrice).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    total += totalPrice;
    objectList.append("单价：" + form.getPrice() + " 数量：" + form.getNum() + " 合计：" + totalPrice + "\n");
}

问题

每次有新逻辑又得需要改客户端代码，又回到归了第二版本的代码的弊病。这样子跟直接调用父类引用指向子类实现没什么区别。而且还多个累赘：上下文。 $\color{red}{客户端依然耦合算法}$

策略模式 ➕ 工厂模式

1. 上下文对象设计思路

class CashContext {
    
    private CashSuper cs;
    //策略模式 + 工厂模式，封装收费策略
    public CashContext(int type) {
        switch (type) {
            case 1:
                cs = new NormalCash();
                break;
            case 2:
                cs = new CashRate(0.8);
                break;
            case 3:
                cs = new CashRate(0.7);
                break;
            case 4:
                cs = new CashRate(0.5);
                break;
            case 5:
                cs = new CashReturn(100, 20);
                break;
            default:
                cs = new NormalCash();
                break;
        }
    }
    
    //保留2位小数
    public double getResult(double money) {
        return  new BigDecimal(cs.acceptCash(money)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    
}

2. 客户端调用

//点击OK按钮，每点击一次就将Form中的单价和数量获取并计算结果
public static void button_OK_clicked(Form2 form) {
    //原价 X 数量
    double totalPrice = new BigDecimal(form.getPrice() * form.getNum()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    //用策略模式策略一下
    totalPrice = new CashContext(form.getStrategy()).getResult(form.getPrice()); 
    total += totalPrice;
    objectList.append("单价：" + form.getPrice() + " 数量：" + form.getNum() + " 合计：" + totalPrice + "\n");
}

靓点

对比工厂方法的客户端调用：

CashSuper cash = CashFactory.createCashAccept(form.getStrategy()); 
cSuper.getResult();   //策略定义的父类的函数调用
--------------------------------------------------------------------
CashContext context = new CashContext(form.getStrategy());
context.getResult(form.getPrice());  //上下文的函数调用，客户端、算法彻底分开

简单工厂模式需要让客户端认识2个类：CashSuper、CashFactory
策略模式和工厂模式的结合，客户端只需要认识一个CashContext即可，耦合度更低

在客户端实例化的CashContext对象，调用的是CashContext方法的getResult()， $\color{red}{这使得具体的收费算法彻底地和客户端分离，连算法的父类CashSuper都不让客户端认识了}$

策略模式解析

。。。。

待改进之处：

策略模式依然不够完美，因为在Context中依然使用了switch分支结构，当有新需求变动的时候，依然需要改动Context类。 $\color{red}{使用反射可以解决此问题}$

第2章-商城促销 - 策略模式

一、商城收银模拟

代码实现

二、增加打折策略

代码实现

思考

改进：简单工厂实现

1. 现金收费抽象类

2. 正常收费子类

3. 折扣子类

4. 满减子类

5. 现金工厂类

6. 简单工厂测试类

简单工厂模式的问题

策略模式（Strategy）

策略模式代码简义

1. 抽象算法类

2. 不同的实现策略

3. 上下文类，封装了策略引用

4. 客户端调用

现金收银的策略模式实现

1. 创建现金收银的策略模式上下文

2. 客户端代码点击按钮函数修改

问题

策略模式 ➕ 工厂模式

1. 上下文对象设计思路

2. 客户端调用

靓点

策略模式解析

待改进之处：

推荐阅读更多精彩内容