一、商城收银模拟
商城收银系统
代码实现
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();
}
}
简单工厂模式的问题
这个模式只解决了对象的创建问题，而且由于工厂本身包含了所有的收费方式，而商城又经常更改打折额度和返利额度，那么
。这是很糟糕的处理方式。面对算法的经常变动，应该有更好的处理方式。
策略模式（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");
}
问题
每次有新逻辑又得需要改客户端代码，又回到归了第二版本的代码的弊病。这样子跟直接调用父类引用指向子类实现没什么区别。而且还多个累赘：上下文。
策略模式 ➕ 工厂模式
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()，
策略模式解析
。。。。
待改进之处：
策略模式依然不够完美，因为在Context中依然使用了switch分支结构，当有新需求变动的时候，依然需要改动Context类。
