一、商场收银软件
营业员根据客户所购商品的单价和数量，向客户收费。用确定按钮来算出每种商品的费用，列表框来记录商品清单，并记录总计金额。
变更1：商场对商品搞活动，所有的商品打八折。
变更2：商场的活动加大，满300元返100元的促销活动。
变更3：所有的商品打五折，同时满300元返100元。
二、简单工厂实现
面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。比如，打一折和打九折只是形式的不同，抽象分析出来，所有的打折算法都是一样的，所以打折算法应该是一个类。
// 现金收费抽象类
// 也是Strategy类，定义所有支持的算法的公共接口
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 discount = 1.0d;
public CashRebate(double discount) {
this.discount = discount;
}
@Override
public double acceptCash(double money) {
return money * discount;
}
}// 返利收费子类
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 - Math.floor(money / moneyCondition) * moneyReturn;
}
return result;
}
}// 现金收费工厂类
public class CashFactory {
public static CashSuper createCashAccept(String type) {
CashSuper cs = null;
switch (type) {
case "正常收费":
cs = new CashNormal();
break;
case "打8折":
cs = new CashRebate(.8);
break;
case "满300返回100":
cs = new CashReturn(300, 100);
break;
default:
break;
}
return cs;
}
}// 简单工厂模式客户端
public class RunMain {
public static void main(String[] args) {
double totalPrices = 0.0d;
double prices = 0.0d;
int number = 10;
double unitPrice = 80;
CashSuper cashAcceptor = CashFactory.createCashAccept("正常收费");
// cashAcceptor = CashFactory.createCashAccept("打8折");
// cashAcceptor = CashFactory.createCashAccept("满300返回100");
prices = cashAcceptor.acceptCash(number * unitPrice);
totalPrices += prices;
System.out.println("单价：" + unitPrice + " 数量：" + number + " 合计：" + prices);
System.out.println("汇总：" + totalPrices);
}
}三、策略模式
定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。
// Cash上下文，用来维护一个对Strategy对象的引用
public class CashContext {
private CashSuper cs = null;
// 初始化时，传入具体的策略对象
public CashContext(CashSuper cs) {
this.cs = cs;
}
// 根据具体的策略对象，调用其算法的方法
public double contextInterface(double money){
return cs.acceptCash(money);
}
}// 策略模式客户端
public class RunMain {
public static void main(String[] args) {
double totalPrices = 0.0d;
double prices = 0.0d;
int number = 10;
double unitPrice = 80;
CashContext cc = new CashContext(new CashNormal());
// cc = new CashContext(new CashRebate(.8));
// cc = new CashContext( new CashReturn(300, 100));
prices = cc.contextInterface(number * unitPrice);
totalPrices += prices;
System.out.println("单价：" + unitPrice + " 数量：" + number + " 合计：" + prices);
System.out.println("汇总：" + totalPrices);
}
}四、策略与简单工厂模式结合
简单工厂模式需要让客户端认识两个类，CashSuper和CashFactory，而策略与简单工厂模式结合的用法，客户端只需要认识一个类CashContext即可，耦合更低。同时客户端实例化的是CashContext的对象，调用的是CashContext的方法，这使得具体的收费算法彻底地与客户端分离。
// Cash上下文
public class CashContext {
private CashSuper cs = null;
//将实例化具体策略的过程由客户端转移到Context类中，简单工厂模式的应用
public CashContext(String type) {
switch (type) {
case "正常收费":
cs = new CashNormal();
break;
case "打8折":
cs = new CashRebate(.8);
break;
case "满300返回100":
cs = new CashReturn(300, 100);
break;
default:
break;
}
}
// 根据具体的策略对象，调用其算法的方法
public double contextInterface(double money){
return cs.acceptCash(money);
}
}// 策略与简单工厂模式结合客户端
public class RunMain {
public static void main(String[] args) {
double totalPrices = 0.0d;
double prices = 0.0d;
int number = 10;
double unitPrice = 80;
CashContext context = new CashContext("正常收费");
// CashContext context = new CashContext("打8折");
// CashContext context = new CashContext("满300返回100");
prices = context.contextInterface(number * unitPrice);
totalPrices += prices;
System.out.println("单价：" + unitPrice + " 数量：" + number + " 合计：" + prices);
System.out.println("汇总：" + totalPrices);
}
}