2.策略模式

---

一、场景描述

请实现一个商场的收银程序，根据客户购买商品的单价和数量，计算出多少钱（可能还有有各种促销活动）

二、版本1.0

前面我们学习了简单工程模式，我们就先用简单工程模式来实现这个问题

结构图

代码

/**
 * 现金收费抽象类
 */
public abstract class CashSuper {
    public abstract double acceptCash(double money);
}

/**
 * 正常收费
 */
public class CashNormal extends CashSuper{
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

/**
 * 打折收费
 */
public class CashRebate extends CashSuper{

    private double moneyRebate = 1d;

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

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

/**
 * 返利收费
 */
public 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) {
            result = money - moneyReturn;
        }
        return result;
    }
}

/**
 * 收费工厂类
 */
public class CashFactory {

    public static CashSuper createAcceptCash(String type) {
        CashSuper cashSuper = null;
        switch (type) {
            case "正常收费":
                cashSuper = new CashNormal();
                break;
            case "满300返100":
                cashSuper = new CashReturn(300,100);
                break;
            case "打8折":
                cashSuper = new CashRebate(0.8);
                break;
        }
        return cashSuper;
    }
}

//客户端简略代码
CashSuper cashSuper = CashFactory.createAcceptCash("收费方式");
double totalPrices = cashSuper.acceptCash(1000);

然后客户端就是提供三种收费方式给用户选择，然后将收费方式传入给工厂，由工厂帮忙创建对应的收费实现类即可

上面使用的简单工厂模式其实主要是解决对象的创建问题，但是我们这里的收费方式会经常的变动，每次维护或者扩展收费方式都要改动工厂类，然后重新编译部署，这样有点不太好，面对这种算法经常变动，有另外一种设计模式，就是策略模式。

三.策略模式版本

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

这个场景的收费方式其实就是一种算法，用工厂来生成算法对象，这没有错，但是算法本身是一种策略，最重要的是这些算法是随时都可能互相替换的，这就是变化点，而封装变化点是我们面向对象的一种很重要的思维方式，下面我们就来看看策略模式的UML图和代码吧。

UML图

代码

在上面的简单工厂模式版本中，CashSuper其实就是UML图中的抽象策略，而正常收费CashNormal、打折收费CashRebate和返利收费CashReturn就是三个具体策略，也就是策略模式中说的具体算法，这个时候我们只需要添加一个Context类，用来维护策略，然后再修改一下客户端的代码即可。

/**
 * 策略配置类
 */
public class CashContext {

    private CashSuper cashSuper;

    public CashContext(String type) {
        switch (type) {
            case "正常收费":
                cashSuper = new CashNormal();
                break;
            case "满300返100":
                cashSuper = new CashReturn(300,100);
                break;
            case "打8折":
                cashSuper = new CashRebate(0.8);
                break;
        }
    }

    public double getResult(double money) {
        return cashSuper.acceptCash(money);
    }
}

//客户端简略代码
CashContext context = new CashContext("收费方式");
double totalPrices = context.getResult(1000);

总结

看了上面策略方式的实现后，可能会有人觉得和简单工厂没什么区别，只是把工厂换成了策略，但是我们可以观察一下客户端的代码，简单工厂模式的客户端代码需要实例化两个类，CashSuper和CashFactory，而策略模式只需要实例化CashContexst即可，这样让客户端的代码和实际的业务耦合度更加低了。