学会了简单工厂，可以做好多事情了，很多地方都有它的影子，不过仅仅是简单工厂是不够用的。这不需求来了：
商场收银软件 根据客户购买的商品的单价和数量 向客户收费
在我们学习设计模式的时候我们会这么写：
public class Cashier {
public static double doCash(ArrayList<Commodity> commodityArrayList,String activity) {
double all_number = 0;
for (Commodity item : commodityArrayList) {
all_number += item.getPrice() * item.getNumbet();
}
}
return all_number;
}
}
public class Commodity {
private String name;
private double price;
private int numbet;
public Commodity(String name, double price, int numbet) {
this.name = name;
this.price = price;
this.numbet = numbet;
}
@Override
public String toString() {
return "Commodity{" +
"name='" + name + '\'' +
", price=" + price +
", numbet=" + numbet +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getNumbet() {
return numbet;
}
public void setNumbet(int numbet) {
this.numbet = numbet;
}
}
public class main {
/**
* 需求：商场收银软件 根据客户购买的商品的单价和数量 向客户收费
*
*/
public static void main(String[] args) {
Commodity commodity1 = new Commodity("苹果", 2.5, 1);
Commodity commodity2 = new Commodity("果汁", 5, 2);
Commodity commodity3 = new Commodity("蓝莓", 15, 3);
Commodity commodity4 = new Commodity("方便面", 1.5, 4);
Commodity commodity5 = new Commodity("铅笔", 0.5, 5);
ArrayList<Commodity> commodityArrayList = new ArrayList<>();
commodityArrayList.add(commodity1);
commodityArrayList.add(commodity2);
commodityArrayList.add(commodity3);
commodityArrayList.add(commodity4);
commodityArrayList.add(commodity5);
Double all_number = Cashier.doCash(commodityArrayList);
System.out.println("all:" + all_number);
}
}
但是吧，产品经理和项目经历永远是我们的敌人，这不又说：
增加打折功能
一句mmp，不能早说吗？我代码都写好了，又要改，改就改~~
五分钟就改好了：
public class Cashier {
public static double doCash(ArrayList<Commodity> commodityArrayList,String activity) {
double all_number = 0;
for (Commodity item : commodityArrayList) {
all_number += item.getPrice() * item.getNumbet();
}
switch (activity){
case "5折":
all_number = all_number*0.5;
break;
case "6折":
all_number = all_number*0.6;
break;
case "7折":
all_number = all_number*0.7;
break;
case "8折":
all_number = all_number*0.8;
break;
case "9折":
all_number = all_number*0.9;
break;
}
return all_number;
}
}
public class main {
/**
* 原始需求：商场收银软件 根据客户购买的商品的单价和数量 向客户收费
* 增加： 1、增加打折
*/
public static void main(String[] args) {
Commodity commodity1 = new Commodity("苹果", 2.5, 1);
Commodity commodity2 = new Commodity("果汁", 5, 2);
Commodity commodity3 = new Commodity("蓝莓", 15, 3);
Commodity commodity4 = new Commodity("方便面", 1.5, 4);
Commodity commodity5 = new Commodity("铅笔", 0.5, 5);
ArrayList<Commodity> commodityArrayList = new ArrayList<>();
commodityArrayList.add(commodity1);
commodityArrayList.add(commodity2);
commodityArrayList.add(commodity3);
commodityArrayList.add(commodity4);
commodityArrayList.add(commodity5);
Double all_number = Cashier.doCash(commodityArrayList,"5折");
System.out.println("all:" + all_number);
}
}
不错吧，什么又要加功能？
要满100返20~~~~~~
一百句mmp，这个就不好改了啊，再改这个里面的逻辑复杂了很容易出错啊，万一哪天又要加功能怎么办？好吧，我用简单工厂模式还不行吗？具体代码大家参照上一篇来写，相信大家会发现，确实比现在要好很多了，各个收费类分明，容易增加扩展。
但是这个例子和上一篇的例子不太一样，这一篇更加侧重于算法的改变，而不是收费类的改变，因为超市活动很多，更改很频繁，简单工厂模式只是更改对象的创建问题，并没有从根本上解决算法的多样性，这就需要引入策略模式了~~
策略模式：（Strategy）它定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。
每次要用设计模式来写程序的时候，建议大家先画一个UML图，这样能够更清晰的了解到我们要如何去做，更方便我们看到设计模式之间的不同和优劣。
image.png
public abstract class Strategy {
//算法方法
public abstract void AlgorithmInterface();
}
public class ConcreteStrategyA extends Strategy {
@Override
public void AlgorithmInterface() {
System.out.println("算法A实现");
}
}
public class ConcreteStrategyA extends Strategy {
@Override
public void AlgorithmInterface() {
System.out.println("算法A实现");
}
}
public class ConcreteStrategyC extends Strategy {
@Override
public void AlgorithmInterface() {
System.out.println("算法C实现");
}
}
public class Context {
Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void ContextInterface(){
strategy.AlgorithmInterface();
}
}
public static void main(String[] args) {
Context context;
String type = "";
switch (type){
case "正常收费":
context = new Context(new ConcreteStrategyA());
context.ContextInterface();
break;
case "打八折":
context = new Context(new ConcreteStrategyB());
context.ContextInterface();
break;
case "满100返20":
context = new Context(new ConcreteStrategy());
context.ContextInterface();
break;
}
}
}
这是个通用的代码，具体详细的代码大家可以自己写写，这样其实我们会发现和简单工厂的区别：
//简单工厂
Algorithm algorithm = AlgorithmFactory.createAlgorithm('/');
//策略模式
context = new Context(new ConcreteStrategyA());
他们侧重点不同：但是能不能把两者结合一下呢？这样写暴露出的东西太多，我想让用户在不知情的情况就把事情做了。
我们可以重写一下Context方法。
public class Context {
Strategy strategy;
public Context(String type) {
switch (type){
case "正常收费":
strategy = new ConcreteStrategyA();
break;
case "打八折":
strategy = new ConcreteStrategyB();
break;
case "满100返20":
strategy = new ConcreteStrategyC();
break;
}
this.strategy = strategy;
}
public void ContextInterface(){
strategy.AlgorithmInterface();
}
}
public static void main(String[] args) {
Context context;
String type = "";
context = new Context(type);
context.ContextInterface();
}
这样完全只暴露出一个Context，算法和客户端彻底分离。
最后我们发现我们还是没有解决switch的问题，再以后讲解抽象工厂模式的时候会利用反射解决这个问题。
