设计模式——抽象工厂模式【Abstract Factory Pattern】

好了，我们继续上一节课，上一节讲到女娲造人，人是造出来了，世界时热闹了，可是低头一看，都是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，Shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。

由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类（Product产品类）怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦炉（工厂模式中的Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男性，又一个具体工厂的实现类），这个过程的类图如下：

先看人类（也就是产品）的类图：

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

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

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

package abstractfactory.pattern; /** * 定义一个人类的统称，问题出来了，刚刚定义的时候忘记定义性别了 */ public interface Human { //人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了； public void laugh(); //人类还会哭，代表痛苦 public void cry(); //人类会说话 public void talk(); //定义性别 public void sex(); }

人类的接口定义好，然后根据接口创建三个抽象类，也就是三个产品等级，实现laugh()、cry()、talk()三个方法，以AbstractYellowHuman为例：

package abstractfactory.pattern; /** * 为什么要修改成抽象类呢？要定义性别呀 */ public abstract class AbstractYellowHuman implements Human { public void cry() { System.out.println("黄色人类会哭"); } public void laugh() { System.out.println("黄色人类会大笑，幸福呀！"); } public void sex() { System.out.println("黄色人类会说话，一般说的都是双字节"); } }

其他的两个抽象类AbstractWhiteHuman和AbstractgBlackHuman与此类似的事项方法，不再通篇拷贝代码，大家可以看一下源代码。算了，还是拷贝，反正是电子档的，不想看就往下翻页，也成就了部分“懒人”，不用启动Eclipse，还要把源码拷贝进来：

白种人的抽象类：

package abstractfactory.pattern; /** * 白色人人类 */ public abstract class AbstractWhiteHuman implements Human { public void cry() { System.out.println("白色人类会哭"); } public void laugh() { System.out.println("白色人类会大笑，侵略的笑声"); } public void sex() { System.out.println("白色人类会说话，一般都是但是单字节！"); } }

黑种人的抽象类：

package abstractfactory.pattern; /** * 黑色人类 */ public abstract class AbstractBlackHuman implements Human { public void cry() { System.out.println("黑人会哭"); } public void laugh() { System.out.println("黑人会笑"); } public void sex() { System.out.println("黑人可以说话，一般人听不懂"); } }

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

女性黄种人的实现类：

 

 

package abstractfactory.pattern; /** * 女性黄种人 */ public class YellowFemaleHuman extends AbstractYellowHuman { public void talk() { System.out.println("该黄种人的性别为女..."); } }

男性黄种人的实现类：

package abstractfactory.pattern; /** * 男性黄种人 */ public class YellowMaleHuman extends AbstractYellowHuman { public void talk() { System.out.println("该黄种人的性别为男...."); } }

女性白种人的实现类：

package abstractfactory.pattern; /** * 女性白种人 */ public class WhiteFemaleHuman extends AbstractWhiteHuman { public void talk() { System.out.println("该白种人的性别为女...."); } }

男性白种人的实现类：

package abstractfactory.pattern; /** * 男性白种人 */ public class WhiteMaleHuman extends AbstractWhiteHuman { public void talk() { System.out.println("该白种人的性别为男...."); } }

女性黑种人的实现类：

package abstractfactory.pattern; /** * 女性黑种人 */ public class BlackFemaleHuman extends AbstractBlackHuman { public void talk() { System.out.println("该黑种人的性别为女..."); } }

男性黑种人的实现类：

package abstractfactory.pattern; /** * 男性黑种人 */ public class BlackMaleHuman extends AbstractBlackHuman { public void talk() { System.out.println("该黑种人的性别为男..."); } }

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

package abstractfactory.pattern; /** * 世界上有哪些类型的人，列出来 */ public enum HumanEnum { //把世界上所有人类型都定义出来 YellowMaleHuman("abstractfactory.pattern.YellowMaleHuman"), YellowFemaleHuman("abstractfactory.pattern.YellowFemaleHuman"), WhiteFemaleHuman("abstractfactory.pattern.WhiteFemaleHuman"), WhiteMaleHuman("abstractfactory.pattern.WhiteMaleHuman"), BlackFemaleHuman("abstractfactory.pattern.BlackFemaleHuman"), BlackMaleHuman("abstractfactory.pattern.BlackMaleHuman"); private String value = ""; //定义构造函数，目的是Data(value)类型的相匹配 private HumanEnum(String value){ this.value = value; } public String getValue(){ return this.value; } }

然后，我们看我们的工厂类，先看接口：

package abstractfactory.pattern; /** * 这次定一个接口，应该要造不同性别的人，需要不同的生产线 */ public interface HumanFactory { //制造黄色人类 public Human createYellowHuman(); //制造一个白色人类 public Human createWhiteHuman(); //制造一个黑色人类 public Human createBlackHuman(); }

然后看抽象类：

package abstractfactory.pattern; /** * 编写一个抽象类，根据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; } }

大家自己看程序领会，没多大难度，这个抽象类的目的就是减少下边实现类的代码量，我们看实现类：

男性工厂，只创建男性：

 

package abstractfactory.pattern; /** * 男性创建工厂 */ 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.YellowMaleHuman); } }

女性工厂，只创建女性：

package abstractfactory.pattern; /** * 女性创建工厂 */ 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.YellowFemaleHuman); } }

产品定义好了，工厂也定义好了，万事俱备只欠东风，那咱就开始造吧，哦，不对，女娲开始造人了：

package abstractfactory.pattern; 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(); maleYellowHuman.talk(); maleYellowHuman.sex(); System.out.println("/n/n/n/n/n/n/n/n"); femaleYellowHuman.cry(); femaleYellowHuman.laugh(); femaleYellowHuman.talk(); femaleYellowHuman.sex(); } }

两个八卦炉，一个造女的，一个造男的，开足马力，一直造到这个世界到现在这个模式为止。

抽象工厂模式讲完了，那我们再思考一些问题：工厂模式有哪些优缺点？先说优点，我这人一般先看人优点，非常重要的有点就是，工厂模式符合OCP原则，也就是开闭原则，怎么说呢，比如就性别的问题，这个世界上还存在双性人，是男也是女的人，那这个就是要在我们的产品族中增加一类产品，同时再增加一个工厂就可以解决这个问题，不需要我再来实现了吧，很简单的大家自己画下类图，然后实现下。

那还有没有其他好处呢？抽象工厂模式，还有一个非常大的有点，高内聚，低耦合，在一个较大的项目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂方法和产品的接口，也就是说只需要提供Product Interface和Concrete Factory就可以产生自己需要的对象和方法，Java的高内聚低耦合的特性表现的一览无遗，哈哈。