女娲造人，人是造出来了，世界是热闹了，可是低头一看，都是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。
由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类（Product 产品类）怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦炉（工厂模式中的 Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男性，又一个具体工厂的实现类），这个过程的类图如下：
先看人类（也就是产品）的类图：
这个类图也比较简单，Java 的典型类图，一个接口，几个抽象类，然后是几个实现类，没啥多说的，其中三个抽象类在抽象工厂模式中是叫做产品等级，六个实现类是叫做产品族，这个也比较好理解，实现类嘛是真实的产品，一个叫产品，多了就叫产品族，然后再看工厂类：
其中抽象工厂只实现了一个 createHuman 的方法，目的是简化实现类的代码工作量，这个在讲代码的时候会说。
这里还使用了 Jdk 1.5 的一个新特性 Enum 类型，完整的类图如下，这个看不大清楚，其实就是上面那两个类图加起来，大家可以看源码中的那个类图文件：
然后类图讲解完毕，我们来看程序实现：
1 package com.pattern.abtructFactory;
2
3 /**
4 * 定义一个人类的统称
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public interface Human {
9
10 /**
11 * 首先定义什么是人类，会笑的
12 */
13 public void laugh();
14
15 /**
16 * 人类还会哭，代表痛苦
17 */
18 public void cry();
19
20 /**
21 * 人类会说话
22 */
23 public void talk();
24
25 /**
26 * 定义性别
27 */
28 public void sex();
29
30 }
31
32 人类的接口定义好，然后根据接口创建三个抽象类，也就是三个产品等级， 实现 laugh()、 cry()、talk()
33 三个方法，以 AbstractYellowHuman 为例：
34
35 package com.pattern.abtructFactory;
36
37 /**
38 * 抽象的黄色人种
39 * @author http://www.cnblogs.com/initial-road/
40 *
41 */
42 public abstract class AbstractYellowHuman implements Human{
43
44 @Override
45 public void cry() {
46 System.out.println("黄色人种会哭");
47 }
48
49 @Override
50 public void laugh() {
51 System.out.println("黄色人种会大笑");
52 }
53
54 @Override
55 public void talk() {
56 System.out.println("黄色人种会说话，一般说的都是双字节");
57 }
58
59 }
60
61 package com.pattern.abtructFactory;
62
63 /**
64 * 抽象的白色人种
65 * @author http://www.cnblogs.com/initial-road/
66 *
67 */
68 public abstract class AbstractWhiteHuman implements Human {
69
70 @Override
71 public void cry() {
72 System.out.println("白色人种会哭");
73 }
74
75 @Override
76 public void laugh() {
77 System.out.println("白色人种会大笑");
78 }
79
80 @Override
81 public void talk() {
82 System.out.println("白色人种会说话，一般都是单字节");
83 }
84
85 }
86
87 package com.pattern.abtructFactory;
88
89 /**
90 * 抽象的黑色人种
91 * @author http://www.cnblogs.com/initial-road/
92 *
93 */
94 public abstract class AbstractBlackHuman implements Human {
95
96 @Override
97 public void cry() {
98 System.out.println("黑人会哭");
99 }
100
101 @Override
102 public void laugh() {
103 System.out.println("黑人会笑");
104 }
105
106 @Override
107 public void talk() {
108 System.out.println("黑人可以说话，一般人听不懂");
109 }
110
111 }
三个抽象类都实现完毕了，然后就是些实现类了。其实，你说抽象类放这里有什么意义吗？就是不允许你 new 出来一个抽象的对象呗，使用非抽象类完全就可以代替，呵呵，杀猪杀尾巴，各有各的杀法，不过既然进了 Java 这个门就要遵守 Java 这个规矩，我们看实现类：
1 package com.pattern.abtructFactory;
2
3 /**
4 * 男性黄种人
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public class YellowMaleHuman extends AbstractYellowHuman{
9
10 @Override
11 public void sex() {
12 System.out.println("该黄种人的性别为男...");
13 }
14
15 }
16
17 package com.pattern.abtructFactory;
18
19 /**
20 * 女性黄种人
21 * @author http://www.cnblogs.com/initial-road/
22 *
23 */
24 public class YellowFemaleHuman extends AbstractYellowHuman{
25
26 @Override
27 public void sex() {
28 System.out.println("该黄色人种的性别为女...");
29 }
30
31 }
32
33 package com.pattern.abtructFactory;
34
35 /**
36 * 男性白种人
37 * @author http://www.cnblogs.com/initial-road/
38 *
39 */
40 public class WhiteMaleHuman extends AbstractWhiteHuman{
41
42 @Override
43 public void sex() {
44 System.out.println("该白种人的性别为男...");
45 }
46
47 }
48
49 package com.pattern.abtructFactory;
50
51 /**
52 * 女性白种人
53 * @author http://www.cnblogs.com/initial-road/
54 *
55 */
56 public class WhiteFemaleHuman extends AbstractWhiteHuman{
57
58 @Override
59 public void sex() {
60 System.out.println("该白色人种的性别为女...");
61 }
62
63 }
64
65 package com.pattern.abtructFactory;
66
67 /**
68 * 男性黑种人
69 * @author http://www.cnblogs.com/initial-road/
70 *
71 */
72 public class BlackMaleHuman extends AbstractBlackHuman{
73
74 @Override
75 public void sex() {
76 System.out.println("该黄种人的性别为男...");
77 }
78
79 }
80
81 package com.pattern.abtructFactory;
82
83 /**
84 * 女性黑种人
85 * @author http://www.cnblogs.com/initial-road/
86 *
87 */
88 public class BlackFemaleHuman extends AbstractBlackHuman{
89
90 @Override
91 public void sex() {
92 System.out.println("该黑色人种的性别为女...");
93 }
94
95 }
抽象工厂模式下的产品等级和产品族都已经完成，也就是人类以及产生出的人类是什么样子的都已经定义好了，下一步就等着工厂开工创建了，那我们来看工厂类。
在看工厂类之前我们先看那个枚举类型，这个是很有意思的：
1 package com.pattern.abtructFactory;
2
3 /**
4 * 世界上有哪些类型的人，列出来
5 * JDK 1.5开始引入enum类型
6 * @author http://www.cnblogs.com/initial-road/
7 *
8 */
9 public enum HumanEnum {
10
11 //把世界上所有人类型都定义出来
12 YellowMaleHuman("com.pattern.abtructFactory.YellowMaleHuman"),
13
14 YellowFemaleHuman("com.pattern.abtructFactory.YellowFemaleHuman"),
15
16 WhiteFemaleHuman("com.pattern.abtructFactory.WhiteFemaleHuman"),
17
18 WhiteMaleHuman("com.pattern.abtructFactory.WhiteMaleHuman"),
19
20 BlackFemaleHuman("com.pattern.abtructFactory.BlackFemaleHuman"),
21
22 BlackMaleHuman("com.pattern.abtructFactory.BlackMaleHuman");
23
24 private String value = "";
25
26 //定义构造函数，目的是Data(value)类型的相匹配
27 private HumanEnum(String value){
28 this.value = value;
29 }
30
31 public String getValue(){
32 return this.value;
33 }
34
35 }
我之所以引入 Enum 这个类型，是想让大家在看这本书的时候能够随时随地的学到点什么，你如果看不懂设计模式，你可以从我的程序中学到一些新的技术点，不用像我以前报着砖头似的书在那里啃，看一遍不懂，再看第二遍，然后翻了英文原本才知道，哦~，原来是这样滴，只能说有些翻译家实在不懂技术。
我在讲解技术的时候，尽量少用专业术语，尽量使用大部分人类都能理解的语言。Enum 以前我也很少用，最近在一个项目中偶然使用上了，然后才发觉它的好处，Enum 类型作为一个参数传递到一个方法中时，在 Junit 进行单元测试的时候，不用判断输入参数是否为空、长度为 0 的边界异常条件，如果方法传入的参数不是 Enum 类型的话，根本就传递不进来，你说定义一个类，定义一堆的静态变量，这也可以呀，这个不和你抬杠，上面的代码我解释一下，构造函数没啥好说的，然后是 getValue()方法，就是获得枚举类型中一个元素的值，枚举类型中的元素也是有名称和值的，这个和 HashMap 有点类似。
然后，我们看我们的工厂类，先看接口：
1 package com.pattern.abtructFactory;
2
3 /**
4 * 这次定一个接口，应该要造不同性别的人，需要不同的生产线
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public interface HumanFactory {
9
10 //制造黄色人种
11 public Human createYellowHuman();
12
13 //制造一个白色人种
14 public Human createWhiteHuman();
15
16 //制造一个黑人人种
17 public Human createBlackHuman();
18
19 }
20
21 package com.pattern.abtructFactory;
22
23 /**
24 * 编写一个抽象类，根据enum创建一个人类出来
25 * @author http://www.cnblogs.com/initial-road/
26 *
27 */
28 public abstract class AbstractHumanFactory implements HumanFactory{
29
30 /**
31 * 给定一个性别人种，创建一个人类出来，专业术语是产生产品等级
32 */
33 protected Human createHuman(HumanEnum humanEnum){
34 Human human = null;
35 //如果传递进来不是一个Enum中具体的一个Element的话，则不处理
36 if(!humanEnum.getValue().equals("")){
37 try {
38 //直接产生一个实例
39 human = (Human) Class.forName(humanEnum.getValue()).newInstance();
40 } catch (Exception e) {
41 //因为使用了enum，这个异常情况不会产生了
42 e.printStackTrace();
43 }
44 }
45 return human;
46 }
47
48 }
这就是引入 enum 的好处，createHuman(HumanEnum humanEnum)这个方法定义了输入参数必须是 HumanEnum 类型，然后直接使用humanEnum.getValue()方法就能获得具体传递进来的值，这个抽象类的目的就是减少下边实现类的代码量，我们看实现类：
1 package com.pattern.abtructFactory;
2
3 /**
4 * 男性创建工厂
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public class MaleHumanFactory extends AbstractHumanFactory{
9
10 /**
11 * 创建一个男性黑种人
12 */
13 @Override
14 public Human createBlackHuman() {
15 return super.createHuman(HumanEnum.BlackMaleHuman);
16 }
17
18 /**
19 * 创建一个男性白种人
20 */
21 @Override
22 public Human createWhiteHuman() {
23 return super.createHuman(HumanEnum.WhiteMaleHuman);
24 }
25
26 /**
27 * 创建一个男性黄种人
28 */
29 @Override
30 public Human createYellowHuman() {
31 return super.createHuman(HumanEnum.YellowMaleHuman);
32 }
33
34 }
35
36 package com.pattern.abtructFactory;
37
38 /**
39 * 女性创建工厂
40 * @author http://www.cnblogs.com/initial-road/
41 *
42 */
43 public class FemaleHumanFactory extends AbstractHumanFactory{
44
45 /**
46 * 创建一个女性黑种人
47 */
48 @Override
49 public Human createBlackHuman() {
50 return super.createHuman(HumanEnum.BlackFemaleHuman);
51 }
52
53 /**
54 * 创建一个女性白种人
55 */
56 @Override
57 public Human createWhiteHuman() {
58 return super.createHuman(HumanEnum.WhiteFemaleHuman);
59 }
60
61 /**
62 * 创建一个女性黄种人
63 */
64 @Override
65 public Human createYellowHuman() {
66 return super.createHuman(HumanEnum.YellowFemaleHuman);
67 }
68
69 }
70
71 package com.pattern.abtructFactory;
72
73 /**
74 * 女娲建立起了两条生产线，分别是：
75 * 男性生产线
76 * 女性生产线
77 * @author http://www.cnblogs.com/initial-road/
78 *
79 */
80 public class NvWa {
81
82 public static void main(String[] args) {
83
84 //第一条生产线，男性生产线
85 HumanFactory maleHumanFactory = new MaleHumanFactory();
86
87 //第二条生产线，女性生产线
88 HumanFactory femaleHumanFactory = new FemaleHumanFactory();
89
90 //生产线建立完毕，开始生产人了
91 for(int i=0;i<100;i++){
92 Human maleYellowHuman = maleHumanFactory.createYellowHuman();
93 maleYellowHuman.cry();
94 maleYellowHuman.laugh();
95 maleYellowHuman.talk();
96 maleYellowHuman.sex();
97 System.out.println("\n");
98 }
99 for(int i=0;i<100;i++){
100 Human femaleYellowHuman = femaleHumanFactory.createYellowHuman();
101 femaleYellowHuman.cry();
102 femaleYellowHuman.laugh();
103 femaleYellowHuman.talk();
104 femaleYellowHuman.sex();
105 System.out.println("\n");
106 }
107
108 }
109
110 }
两个八卦炉，一个造女的，一个造男的，开足马力，一直造到这个世界到现在这个模式为止。
抽象工厂模式讲完了，那我们再思考一些问题：工厂模式有哪些优缺点？先说优点，非常重要的一点就是，工厂模式符合 OCP 原则，也就是开闭原则，比如就性别的问题，这个世界上还存在双性人，是男也是女的人，那这个就是要在我们的产品族中增加一类产品，同时再增加一个工厂就可以解决这个问题。那还有没有其他好处呢？抽象工厂模式，还有一个非常大的优点，高内聚，低耦合，在一个较大的项目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂方法和产品的接口，也就是说只需要提供 Product Interface 和 Concrete Factory 就可以产生自己需要的对象和方法，Java 的高内 聚低耦合的特性表现的一览无遗。