本文章内容是看完《HeadFirst设计模式》书籍的工厂模式后为了加深印象而写。其实有的时候，某些博客并不是仅仅为了分享，更主要的是写给自己，主要是为了自己在写的过程去更加深刻去体会，光看看别人所说的，感觉挺有道理的，却没有转化成自己的东西，就更不会在实际的工作中去使用设计模式了。
言归正传，工厂模式分成3种，简单工厂模式、工厂方法模式、抽象工厂模式。这些模式都是通过接口和抽象进行解耦。
简单工厂模式：（为了偷懒，我也不会独自去想一个实际的场景，将那本书所用场景复述下来,纯手打）
订购一个披萨现状如下：
这个过程完成了太多的职责，披萨的生产过程、装配过程。一旦有新的披萨类型加进来就要修改这个函数。简单工厂模式就是把生产披萨的过程独立出去，使得职责划分的更加细致，更好的复用。所以建一个工厂类SimplePizzaFactory单独负责创建各种披萨，改变如下：
再回到订购披萨的函数中：
我们使用了SimplePizzaFactory 来创建披萨，任何地方都可以使用SimplePizzaFactory 来创建披萨，达到复用的效果，同时要新增一个披萨类型时，只需在SimplePizzaFactory 里修改即可。这就是简单工厂模式。看完后，可能你会不屑一顾，没什么特别之处吗？我没看到多大的优点，整体来说不就是把一段代码封装起来达到复用效果吗。我也感觉是这样
工厂方法模式：
上述的简单工厂模式的缺点也很明显，简单工厂模式就是一个大杂烩，把所有的披萨的创建全依靠if else判断来进行，一旦新增一个新的披萨类型，就要去改动if else判断。工厂方法模式就是对这种缺点的改进：
PizzaStore是一个抽象的披萨商店，负责为客户订购披萨，如下：
PizzaStore 根据客户传进来type类型，由它的子类来具体实现这一创建过程，PizzaStore 这一抽象类仅仅对披萨的prepare、bake、cut、bake等装配流程（相同的部分）进行封装。
protected abstract Pizza createPizza()方法就是工厂方法。新增一个披萨类型，只需继承PizzaStore实现抽象方法createPizza方法即可，不再关心披萨的装配流程。
此时实现订购的代码即为：
首先创建一个相应的披萨工厂，然后直接调用工厂的orderPizza即可获取对应的披萨。
这样的做法的确改变了简单工厂模式的大杂烩模式，新增一个披萨类，并不需要去改动以前的任何代码，只需创建一个对应的工厂，继承抽象的披萨工厂PizzaStore。然而这样也存在着一个缺点，每当新增一个新的披萨类型时，就需要新增一个对应的披萨工厂（也可以在已有的工厂中进行if else判断，但这样又会沦落为一个大杂烩），新增一个披萨类型，就要写披萨类和对应的工厂类，有人说不要工厂了，直接new一个披萨。这就说到了工厂和new的区别，其实工厂创建对象也是通过new来创建的，然而它的功能是对new出来的对象进行控制，控制对象的某些参数等等（我们的例子比较简单，工厂没有进行相应的控制）。
抽象工厂模式：
这种模式其实是另一种的使用场景即多件东西组合来合成一件东西。即工厂方法模式是用于生产一件产品，而抽象工厂模式则更适用于多件产品来组合。
如披萨的产生有多种原料来生成，所以构建这样一个抽象的原料工厂，披萨原料抽象工厂如下:
Salt、Sugar、Flour都是接口，都有不同的实现类。
上面仅仅是一个抽象的原料工厂，下面就需要实现这个工厂,北京披萨原料工厂，BeijingPizzaSourceFactory 如下：
北京披萨原料工厂都是生产的北京的盐、北京的糖、北京的面。同理上海的披萨原料工厂都生产上海的盐、上海的糖、上海的面。
有了披萨的原料工厂，来看看如何制作披萨：
这是一个抽象类，留出prepare()方法要求子类来实现，子类就需要通过原料工厂来实现：
BeijingPizza 需要接收一个原料工厂，在prepare()方法中不断的向原料工厂来获取原料，这些都是针对接口不是针对实现，披萨与原料之间实现解耦。
不同的披萨可以由不同的原料工厂来为它提供原料。
原料工厂提供原料的大致类图如下：
下面说说工厂方法和抽象工厂的区别：
1 抽象工厂内部的方法其实都是工厂方法，即工厂方法用于生产一个产品，而抽象工厂则用于生产一组产品。
2 工厂方法更多的用于继承基础类，抽象工厂则更多用于提供各种原料来组合创建一个产品。
言归正传，工厂模式分成3种，简单工厂模式、工厂方法模式、抽象工厂模式。这些模式都是通过接口和抽象进行解耦。
简单工厂模式：（为了偷懒，我也不会独自去想一个实际的场景，将那本书所用场景复述下来,纯手打）
订购一个披萨现状如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
Pizza orderPizza(String type){
Pizza pizza;
if
(type==
null
|| type.equals(
"cheese"
)){
pizza=
new
CheesePizza();
}
else
if
(type.equals(
"greek"
)){
pizza=
new
GreekPizza();
}
else
{
pizza=
new
PepperoniPizza();
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
return
pizza;
}
|
这个过程完成了太多的职责，披萨的生产过程、装配过程。一旦有新的披萨类型加进来就要修改这个函数。简单工厂模式就是把生产披萨的过程独立出去，使得职责划分的更加细致，更好的复用。所以建一个工厂类SimplePizzaFactory单独负责创建各种披萨，改变如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
class
SimplePizzaFactory {
public
Pizza createPizza(String type){
Pizza pizza;
if
(type==
null
|| type.equals(
"cheese"
)){
pizza=
new
CheesePizza();
}
else
if
(type.equals(
"greek"
)){
pizza=
new
GreekPizza();
}
else
{
pizza=
new
PepperoniPizza();
}
return
pizza;
}
}
|
再回到订购披萨的函数中：
|
1
2
3
4
5
6
7
8
9
10
11
|
public
static
Pizza orderPizza(String type){
SimplePizzaFactory factory=
new
SimplePizzaFactory();
Pizza pizza=factory.createPizza(
"cheese"
);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
return
pizza;
}
|
我们使用了SimplePizzaFactory 来创建披萨，任何地方都可以使用SimplePizzaFactory 来创建披萨，达到复用的效果，同时要新增一个披萨类型时，只需在SimplePizzaFactory 里修改即可。这就是简单工厂模式。看完后，可能你会不屑一顾，没什么特别之处吗？我没看到多大的优点，整体来说不就是把一段代码封装起来达到复用效果吗。我也感觉是这样
工厂方法模式：
上述的简单工厂模式的缺点也很明显，简单工厂模式就是一个大杂烩，把所有的披萨的创建全依靠if else判断来进行，一旦新增一个新的披萨类型，就要去改动if else判断。工厂方法模式就是对这种缺点的改进：
PizzaStore是一个抽象的披萨商店，负责为客户订购披萨，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
abstract
class
PizzaStore {
public
Pizza orderPizza(){
Pizza pizza=createPizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
return
pizza;
}
protected
abstract
Pizza createPizza();
}
|
PizzaStore 根据客户传进来type类型，由它的子类来具体实现这一创建过程，PizzaStore 这一抽象类仅仅对披萨的prepare、bake、cut、bake等装配流程（相同的部分）进行封装。
protected abstract Pizza createPizza()方法就是工厂方法。新增一个披萨类型，只需继承PizzaStore实现抽象方法createPizza方法即可，不再关心披萨的装配流程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public
class
CheesePizzaFactory
extends
PizzaStore{
@Override
protected
Pizza createPizza() {
return
new
CheesePizza();
}
}
public
class
GreekPizzaFactory
extends
PizzaStore{
@Override
protected
Pizza createPizza() {
return
new
GreekPizza();
}
}
|
此时实现订购的代码即为：
|
1
2
3
4
|
public
static
Pizza orderPizzaFactory(String type){
PizzaStore pizzaStore=
new
CheesePizzaFactory();
return
pizzaStore.orderPizza();
}
|
首先创建一个相应的披萨工厂，然后直接调用工厂的orderPizza即可获取对应的披萨。
这样的做法的确改变了简单工厂模式的大杂烩模式，新增一个披萨类，并不需要去改动以前的任何代码，只需创建一个对应的工厂，继承抽象的披萨工厂PizzaStore。然而这样也存在着一个缺点，每当新增一个新的披萨类型时，就需要新增一个对应的披萨工厂（也可以在已有的工厂中进行if else判断，但这样又会沦落为一个大杂烩），新增一个披萨类型，就要写披萨类和对应的工厂类，有人说不要工厂了，直接new一个披萨。这就说到了工厂和new的区别，其实工厂创建对象也是通过new来创建的，然而它的功能是对new出来的对象进行控制，控制对象的某些参数等等（我们的例子比较简单，工厂没有进行相应的控制）。
抽象工厂模式：
这种模式其实是另一种的使用场景即多件东西组合来合成一件东西。即工厂方法模式是用于生产一件产品，而抽象工厂模式则更适用于多件产品来组合。
如披萨的产生有多种原料来生成，所以构建这样一个抽象的原料工厂，披萨原料抽象工厂如下:
|
1
2
3
4
5
6
7
8
|
public
interface
PizzaSourceFactory {
public
Salt getSalt();
public
Sugar getSugar();
public
Flour getFlour();
}
|
Salt、Sugar、Flour都是接口，都有不同的实现类。
上面仅仅是一个抽象的原料工厂，下面就需要实现这个工厂,北京披萨原料工厂，BeijingPizzaSourceFactory 如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
class
BeijingPizzaSourceFactory
implements
PizzaSourceFactory{
@Override
public
Salt getSalt() {
return
new
BeijingSalt();
}
@Override
public
Sugar getSugar() {
return
new
BeijingSugar();
}
@Override
public
Flour getFlour() {
return
new
BeijingFlour();
}
}
|
北京披萨原料工厂都是生产的北京的盐、北京的糖、北京的面。同理上海的披萨原料工厂都生产上海的盐、上海的糖、上海的面。
有了披萨的原料工厂，来看看如何制作披萨：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public
abstract
class
NewPizza {
private
Salt salt;
private
Sugar sugar;
private
Flour flour;
protected
abstract
void
prepare();
public
void
bake(){
System.out.println(
"bake pizza"
);
}
public
void
cut(){
System.out.println(
"cut pizza"
);
}
public
void
box(){
System.out.println(
"box pizza"
);
}
}
|
这是一个抽象类，留出prepare()方法要求子类来实现，子类就需要通过原料工厂来实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
BeijingPizza
extends
NewPizza{
private
PizzaSourceFactory pizzaSourceFactory;
public
BeijingPizza(PizzaSourceFactory pizzaSourceFactory) {
super
();
this
.pizzaSourceFactory = pizzaSourceFactory;
}
@Override
protected
void
prepare() {
salt=pizzaSourceFactory.getSalt();
sugar=pizzaSourceFactory.getSugar();
flour=pizzaSourceFactory.getFlour();
}
}
|
BeijingPizza 需要接收一个原料工厂，在prepare()方法中不断的向原料工厂来获取原料，这些都是针对接口不是针对实现，披萨与原料之间实现解耦。
不同的披萨可以由不同的原料工厂来为它提供原料。
原料工厂提供原料的大致类图如下：
下面说说工厂方法和抽象工厂的区别：
1 抽象工厂内部的方法其实都是工厂方法，即工厂方法用于生产一个产品，而抽象工厂则用于生产一组产品。
2 工厂方法更多的用于继承基础类，抽象工厂则更多用于提供各种原料来组合创建一个产品。
