【设计模式】策略模式——以商场促销为例
本文内容参考自《大话设计模式》（程杰 著）
注：以下代码为java实现
版本1
需求：
做一个商场收银软件，营业员根据客户所购买商品的单价和数量，向客户收费。
关键代码：
public class Cash
{
private double total = 0;
public void submit(int num, double price)
{
double totalPrices = num * price;
total += totalPrices;
System.out.println("单价:" + price + " 数量:" + num + "合计:" + totalPrices);
}
public double getTotal()
{
return total;
}
public void setTotal(double total)
{
this.total = total;
}
}版本2
需求：
增加打折功能
思路1：修改代码，比如打7折，则total *= 0.7；
评价：如果取消打折，或者修改折扣，需要频繁修改代码，不推荐。
思路2：增加折扣选项，关键代码如下：
public class Cash
{
private double total = 0;
private int selectedIndex = 0;
public void selectFormLoad()
{
String[] selectForm = { "正常收费", "打8折", "打7折", "打5折" };
selectedIndex = 0;
}
public void submit(int num, double price)
{
double totalPrices = 0;
switch (selectedIndex)
{
case 0:
totalPrices = num * price;
break;
case 1:
totalPrices = num * price * 0.8;
break;
case 2:
totalPrices = num * price * 0.7;
break;
case 3:
totalPrices = num * price * 0.5;
break;
}
total += totalPrices;
System.out.println("单价:" + price + " 数量:" + num + "合计:" + totalPrices);
}
public double getTotal()
{
return total;
}
public void setTotal(double total)
{
this.total = total;
}
public int getSelectedIndex()
{
return selectedIndex;
}
public void setSelectedIndex(int selectedIndex)
{
this.selectedIndex = selectedIndex;
}
}
问题：重复的代码太多，而且选项少，可变性不高！
版本3
需求：
可以灵活修改折扣，并且可以返利
//现金收费接口
public interface CashSuper
{
public double acceptCash(double money);
}
//正常收费子类
public class CashNormal implements CashSuper
{
public double acceptCash(double money)
{
return money;
}
}
//打折收费子类
public class CashRebate implements CashSuper
{
private double moneyRebate = 1;
public CashRebate(double moneyRebate)
{
this.moneyRebate = moneyRebate;
}
public double acceptCash(double money)
{
return money * moneyRebate;
}
}
//返利收费子类
public class CashReturn implements CashSuper
{
private double moneyCondition = 0;
private double moneyReturn = 0;
public CashReturn(double moneyCondition, double moneyReturn)
{
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
public double acceptCash(double money)
{
double result = money;
if (money >= moneyCondition)
{
result = money - money / moneyCondition * moneyReturn;
}
return result;
}
}
//现金收费工厂类
public class CashFactory
{
public static CashSuper createCash(String type)
{
CashSuper cs = null;
if ("正常收费".equals(type))
{
cs = new CashNormal();
}
else if ("满300返100".equals(type))
{
cs = new CashReturn(300, 100);
}
else if ("打8折".equals(type))
{
cs = new CashRebate(0.8);
}
return cs;
}
}
//客户端代码
public class Main
{
private static double total = 0;
public static void main(String[] args)
{
consume("正常收费", 1, 1000);
consume("满300返100", 1, 1000);
consume("打8折", 1, 1000);
System.out.println("总计:" + total);
}
public static void consume(String type, int num, double price)
{
CashSuper csuper = CashFactory.createCash(type);
double totalPrices = 0;
totalPrices = csuper.acceptCash(num * price);
total += totalPrices;
System.out.println("单价:" + price + " 数量:" + num + "合计:" + totalPrices);
}
}以上代码进行了抽象封装，并使用了简单的工厂类，灵活性高了很多。
问题：简单工厂模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场是可能经常性地更改打折额度和返利额度的，每次维护或扩展收费方式都要改动这个工厂，以致代码需要重新编译部署，这是非常糟糕的处理方式，所以用它不是最好的办法。面对算法的时常变动，我们可以使用策略模式！
版本4
需求：
可以经常性地更改打折额度和返利额度，而且要维护成本较低。
策略模式（Strategy）：
它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
商场收银时，如何促销，用打折还是返利，其实都是一些算法，最重要的是这些算法是随时都可能互相替换的，就这点变化，而封装变化点是我们面向对象的一种很重要的思维方式。我们来看看策略模式的结构图和基本代码：
//Strategy类，定义所有支持的算法的公共接口
public interface Strategy
{
public void algorithmInterface();
}
//ConcreteStrategy封装了具体的算法或行为，继承于Strategy
public class ConcreteStrategyA implements Strategy
{
public void algorithmInterface()
{
System.out.println("算法A实现");
}
}
public class ConcreteStrategyB implements Strategy
{
public void algorithmInterface()
{
System.out.println("算法A实现");
}
}
public class ConcreteStrategyC implements Strategy
{
public void algorithmInterface()
{
System.out.println("算法C实现");
}
}
//Context用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用
public class Context
{
private Strategy strategy;
public Context(Strategy strategy)
{
this.strategy = strategy;
}
public void contextInterface()
{
strategy.algorithmInterface();
}
}
//客户端代码
public class Main
{
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();
}
}所以我们的可以进行以下修改：
//CashContext类
public class CashContext
{
CashSuper cashSuper;
public CashContext(CashSuper cashSuper)
{
this.cashSuper = cashSuper;
}
public double acceptCash(double money)
{
return cashSuper.acceptCash(money);
}
}
//客户端代码
public class Main
{
private static double total = 0;
public static void main(String[] args)
{
consume("正常收费", 1, 1000);
consume("满300返100", 1, 1000);
consume("打8折", 1, 1000);
System.out.println("总计:" + total);
}
public static void consume(String type, int num, double price)
{
CashContext cashContext = null;
if ("正常收费".equals(type))
{
cashContext = new CashContext(new CashNormal());
}
else if ("满300返100".equals(type))
{
cashContext = new CashContext(new CashReturn(300, 100));
}
else if ("打8折".equals(type))
{
cashContext = new CashContext(new CashRebate(0.8));
}
double totalPrices = cashContext.acceptCash(num * price);
total += totalPrices;
System.out.println("单价:" + price + " 数量:" + num + "合计:" + totalPrices);
}
}问题：缺乏工厂模式的优势，在客户端要进行判断。
版本5
将策略模式与简单工厂模式结合起来：
//改造后的CashContext
public class CashContext
{
CashSuper cashSuper;
public CashContext(CashSuper cashSuper)
{
this.cashSuper = cashSuper;
}
public CashContext(String type)
{
if ("正常收费".equals(type))
{
cashSuper = new CashNormal();
}
else if ("满300返100".equals(type))
{
cashSuper = new CashReturn(300, 100);
}
else if ("打8折".equals(type))
{
cashSuper = new CashRebate(0.8);
}
}
public double acceptCash(double money)
{
return cashSuper.acceptCash(money);
}
}
//客户端代码
public class Main
{
private static double total = 0;
public static void main(String[] args)
{
consume("正常收费", 1, 1000);
consume("满300返100", 1, 1000);
consume("打8折", 1, 1000);
System.out.println("总计:" + total);
}
public static void consume(String type, int num, double price)
{
CashContext cashContext = new CashContext(type);
double totalPrices = cashContext.acceptCash(num * price);
total += totalPrices;
System.out.println("单价:" + price + " 数量:" + num + "合计:" + totalPrices);
}
}简单工厂 和 策略模式+简单工厂 的对比
客户端代码：
//简单工厂模式的用法
CashSuper csuper = CashFactory.createCash(type);
...
totalPrices = csuper.acceptCash(num * price);
//策略模式与简单工厂模式结合的用法
CashContext cashContext = new CashContext(type);
double totalPrices = cashContext.acceptCash(num * price);简单工厂模式需要让客户端认识两个类，CashSuper和CashFactory，而策略模式与简单工厂模式结合的用法，客户端就只需要认识一个类CashContext。耦合度更加降低。
我们在客户端实例化的是CashContext的对象，调用的是CashContext的方法，这使得具体的收费算法彻底地与客户端分离。连算法的父类CashSuper都不让客户端认识了。相当于创建了一个句柄类。
总结
策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法与使用算法之间的耦合。
另外，它简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
遗留问题：如果我们需要增加一种算法，比如满200返50，你就必须要改CashContext中的if或switch代码，有没有更低的维护成本？
（使用反射）