大话设计模式之策略模式

最新推荐文章于 2022-05-12 16:25:51 发布

yaoyumeigood

最新推荐文章于 2022-05-12 16:25:51 发布

阅读量184

点赞数 2

分类专栏：设计模式

本文链接：https://blog.csdn.net/yaoyumeigood/article/details/80736098

版权

设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

题目：做一个商场收银软件，营业员根据客户所购买的商品数量和单价，向客户收费。

将业务封装起来，代码如下:

public class CashierController {

    public double confirmOrder(long number,double price){
        BigDecimal total = new BigDecimal(0);
        total.add(new BigDecimal(price).multiply(new BigDecimal(number))).setScale(2,BigDecimal.ROUND_HALF_UP);
        System.out.println("购买单价：" + price + "，购买数量：" + number + "，总金额：" + total.doubleValue());
        
        return total.doubleValue();
    }
}

一、增加活动

1. 商场活动，增加五折、七折和八折优惠

public class CashierController {
    /**
     *
     * @param number 数量
     * @param price 单价
     * @param selectDiscount 选择折扣：0 不打折；1 八折；2 七折；3 五折
     * @return
     */
    public double confirmOrder(long number,double price,int selectDiscount){
        BigDecimal total = new BigDecimal(0);
        switch (selectDiscount){
            case 0:
                total.add(new BigDecimal(price).multiply(new BigDecimal(number))).setScale(2,BigDecimal.ROUND_HALF_UP);
                break;
            case 1:
                total.add(new BigDecimal(price).multiply(new BigDecimal(number))).multiply(new BigDecimal(0.8)).setScale(2, BigDecimal.ROUND_HALF_UP);
                break;
            case 2:
                total.add(new BigDecimal(price).multiply(new BigDecimal(number))).multiply(new BigDecimal(0.7)).setScale(2, BigDecimal.ROUND_HALF_UP);
                break;
            case 3:
                total.add(new BigDecimal(price).multiply(new BigDecimal(number))).multiply(new BigDecimal(0.5)).setScale(2, BigDecimal.ROUND_HALF_UP);
                break;
        }
        System.out.println("购买单价：" + price + "，购买数量：" + number + "，总金额：" + total.doubleValue());
        return total.doubleValue();
    }
}

面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。打五折和打七折只是形式的不同，抽象分析出来，所有的打折算法都是一样的，所以打折算法应该是一个类。

2. 继续增加满200送50、满300送100

（1）简单工厂实现

现金收费抽象类

public interface CashSuper {
    /**
     * 收取现金
     * @param money 原价
     * @return  当前价
     */
    public double acceptCash(double money);
}

正常收费子类

public class CashNormal implements CashSuper {
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

打折收费子类

public class CashRebate implements CashSuper{

    private double moneyRebate = 1d;    //折扣值

    @Override
    public double acceptCash(double money) {
        return new BigDecimal(money).multiply(new BigDecimal(moneyRebate)).doubleValue();
    }

    public double getMoneyRebate() {
        return moneyRebate;
    }

    public void setMoneyRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }
}

返利收费子类

public class CashReturn implements CashSuper{
    
    private double moneyCondition;  //返利条件
    private double moneyReturn;     //返利金额

    @Override
    public double acceptCash(double money) {
        if (new BigDecimal(money).compareTo(new BigDecimal(moneyCondition)) == 1){
            return new BigDecimal(money).subtract(new BigDecimal(moneyReturn)).
                       setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
        return money;
    }

    public double getMoneyCondition() {
        return moneyCondition;
    }

    public void setMoneyCondition(double moneyCondition) {
        this.moneyCondition = moneyCondition;
    }

    public double getMoneyReturn() {
        return moneyReturn;
    }

    public void setMoneyReturn(double moneyReturn) {
        this.moneyReturn = moneyReturn;
    }
}

现金收费工厂类

public class CashFactory {
    public CashSuper createCashAccept(String type){
        CashSuper cashSuper = null;
        switch (type){
            case "正常收费":
                cashSuper = new CashNormal();
                break;
            case "满300送100":
                CashReturn cashReturn = new CashReturn();
                cashReturn.setMoneyCondition(300);
                cashReturn.setMoneyReturn(100);
                cashSuper = cashReturn;
                break;
            case "打八折":
                CashRebate cashRebate = new CashRebate();
                cashRebate.setMoneyRebate(0.8);
                cashSuper = cashRebate;
        }
        return cashSuper;
    }
}

如果需要打九折和满500送100的促销活动，则需要修改现金收费工厂；如果增加一种商场促销手段，满100积分10点，积分到一定时候可以领取奖品，则需要加一个积分算法，同时修改工厂类。

简单工厂模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场可能经常性地更改打折额度和返利额度，每次维护或扩展收费方式都要改动这个工厂，以致代码需要重新编译部署。

（2）策略模式

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

算法本身就是一种策略，最重要的是算法随时都可能相互替换的，这就是变化点。封装变化点是面向对象的一个重要概念。

商场收银系统的策略模式实现，结构图如下所示：

由简单工厂模式到策略模式的改变不大，原来的CashSuper、CashNormal、CashRebate和CashReturn都不要变化，只需要增加一个CashContext类。

public class CashContext {

    private CashSuper cashSuper;

    /**
     * 构造方法
     * @param cashSuper 收费策略
     */
    public CashContext(CashSuper cashSuper){
        this.cashSuper = cashSuper;
    }

    /**
     * 根据收费策略的不同，获得计算结果
     * @param money 原价
     * @return      当前价
     */
    public double GetResult(double money){
        return cashSuper.acceptCash(money);
    }
}

（3）策略与简单工厂模式的结合

public class CashContext {

    private CashSuper cashSuper;

    public CashContext(String type){
        switch (type){
            case "正常收费":
                cashSuper = new CashNormal();
                break;
            case "满300送100":
                CashReturn cashReturn = new CashReturn();
                cashReturn.setMoneyCondition(300);
                cashReturn.setMoneyReturn(100);
                cashSuper = cashReturn;
                break;
            case "打八折":
                CashRebate cashRebate = new CashRebate();
                cashRebate.setMoneyRebate(0.8);
                cashSuper = cashRebate;
                break;
        }
    }
    
    public double GetResult(double money){
        return cashSuper.acceptCash(money);
    }
}