每次写博客都不知道要怎么引入要写的主题，挺头疼的一件事。今天就直接开门见山，今天要学的就是工厂模式，工厂就是批量生产制造东西的地方。在这里，工厂就是批量生产对象的地方。
学习书上的例子
假如你现在有一个披萨店PizzaStore，店里有各种各样的pizza，现在你需要根据订单生产pizza，可能会这样做
public Pizza orderPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese"))
pizza = new CheesePizza();
else
pizza = new GreekPizza();
}
将具体需要哪种pizza直接放在orderPizza方法中，那需要增加新的pizza呢……好吧，这里先跳过，先看一下如果使用简单工厂要怎么做。（书上说简单工厂不算一个“真正的”模式，更像一种编程习惯，好吧，这个我们就不纠结了）需要一个专门生产pizza的类SimplePizzaFactory,把生产pizza的任务就交给它了，就像这样：
/**
* 专门生产pizza的工厂
*/
public class SimplePizzaFactory {
public static Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese"))
pizza = new CheesePizza();
else
pizza = new GreekPizza();
return pizza;
}
}
好了，得到了想要的pizza，现在接着完成pizza的订单，还需要这样的几个步骤：准备prepare(), 烘烤bake(), 切片cut(), 装盒box(). 这几个方法对所有pizza都是一样的， 所以需要一个pizza的抽象类，这几个方法可以直接在这个抽象类中实现
public abstract class Pizza {
public void prepare() {
System.out.println("prepare");
description();
}
public void bake() {
System.out.println("bake");
}
public void cut() {
System.out.println("cut");
}
public void box() {
System.out.println("box");
}
public abstract void description();//描述pizza
}
具体的pizza（如cheesePizza）继承这个Pizza这个类，在description方法中添加自己的描述
public class CheesePizza extends Pizza {
@Override
public void description() {
System.out.println("default NY Cheese Pizza");
}
}
其他的我就不写了，现在可以用工厂生产pizza了，这时候orderPizza方法大概就是这样的
public class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza = SimplePizzaFactory.createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
你可能会问，这不就是把问题从一个地方搬到了另一个地方吗，问题依然存在啊。是的，我开始也是这样想的，但是仔细想想，这样还是有好处的，如果说其他的类中也需要生产pizza呢？难道你还要在把生产pizza的代码写一遍？用书上表达意思就是简单工厂SimplePizzaFactory的客户可能还有其他的，就是说在其他的类中也需要生产pizza。所以说需要依据具体情况创建对象时简单工厂是一个好的选择。
书上把工厂模式分成了3类（我这里把简单工厂也当作一类），分别是简单工厂，工厂方法和抽象工厂，简单工厂上面已经介绍了，然后看一下工厂方法和抽象工厂
工厂方法
现在pizza店的生意比较好，准备开加盟店了，在纽约和芝加哥等地方开一些加盟店，就有了NYPizzaStore和ChicagoPizzaStore等，可是由于地域差异造成了人们的口味也不同，就是说同一种pizza的风味都不一样，比如纽约的cheesePizza的饼要厚一些，而芝加哥的cheesePizza的饼要薄一些。这样就不能使用简单工厂呢？先不作回答，接着往下看，由于各个地方的pizza的风味不一样，所以让他们自己制造自己的pizza，就在PizzaStore中写一个抽象的制作pizza的方法
public abstract Pizza createPizza(String type);
然后在orderPizza中调用这个方法就可以得到想要的pizza，原来的简单工厂就可以替换为
Pizza pizza = createPizza(type);
具体的pizza店（如NYPizzaStore和ChiragoPizzaStore）继承自抽象的pizza店PizzaStore，然后实现各自制作pizza的方法createPizza，比如像这样
NYPizzaStore
//默认为纽约风味的pizza
@Override
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese"))
pizza = new CheesePizza();
else
pizza = new GreekPizza();
return pizza;
}
ChiragoPizzaStore
@Override
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new ChicagoCheesePizza();
}
else
pizza = new ChicagoGreekPizza();
return pizza;
}
可以测试一下
ChicagoPizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
chicagoPizzaStore.orderPizza("cheese");
可以看到，不同pizza店生产不同的pizza，都是依靠public abstract Pizza createPizza(String type);这个方法，能够生产不同的pizza，就像一个工厂一样。所以把这个方法称为工厂方法。工厂方法都是要返回一个具体的产品的。
工厂方法模式的定义
定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法把类的实例化推迟到子类。
还没有完，可以看到，2个具体的pizza店都是负责创建pizza的，于是我就想能不能把这2个pizza店创建pizza的动作交给一个简单工厂来处理，就像这样
public class NoSimplePizzaFactory {
//通过pizza店clazz来区分地域
public static Pizza createPizza(Class<? extends PizzaStore> clazz, String type) {
if (clazz == null)
throw new NullPointerException("address不能为空");
if (StringUtils.isNullOrEmpty(type))
throw new NullPointerException("type不能为空");
if (clazz.getSimpleName().equals(NYPizzaStore.class.getSimpleName())) {
if (type.equals("cheese"))
return new CheesePizza();
else
return new GreekPizza();
} else if (clazz.getSimpleName().equals(ChicagoPizzaStore.class.getSimpleName())) {
if (type.equals("cheese"))
return new ChicagoCheesePizza();
else
return new ChicagoGreekPizza();
} else
return null;
}
}
于是在具体的pizza店中调用制作pizza的方法就可以得到pizza了
NoSimplePizzaFactory.createPizza(getClass(), type);
再来看一下刚才提出的问题：能不能在抽象类PizzaStore中使用简单工厂来制作各地区不同的pizza？答案是可以的，因为我们现在有了一个简单工厂NoSimplePizzaFactory（简单工厂不简单啊），它可以生产各地区不同的pizza。所以来一个重载的orderPizza方法或把原来的orderPizza方法修改一下，就像这样
public Pizza orderPizza(Class<? extends PizzaStore> clazz, String type) {
Pizza pizza = NoSimplePizzaFactory.createPizza(clazz, type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
这样就可以制作不同地区不同的pizza了。
现在pizza店的生意越来越好了，随机而来的问题是制作pizza的原料供不应求，而且各个地区的pizza所用的原料还可能不同，如图
为了解决原料供不应求和各地制作pizza所用原料不同的问题，我们可以在每个地区都建一座原料工厂。来供应本地区pizza店所需要的原料。新建一个抽象的原料工厂PizzaIngredientFactory，里面有制造原料的方法，比如：
Dough createDough();
Sauce createSauce();
这个工厂是一个接口，然后2个具体的原料工厂ChicagoPizzaIngredientFactory和NYPizaaIngredientFactory实现它，不同的工厂制作不同的原料，
ChicagoPizzaIngredientFactory
@Override
public Dough createDough() {
return new ChicagoDough();
} @Override
public Sauce createSauce() {
return new ChicagoSauce();
}
NYPizaaIngredientFactory
@Override
public Dough createDough() {
return new NYDough();
} @Override
public Sauce createSauce() {
return new NYSauce();
}
现在在pizza中加入这些原料，也就是在Pizza类中加入原料属性
Dough dough; //面团
Sauce sauce; //酱料
大家还可以自己添加其他的原料属性，这些原料是工厂生产的，所以把工厂也放在Pizza类中
private PizzaIngredientFactory ingredientFactory;
public Pizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
然后在具体的pizza中添加对应的构造方法，然后在准备prepare阶段生产原料，所以prepare方法修改一下
public void prepare() {
System.out.println("prepare");
description();
if (ingredientFactory != null) {
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
System.out.println(dough.getName());
System.out.println(sauce.getName());
}
}
然后在简单工厂NoSimplePizzaFactory中就可以使用原料工厂了，然后在该类中引入原料工厂
private static PizzaIngredientFactory chicagoPizzaIngredientFactory = new ChicagoPizzaIngredientFactory();
private static PizzaIngredientFactory nyPizaaIngredientFactory = new NYPizaaIngredientFactory();
然后创建pizza是注入工厂，修改其中的即可
if (clazz.getSimpleName().equals(NYPizzaStore.class.getSimpleName())) {
if (type.equals("cheese"))
return new CheesePizza();
else
return new GreekPizza(nyPizaaIngredientFactory);
测试一下，你会发现可以通过工厂获得不同的pizza。本例只为说明工厂模式，所以还有不足之处，例如，一旦确定了pizza的区域和种类，通过orderPizza方法得到的pizza就是确定的，并不能在动态的改变制作pizza的原料，我的思路：只要控制原料工厂就可以在制作pizza时动态的改变原料。
从本例可以看到，pizza原料工厂就是一个抽象工厂
抽象工厂模式的定义
提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
工厂方法是不是潜伏在抽象工厂里面
可以看到PizzaIngredientFactory接口中有2个制造原料的抽象方法，这2个方法的作用是生产原料，所以这2个是工厂方法。
小结
简单工厂专职创建对象
工厂方法是一个生产产品的抽象方法，具体生产什么产品由具体的子类决定
抽象工厂用于制造产品的“家族”，具体产品家族由具体工厂决定，抽象工厂里的方法通常是工厂方法