开篇
天天逛博客园，就是狠不下心来写篇博客，忙是一方面，但是说忙能有多忙呢，都有时间逛博客园，写篇博客的时间都没有？（这还真不好说）
每次想到写一篇新的设计模式，我总会问自己：
1，自己理解了吗？
2，我能以一种简单且有逻辑的方式把它说出来吗？
不说做到有的放矢，但是一本正经的胡说八道还是要有吧，起码要忽悠得头头是道嘛（手动斜眼笑）
关于工厂模式的几个问题
1，这个是拿来干什么的？
2，怎么用？
3，不用行不行？
第一个和第三个问题，我现在就可以告诉你答案：早点下班，可以
所有的设计模式对我来说都是为了减少工作量。关于减少工作量我的理解是：每个需求，都应该在它适当的时候出现适当的代码！这个太重要了
代码偷懒，后期返工多
过度设计，后期返工多
设计模式+经验可以解决这个问题，其他的我还不知道。没有经验怎么办？两个要点：
1，能用
2，简洁
首先要达到能用，然后就是尽量简洁，这样代码就不会太差。首先你要自己看得懂，然后是让队友看得懂。
你知道你队友看到一堆烂的看都看不懂，也一句注释都没有的代码的时候的心理阴影面积吗？
这其实也没什么，谁没填过别人的坑呢？关键是他知道你家在哪里，而且还知道你经常走夜路，就问你怕不怕？（卧槽，又跑题了。。）
需求：你有一个披萨店，只卖一种披萨，代码如下：
披萨：
import java.util.ArrayList;
import java.util.List; /**
* 披萨类
* @author skysea
*/
public class Pizza { private String name;//披萨名称 private String dough;//面团 private String sauce;//酱料 private List<String> toppings = new ArrayList<>();//佐料 public Pizza() {
this.name = "原味披萨";
this.dough = "原味面团";
this.sauce = "原味酱料";
} void prepare() {
System.out.println("开始准备披萨：" + name); System.out.println("开始处理面团：" + dough); System.out.println("添加酱料：" + sauce); System.out.println("添加佐料：");
if(toppings.size() > 0) {
for(String t : toppings) {
System.out.println(" " + t);
}
}
} void bake() {
System.out.println("烘焙25分钟..");
} void cut() {
System.out.println("披萨切片..");
} void box() {
System.out.println("披萨打包..");
} public String getName() {
return name;
}
}
披萨店：
/**
* 只卖一种披萨的披萨店
* @author skysea
*/
public class PizzaStore { public Pizza orderPizza() {
Pizza pizza = new Pizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
测试类：
/**
* pizza测试类
* @author skysea
*/
public class PizzaTest {
public static void main(String[] args) {
PizzaStore pizzaStore = new PizzaStore();
Pizza pizza = pizzaStore.orderPizza();
System.out.println("当前预定的披萨：" + pizza.getName());
}
}
现在披萨店要拓展业务了，因为卖一种披萨顾客已经吃腻了，现在要开始添加新的披萨类型
简单工厂模式
Pizza类的改进
import java.util.ArrayList;
import java.util.List; /**
* 披萨抽象类
* 1,修改private -> protected（保证子类拥有这些属性）
* 2,将Pizza定义为abstract类，防止被new，也是为后面的改造做准备
* @author skysea
*/
public abstract class Pizza { protected String name;//披萨名称 protected String dough;//面团 protected String sauce;//酱料 protected List<String> toppings = new ArrayList<>();//佐料 void prepare() {
System.out.println("开始准备披萨：" + name); System.out.print("开始处理面团：" + dough); System.out.println("添加酱料：" + sauce); System.out.println("添加佐料：");
for(String t : toppings) {
System.out.println(" " + t);
}
} void bake() {
System.out.println("烘焙25分钟..");
} void cut() {
System.out.println("披萨切片..");
} void box() {
System.out.println("披萨打包..");
} public String getName() {
return name;
} @Override
public String toString() {
return "Pizza [name=" + name + ", dough=" + dough + ", sauce=" + sauce + ", toppings=" + toppings + "]";
}
}
先给出新增的披萨
芝士披萨：
/**
* 芝士披萨
* @author skysea
*/
public class CheesePizza extends Pizza{
public CheesePizza() {
this.name = "芝士披萨";
this.dough = "芝士披萨的面团";
this.sauce = "芝士披萨的酱料";
this.toppings.add("很多芝士....");
}
}
蛤蜊披萨:
/**
* 蛤蜊披萨
* @author skysea
*/
public class ClamPizza extends Pizza {
public ClamPizza() {
this.name = "蛤蜊披萨";
this.dough = "蛤蜊披萨的面团";
this.sauce = "蛤蜊披萨的酱料";
this.toppings.add("蛤蜊");
}
}
意大利烤肠披萨：
/**
* 意大利烤肠披萨
* @author skysea
*/
public class PepperoniPizza extends Pizza{ public PepperoniPizza() {
this.name = "意大利烤肠披萨";
this.dough = "意大利烤肠披萨的面团";
this.sauce = "意大利烤肠披萨的酱料";
this.toppings.add("一大波意大利烤肠...");
}
}
素食比萨：
/**
* 素食比萨
* @author skysea
*/
public class VeggiePizza extends Pizza {
public VeggiePizza() {
name = "素食比萨";
dough = "素食比萨的面团";
sauce = "素食比萨的酱料";
toppings.add("素食比萨");
toppings.add("素食比萨佐料1");
toppings.add("素食比萨佐料2");
}
}
贴了这么多代码，先给出一波简单的实现：
/**
* pizza店
* @author skysea
*/
public class PizzaStore { public Pizza orderPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
} else if (type.equals("clam")) {
pizza = new ClamPizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
} pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box(); return pizza;
} }
在不考虑继续扩展披萨种类的时候，这样的实现有没有问题，一般来说，达到了可以用的标准，但是不好用，问题如下：
1，没有兼容原来的一种披萨方法 public Pizza orderPizza()，相信我，每一个public方法都是很重要的，因为你不知道有多少地方用到过。当然也不是没办法知道，只是你知道也不一定就能改，就算你能改，也不一定改对。
2，String类型的type太容易出错了，个人感觉对程序开发不友好，当然这个也要分情况，灵活和严谨本来就很难做到两全
3，推荐取不到合适的type时抛异常，而不是返回空，便于排查问题(此处的if里面只是直接new返回的对象，实际情况远比现在的复杂)
给出第二版：
/**
* pizza店
* @author skysea
*/
public class PizzaStore { public Pizza orderPizza() {
return orderPizza(PizzaTypeEnum.CHEESE);
} public Pizza orderPizza(PizzaTypeEnum type) {
Pizza pizza; pizza = SimplePizzaFactory.getPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box(); return pizza;
}
}
SimplePizzaFactory：
/**
* 简单工厂类
* @author skysea
*/
public class SimplePizzaFactory { /**
* 根据类型获取pizza
* @param type
* @return
*/
public static final Pizza getPizza(PizzaTypeEnum type){
switch (type) {
case CHEESE: return new CheesePizza();
case CLAM: return new ClamPizza();
case PEPPERONI: return new PepperoniPizza();
case VEGGIE: return new VeggiePizza();
default: throw new NoSuchPizzaException(type.getCode());
}
}
}
辅助类（枚举，异常）:
/**
* 定义pizza类型枚举
* @author skysea
*
*/
public enum PizzaTypeEnum{
/**
* 芝士披萨
*/
CHEESE("cheese"),
/**
* 意大利烤肠披萨
*/
PEPPERONI("pepperoni"),
/**
* 蛤蜊披萨
*/
CLAM("clam"),
/**
* 素食比萨
*/
VEGGIE("veggie");
private final String code;
PizzaTypeEnum(String code) {
this.code = code;
}
public String getCode() {
return code;
}
}
/**
* 没有匹配的pizza异常
* @author skysea
*/
public class NoSuchPizzaException extends RuntimeException{
private static final long serialVersionUID = 6831396172306375611L;
public NoSuchPizzaException(String message) {
super(message);
}
}
测试类：
/**
* pizza测试类
* @author skysea
*/
public class PizzaTest { public static void main(String[] args) {
PizzaStore store = new PizzaStore(); Pizza pizza = store.orderPizza(PizzaTypeEnum.CHEESE);
System.out.println(pizza); pizza = store.orderPizza(PizzaTypeEnum.VEGGIE);
System.out.println(pizza);
}
}
好了，代码写到这里，其实对于：新增披萨类型的这个需求的实现其实已经很好了。至少来说现阶段的需求实现了，其次就是对调用方友好，至少队友不会跑过来问你类型传啥，不会告诉你他string字符串传错了，不会在你改个类型的时候，还要通知他（当然这个也可以通过常量来处理）。
吹了半天，来说说这段代码的问题，正常情况下，需求会是这样变：
1，PepperoniPizza暂时不要了，一般来说，你问他要不要，他会说，这个要看后面的运营情况（我：...）
2，你给我新加一个xx披萨
现在需要改的是两个地方，一个是工厂类，一个是枚举，但是主要的流程是不用改了，如果你觉得还是很麻烦在不考虑性能的情况下，你还可以用反射来玩，改造一下工厂类(实现通过class来创建对象)和枚举（添加一个字段来存放type对应的class）就可以了，不赘述..
第一波需求就差不多可以这样收手了，随着业务的发展，披萨店那叫一个红火啊，虽然中间也对代码做了很多新的披萨，但是由于PizzaStore相当稳定，也没出什么大问题。
新的问题（开分店）：
1，旗舰店在芝加哥，现在要在纽约开一家新的店
2，分店的披萨口味要根据当地的口味来进行调整，保证能够不失品牌特色的同时，也能满足当地独特的风味
3，分店披萨的种类与暂时与旗舰店保持一致
工厂方法模式
先把所有的披萨列出来
芝加哥的披萨：
/**
* 芝加哥芝士披萨
* @author skysea
*/
public class ChicagoStyleCheesePizza extends Pizza { public ChicagoStyleCheesePizza() {
name = "芝加哥芝士披萨";
dough = "芝加哥芝士披萨面团";
sauce = "芝加哥芝士披萨酱料"; toppings.add("芝加哥芝士披萨调料1");
toppings.add("芝加哥芝士披萨调料2");
} @Override
void cut() {
System.out.println("芝加哥芝士披萨版切片...");
}
}
/**
* 芝加哥蛤蜊披萨
* @author skysea
*/
public class ChicagoStyleClamPizza extends Pizza {
public ChicagoStyleClamPizza() {
name = "芝加哥蛤蜊披萨";
dough = "芝加哥蛤蜊披萨面团";
sauce = "芝加哥蛤蜊披萨酱料"; toppings.add("芝加哥蛤蜊披萨佐料1");
toppings.add("芝加哥蛤蜊披萨佐料2");
} @Override
void cut() {
System.out.println("芝加哥蛤蜊披萨版切片...");
}
}
/**
* 芝加哥意大利烤肠披萨
* @author skysea
*/
public class ChicagoStylePepperoniPizza extends Pizza {
public ChicagoStylePepperoniPizza() {
name = "芝加哥意大利烤肠披萨";
dough = "芝加哥意大利烤肠披萨面团";
sauce = "芝加哥意大利烤肠披萨酱料"; toppings.add("芝加哥意大利烤肠披萨调料1");
toppings.add("芝加哥意大利烤肠披萨调料2");
toppings.add("芝加哥意大利烤肠披萨调料3");
toppings.add("芝加哥意大利烤肠披萨调料4");
} @Override
void cut() {
System.out.println("芝加哥意大利烤肠披萨版切片...");
}
}
/**
* 芝加哥素食比萨
* @author skysea
*/
public class ChicagoStyleVeggiePizza extends Pizza {
public ChicagoStyleVeggiePizza() {
name = "芝加哥素食比萨";
dough = "芝加哥素食比萨的面团";
sauce = "芝加哥素食比萨的酱料"; toppings.add("芝加哥素食比萨调料1");
toppings.add("芝加哥素食比萨调料2");
toppings.add("芝加哥素食比萨调料3");
} void cut() {
System.out.println("芝加哥素食比萨版切片...");
}
}
纽约的披萨：
/**
* 纽约芝士披萨
* @author skysea
*/
public class NYStyleCheesePizza extends Pizza { public NYStyleCheesePizza() {
name = "纽约芝士披萨";
dough = "纽约芝士披萨面团";
sauce = "纽约芝士披萨酱料"; toppings.add("纽约芝士披萨调料1");
toppings.add("纽约芝士披萨调料2");
} @Override
void cut() {
System.out.println("纽约芝士披萨版切片...");
}
}
/**
* 纽约蛤蜊披萨
* @author skysea
*/
public class NYStyleClamPizza extends Pizza {
public NYStyleClamPizza() {
name = "纽约蛤蜊披萨";
dough = "纽约蛤蜊披萨面团";
sauce = "纽约蛤蜊披萨酱料"; toppings.add("纽约蛤蜊披萨佐料1");
toppings.add("纽约蛤蜊披萨佐料2");
} @Override
void cut() {
System.out.println("纽约蛤蜊披萨版切片...");
}
}
/**
* 纽约意大利烤肠披萨
* @author skysea
*/
public class NYStylePepperoniPizza extends Pizza {
public NYStylePepperoniPizza() {
name = "纽约意大利烤肠披萨";
dough = "纽约意大利烤肠披萨面团";
sauce = "纽约意大利烤肠披萨酱料"; toppings.add("纽约意大利烤肠披萨调料1");
toppings.add("纽约意大利烤肠披萨调料2");
toppings.add("纽约意大利烤肠披萨调料3");
toppings.add("纽约意大利烤肠披萨调料4");
} @Override
void cut() {
System.out.println("纽约意大利烤肠披萨版切片...");
}
}
/**
* 纽约素食比萨
* @author skysea
*/
public class NYStyleVeggiePizza extends Pizza {
public NYStyleVeggiePizza() {
name = "纽约素食比萨";
dough = "纽约素食比萨的面团";
sauce = "纽约素食比萨的酱料"; toppings.add("纽约素食比萨调料1");
toppings.add("纽约素食比萨调料2");
toppings.add("纽约素食比萨调料3");
} void cut() {
System.out.println("纽约素食比萨版切片...");
}
}
披萨倒是列完了，但是在实际的开发过程中，业务逻辑这么简单那是不可能的，想要改那什么旗舰店披萨的类名是很困难的
一般要考虑：
1，是不是单机，有没有其他外部系统在调用
2，改动原来的代码有什么好处，更容易理解吗？迭代了几个版本过后垃圾代码太多了吗？
3，影响大不大
当然，我这里是随便造，你们呢，我就不知道了，嘿嘿嘿，所以碰到这种情况，一般来说要悠着点，看时间，也要看影响，开发就是这样，同一个功能，2天有2天的做法，5天有5天的做法，10天有10天的做法
披萨店改造：
/**
* 披萨店抽象类
* @author skysea
*/
public abstract class PizzaStore { abstract Pizza createPizza(String item); public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
System.out.println("--- 制作 " + pizza.getName() + " ---");
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
/**
* 芝加哥披萨店
* @author skysea
*/
public class ChicagoPizzaStore extends PizzaStore {
public static final String CHEESE = "cheese";
public static final String VEGGIE = "veggie";
public static final String CLAM = "clam";
public static final String PEPPERONI = "pepperoni";
Pizza createPizza(String item) {
if (CHEESE.equals(item)) {
return new ChicagoStyleCheesePizza();
} else if (VEGGIE.equals(item)) {
return new ChicagoStyleVeggiePizza();
} else if (CLAM.equals(item)) {
return new ChicagoStyleClamPizza();
} else if (PEPPERONI.equals(item)) {
return new ChicagoStylePepperoniPizza();
} else {
throw new NoSuchPizzaException(item);
}
}
}
纽约披萨店（和芝加哥披萨店几乎一毛一样，这里就不展开了）：
/**
* 纽约披萨店
* @author skysea
*/
public class NYPizzaStore extends PizzaStore { public static final String CHEESE = "cheese";
public static final String VEGGIE = "veggie";
public static final String CLAM = "clam";
public static final String PEPPERONI = "pepperoni";
Pizza createPizza(String item) {
if (CHEESE.equals(item)) {
return new NYStyleCheesePizza();
} else if (VEGGIE.equals(item)) {
return new NYStyleVeggiePizza();
} else if (CLAM.equals(item)) {
return new NYStyleClamPizza();
} else if (PEPPERONI.equals(item)) {
return new NYStylePepperoniPizza();
} else {
throw new NoSuchPizzaException(item);
}
}
}
这段代码有三个问题要理解清楚：
1，这个地方为啥要弄个抽象类出来？
这个就要结合实际来理解了，分店与分店之间，需不需要统一规范化管理？需不需要保证自己的特色？答案毫无疑问，都是需要的
这个地方制作披萨的过程，毫无疑问是肯定要一致的。就像外卖一样，下单，炒菜，配送。整套流程都是这样，不能说你出来就开始炒菜了啊，这不科学。不一样的地方就是，你炒的什么菜，好不好吃。配送得快不快，稳不稳，服务好不好。
所以，抽象类的意义就是：规范、特色
2，factory咋个不见了？
因为把它和具体的store合并在一起了，这样又引申出另外一个问题：为啥要合并？因为store现在充当的角色就是facotry，刚才说过的制作过程已经放到父类中实现了，现在只需要在具体的store中去解决披萨的创建问题
3，为啥又不用枚举了，弄个String来创建pizza？
如果还是单机，用枚举当然会比直接扔个string来得稳当。
开了分店，要是每个分店都是一套完整的服务在玩，丢个string，要比枚举来得好。原因有2：传输过程中的序列化和反序列化、更加灵活（客户端不用每次都因为这个原因要去升级对应的包，特别是多个版本在跑得时候，升级了又会导致其他东西不能玩）
测试类：
/**
* 披萨测试类
* @author skysea
*/
public class PizzaTest { public static void main(String[] args) {
PizzaStore nyStore = new NYPizzaStore();
PizzaStore chicagoStore = new ChicagoPizzaStore(); Pizza pizza = nyStore.orderPizza(NYPizzaStore.CHEESE);
System.out.println("Ethan ordered a " + pizza.getName() + "\n"); pizza = chicagoStore.orderPizza(ChicagoPizzaStore.CHEESE);
System.out.println("Joel ordered a " + pizza.getName() + "\n"); pizza = nyStore.orderPizza(NYPizzaStore.CLAM);
System.out.println("Ethan ordered a " + pizza.getName() + "\n"); pizza = chicagoStore.orderPizza(ChicagoPizzaStore.CLAM);
System.out.println("Joel ordered a " + pizza.getName() + "\n"); pizza = nyStore.orderPizza(NYPizzaStore.PEPPERONI);
System.out.println("Ethan ordered a " + pizza.getName() + "\n"); pizza = chicagoStore.orderPizza(ChicagoPizzaStore.PEPPERONI);
System.out.println("Joel ordered a " + pizza.getName() + "\n"); pizza = nyStore.orderPizza(NYPizzaStore.VEGGIE);
System.out.println("Ethan ordered a " + pizza.getName() + "\n"); pizza = chicagoStore.orderPizza(ChicagoPizzaStore.VEGGIE);
System.out.println("Joel ordered a " + pizza.getName() + "\n");
}
}
结果（结果太多了，就不全部截图出来了）：
