（六）抽象工厂模式
好了，我们继续上一节课，上一节讲到女娲造人，人是造出来了，世界时热闹了，可是低头一看，都
是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，
Shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。
由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类（Product产品类）
怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？
只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦
炉（工厂模式中的 Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术” ，把原先的八卦炉一个变两
个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男
性，又一个具体工厂的实现类） ，这个过程的类图如下：
先看人类（也就是产品）的类图：
这个类图也比较简单，Java 的典型类图，一个接口，几个抽象类，然后是几个实现类，没啥多说的，
其中三个抽象类在抽象工厂模式中是叫做产品等级，六个实现类是叫做产品族，这个也比较好理解，实现
类嘛是真实的产品，一个叫产品，多了就叫产品族，然后再看工厂类：
其中抽象工厂只实现了一个 createHuman 的方法，目的是简化实现类的代码工作量，这个在讲代码的
时候会说。这里还使用了 Jdk 1.5的一个新特性 Enum 类型，其实这个完全可以类的静态变量来实现，但我
想既然是学习就应该学有所获得，即使你对这个模式非常了解，也可能没用过 Enum 类型，也算是一个不同
的知识点吧，我希望给大家讲解，每次都有新的技术点提出来，每个人都会有一点的收获就足够了，然后
在具体的项目中使用时，知道有这个技术点，然后上 baidu 狗狗一下就能解决问题。话题扯远了，我们继
续类图，完整的类图如下，这个看不大清楚，其实就是上面那两个类图加起来，大家可以看源码中的那个
类图文件：
然后类图讲解完毕，我们来看程序实现：
package com.cbf4life;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 定义一个人类的统称，问题出来了，刚刚定义的时候忘记定义性别了
* 这个重要的问题非修改不可，否则这个世界上太多太多的东西不存在了
*/
public interface Human {
//首先定义什么是人类
//人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了；
public void laugh();
//人类还会哭，代表痛苦
public void cry();
//人类会说话
public void talk();
//定义性别
public void sex();
}
人类的接口定义好， 然后根据接口创建三个抽象类， 也就是三个产品等级， 实现laugh()、 cry()、 talk()
三个方法，以 AbstractYellowHuman为例：
package com.cbf4life.yellowHuman;
import com.cbf4life.Human;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 为什么要修改成抽象类呢？要定义性别呀
*/
public abstract class AbstractYellowHuman implements Human {
public void cry() {
System.out.println("黄色人类会哭");
}
public void laugh() {
System.out.println("黄色人类会大笑，幸福呀！");
}
public void talk() {
System.out.println("黄色人类会说话，一般说的都是双字节");
}
}
其他的两个抽象类 AbstractWhiteHuman和 AbstractgBlackHuman 与此类似的事项方法，不再通篇拷贝
代码，大家可以看一下源代码。算了，还是拷贝，反正是电子档的，不想看就往下翻页，也成就了部分“懒
人” ，不用启动 Eclipse，还要把源码拷贝进来：
白种人的抽象类：
package com.cbf4life.whiteHuman;
import com.cbf4life.Human;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 白色人人类
* 为了代码整洁，新建一个包，这里是白种人的天下了
*/
public abstract class AbstractWhiteHuman implements Human {
public void cry() {
System.out.println("白色人类会哭");
}
public void laugh() {
System.out.println("白色人类会大笑，侵略的笑声");
}
public void talk() {
System.out.println("白色人类会说话，一般都是但是单字节！");
}
}
黑种人的抽象类：
package com.cbf4life.blackHuman;
import com.cbf4life.Human;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 黑色人类，记得中学学英语，老师说black man是侮辱人的意思，不懂，没跟老外说话
*/
public abstract class AbstractBlackHuman implements Human {
public void cry() {
System.out.println("黑人会哭");
}
public void laugh() {
System.out.println("黑人会笑");
}
public void talk() {
System.out.println("黑人可以说话，一般人听不懂");
}
}
三个抽象类都实现完毕了，然后就是些实现类了。其实，你说抽象类放这里有什么意义吗？就是不允
许你 new 出来一个抽象的对象呗，使用非抽象类完全就可以代替，呵呵，杀猪杀尾巴，各有各的杀法，不
过既然进了 Java 这个门就要遵守 Java这个规矩，我们看实现类：
女性黄种人的实现类：
package com.cbf4life.yellowHuman;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 女性黄种人
*/
public class YellowFemaleHuman extends AbstractYellowHuman {
public void sex() {
System.out.println("该黄种人的性别为女...");
}
}
男性黄种人的实现类：
package com.cbf4life.yellowHuman;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 男性黄种人
*/
public class YellowMaleHuman extends AbstractYellowHuman {
public void sex() {
System.out.println("该黄种人的性别为男....");
}
}
女性白种人的实现类：
package com.cbf4life.whiteHuman;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.\
* 女性白种人
*/
public class WhiteFemaleHuman extends AbstractWhiteHuman {
public void sex() {
System.out.println("该白种人的性别为女....");
}
}
男性白种人的实现类：
package com.cbf4life.whiteHuman;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 男性白种人
*/
public class WhiteMaleHuman extends AbstractWhiteHuman {
public void sex() {
System.out.println("该白种人的性别为男....");
}
}
女性黑种人的实现类：
package com.cbf4life.blackHuman;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 女性黑种人
*/
public class BlackFemaleHuman extends AbstractBlackHuman {
public void sex() {
System.out.println("该黑种人的性别为女...");
}
}
男性黑种人的实现类：
package com.cbf4life.blackHuman;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 男性黑种人
*/
public class BlackMaleHuman extends AbstractBlackHuman {
public void sex() {
System.out.println("该黑种人的性别为男...");
}
}
抽象工厂模式下的产品等级和产品族都已经完成，也就是人类以及产生出的人类是什么样子的都已经
定义好了，下一步就等着工厂开工创建了，那我们来看工厂类。
在看工厂类之前我们先看那个枚举类型，这个是很有意思的：
package com.cbf4life;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 世界上有哪些类型的人，列出来
* JDK 1.5开始引入enum类型也是目的的，吸引C程序员转过来
*/
public enum HumanEnum {
//把世界上所有人类型都定义出来
YelloMaleHuman("com.cbf4life.yellowHuman.YellowMaleHuman"),
YelloFemaleHuman("com.cbf4life.yellowHuman.YellowFemaleHuman"),
WhiteFemaleHuman("com.cbf4life.whiteHuman.WhiteFemaleHuman"),
WhiteMaleHuman("com.cbf4life.whiteHuman.WhiteMaleHuman"),
BlackFemaleHuman("com.cbf4life.blackHuman.BlackFemaleHuman"),
BlackMaleHuman("com.cbf4life.blackHuman.BlackMaleHuman");
private String value = "";
//定义构造函数，目的是Data(value)类型的相匹配
private HumanEnum(String value){
this.value = value;
}
public String getValue(){
return this.value;
}
/*
* java enum类型尽量简单使用，尽量不要使用多态、继承等方法
* 毕竟用Clas完全可以代替enum
*/
}
我之所以引入 Enum 这个类型，是想让大家在看这本书的时候能够随时随地的学到点什么，你如果看不
懂设计模式，你可以从我的程序中学到一些新的技术点，不用像我以前报着砖头似的书在那里啃，看一遍
不懂，再看第二遍，然后翻了英文原本才知道，哦~，原来是这样滴，只能说有些翻译家实在不懂技术。我
在讲解技术的时候，尽量少用专业术语，尽量使用大部分人类都能理解的语言。
Enum 以前我也很少用，最近在一个项目中偶然使用上了，然后才发觉它的好处，Enum 类型作为一个参
数传递到一个方法中时，在 Junit 进行单元测试的时候，不用判断输入参数是否为空、长度为 0 的边界异
常条件，如果方法传入的参数不是 Enum 类型的话，根本就传递不进来，你说定义一个类，定义一堆的静态
变量，这也可以呀，这个不和你抬杠，上面的代码我解释一下，构造函数没啥好说的，然后是 getValue()
方法，就是获得枚举类型中一个元素的值，枚举类型中的元素也是有名称和值的，这个和 HashMap 有点类
似。
然后，我们看我们的工厂类，先看接口：
package com.cbf4life;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 这次定一个接口，应该要造不同性别的人，需要不同的生产线
* 那这个八卦炉必须可以制造男人和女人
*/
public interface HumanFactory {
//制造黄色人类
public Human createYellowHuman();
//制造一个白色人类
public Human createWhiteHuman();
//制造一个黑色人类
public Human createBlackHuman();
}
然后看抽象类：
package com.cbf4life.humanFactory;
import com.cbf4life.Human;
import com.cbf4life.HumanEnum;
import com.cbf4life.HumanFactory;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 编写一个抽象类，根据enum创建一个人类出来
*/
public abstract class AbstractHumanFactory implements HumanFactory {
/*
* 给定一个性别人类，创建一个人类出来 专业术语是产生产品等级
*/
protected Human createHuman(HumanEnum humanEnum) {
Human human = null;
//如果传递进来不是一个Enum中具体的一个Element的话，则不处理
if (!humanEnum.getValue().equals("")) {
try {
//直接产生一个实例
human = (Human)
Class.forName(humanEnum.getValue()).newInstance();
} catch (Exception e) {
//因为使用了enum，这个种异常情况不会产生了，除非你的enum有问题；
e.printStackTrace();
}
}
return human;
}
}
看到没，这就是引入 enum 的好处，createHuman(HumanEnum humanEnum)这个方法定义了输入参数必须
是 HumanEnum 类型，然后直接使用 humanEnum.getValue()方法就能获得具体传递进来的值，这个不多说了，
大家自己看程序领会，没多大难度，这个抽象类的目的就是减少下边实现类的代码量，我们看实现类：
男性工厂，只创建男性：
package com.cbf4life.humanFactory;
import com.cbf4life.Human;
import com.cbf4life.HumanEnum;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 男性创建工厂
*/
public class MaleHumanFactory extends AbstractHumanFactory {
//创建一个男性黑种人
public Human createBlackHuman() {
return super.createHuman(HumanEnum.BlackMaleHuman);
}
//创建一个男性白种人
public Human createWhiteHuman() {
return super.createHuman(HumanEnum.WhiteMaleHuman);
}
//创建一个男性黄种人
public Human createYellowHuman() {
return super.createHuman(HumanEnum.YelloMaleHuman);
}
}
女性工厂，只创建女性：
package com.cbf4life.humanFactory;
import com.cbf4life.Human;
import com.cbf4life.HumanEnum;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.\
* 女性创建工厂
*/
public class FemaleHumanFactory extends AbstractHumanFactory {
//创建一个女性黑种人
public Human createBlackHuman() {
return super.createHuman(HumanEnum.BlackFemaleHuman);
}
//创建一个女性白种人
public Human createWhiteHuman() {
return super.createHuman(HumanEnum.WhiteFemaleHuman);
}
//创建一个女性黄种人
public Human createYellowHuman() {
return super.createHuman(HumanEnum.YelloFemaleHuman);
}
}
产品定义好了，工厂也定义好了，万事俱备只欠东风，那咱就开始造吧，哦，不对，女娲开始造人了：
package com.cbf4life;
import com.cbf4life.humanFactory.FemaleHumanFactory;
import com.cbf4life.humanFactory.MaleHumanFactory;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 女娲建立起了两条生产线，分别是：
* 男性生产线
* 女性生产线
*/
public class NvWa {
public static void main(String[] args) {
//第一条生产线，男性生产线
HumanFactory maleHumanFactory = new MaleHumanFactory();
//第二条生产线，女性生产线
HumanFactory femaleHumanFactory = new FemaleHumanFactory();
//生产线建立完毕，开始生产人了:
Human maleYellowHuman = maleHumanFactory.createYellowHuman();
Human femaleYellowHuman = femaleHumanFactory.createYellowHuman();
maleYellowHuman.cry();
maleYellowHuman.laugh();
femaleYellowHuman.sex();
/*
* .....
* 后面你可以续了
*/
}
}
两个八卦炉，一个造女的，一个造男的，开足马力，一直造到这个世界到现在这个模式为止。
抽象工厂模式讲完了，那我们再思考一些问题：工厂模式有哪些优缺点？先说优点，我这人一般先看
人优点，非常重要的有点就是，工厂模式符合 OCP 原则，也就是开闭原则，怎么说呢，比如就性别的问题，
这个世界上还存在双性人，是男也是女的人，那这个就是要在我们的产品族中增加一类产品，同时再增加
一个工厂就可以解决这个问题，不需要我再来实现了吧，很简单的大家自己画下类图，然后实现下。
那还有没有其他好处呢？抽象工厂模式，还有一个非常大的有点，高内聚，低耦合，在一个较大的项
目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂方法和产品的接口，也就是
说只需要提供 Product Interface和Concrete Factory 就可以产生自己需要的对象和方法，Java的高内聚
低耦合的特性表现的一览无遗，哈哈。
