学点设计模式-抽象工厂模式

抽象工厂模式

人是造出来了，世界时热闹了，可是低头一看，都
是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，
Shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。
由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类（Product 产品类）
怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？
只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦
炉（工厂模式中的Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两
个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男
性，又一个具体工厂的实现类），这个过程的类图如下：
先看人类（也就是产品）的类图：

这个类图也比较简单，Java 的典型类图，一个接口，几个抽象类，然后是几个实现类，没啥多说的，
其中三个抽象类在抽象工厂模式中是叫做产品等级，六个实现类是叫做产品族，这个也比较好理解，实现
类嘛是真实的产品，一个叫产品，多了就叫产品族，然后再看工厂类：

其中抽象工厂只实现了一个createHuman 的方法，目的是简化实现类的代码工作量，这个在讲代码的
时候会说。这里还使用了Jdk 1.5 的一个新特性Enum 类型，其实这个完全可以类的静态变量来实现，但我
想既然是学习就应该学有所获得，即使你对这个模式非常了解，也可能没用过Enum 类型，也算是一个不同
的知识点吧，我希望给大家讲解，每次都有新的技术点提出来，每个人都会有一点的收获就足够了，然后
在具体的项目中使用时，知道有这个技术点，然后上baidu 狗狗一下就能解决问题。话题扯远了，我们继
续类图，完整的类图如下，这个看不大清楚，其实就是上面那两个类图加起来，大家可以看源码中的那个
类图文件：

然后类图讲解完毕，我们来看程序实现：

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] 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.AbstractFactory;public abstract class AbstractYellowHuman implements Human {public void cry() {System.out.println("黄色人种会哭");}public void laugh() {System.out.println("黄色人种会大笑，幸福呀！");}public void talk() {System.out.println("黄色人种会说话，一般说的都是双字节");}}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] 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.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 女性黑种人 */public class BlackFemaleHuman extends AbstractBlackHuman {public void sex() {System.out.println("该黑种人的性别为女...");}}

三个抽象类都实现完毕了，然后就是些实现类了。其实，你说抽象类放这里有什么意义吗？就是不允
许你new 出来一个抽象的对象呗，使用非抽象类完全就可以代替，呵呵，杀猪杀尾巴，各有各的杀法，不
过既然进了Java 这个门就要遵守Java 这个规矩，我们看实现类：
女性黄种人的实现类：

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 女性黄种人 */public class YellowFemaleHuman extends AbstractYellowHuman {public void sex() {System.out.println("该黄种人的性别为女...");}}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 男性黄种人 */public class YellowMaleHuman extends AbstractYellowHuman {public void sex() {System.out.println("该黄种人的性别为男....");}}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all.\ 女性白种人 */public class WhiteFemaleHuman extends AbstractWhiteHuman {public void sex() {System.out.println("该白种人的性别为女....");}}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 男性白种人 */public class WhiteMaleHuman extends AbstractWhiteHuman {public void sex() {System.out.println("该白种人的性别为男....");}}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 女性黑种人 */public class BlackFemaleHuman extends AbstractBlackHuman {public void sex() {System.out.println("该黑种人的性别为女...");}}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 男性黑种人 */public class BlackMaleHuman extends AbstractBlackHuman {public void sex() {System.out.println("该黑种人的性别为男...");}}

抽象工厂模式下的产品等级和产品族都已经完成，也就是人类以及产生出的人类是什么样子的都已经
定义好了，下一步就等着工厂开工创建了，那我们来看工厂类。
在看工厂类之前我们先看那个枚举类型，这个是很有意思的：

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] 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.AbstractFactory;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 这次定一个接口，应该要造不同性别的人，需要不同的生产线 那这个八卦炉必须可以制造男人和女人 第 39 页 您的设计模式 */public interface HumanFactory {// 制造黄色人种public Human createYellowHuman();// 制造一个白色人种public Human createWhiteHuman();// 制造一个黑色人种public Human createBlackHuman();}

package com.cbf4life.AbstractFactory;/** * @author cbf4Life [e-mail] 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.AbstractFactory;/** * @author cbf4Life [e-mail] 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.AbstractFactory;/** * @author cbf4Life [e-mail] 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.AbstractFactory;/** * @author cbf4Life [e-mail] 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 的高内聚
低耦合的特性表现的一览无遗，哈哈。