java 抽象工厂_006.抽象工厂模式

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

由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类(Product产品类)怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦

炉(工厂方法模式中的HumanFactory)拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两个，并且略加修改，就成了女性八卦炉(只生产女性，一个具体工厂的实现类)和男性八卦炉(只生产男性，又一个具体工厂的实现类)，这个过程的类图如下：

先看人类(也就是产品)的类图：

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

其中抽象工厂只实现了一个createHuman()的方法，目的是简化实现类的代码工作量，这个在讲代码的时候会说。这里还使用了Jdk1.5以后的一个特性，Enum类型，其实这个完全可以类的静态变量来实现，完整的类图如下：

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

package com.cbf4life.abstract_factory;

/**

*

* @Description:

* 定义一个人类的统称，问题出来了，刚刚定义的时候忘记定义性别了

* 这个重要的问题非修改不可，否则这个世界上太多太多的东西不存在了

*/

public interface Human {

// 首先定义什么是人类

// 人会笑，表达愉快

void laugh();

// 人会哭，表达悲伤

void cry();

// 人会说话

void talk();

// 定义性别

void sex();

}

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

package com.cbf4life.abstract_factory;

/**

* @Description:

* 为什么要修改成抽象类呢？只是YellowHuman的统称，不需要定义性别

*/

public abstract class YellowHuman implements Human {

@Override

public void laugh() {

System.out.println("黄种人会笑...");

}

@Override

public void cry() {

System.out.println("黄种人会哭...");

}

@Override

public void talk() {

System.out.println("黄种人说话，一般说的都是双字节...");

}

}

白种人抽象类：

package com.cbf4life.abstract_factory;

public abstract class WhiteHuman implements Human {

@Override

public void laugh() {

System.out.println("白种人会笑...");

}

@Override

public void cry() {

System.out.println("白种人会哭...");

}

@Override

public void talk() {

System.out.println("白种人说话，一般说的都是单字节...");

}

}

黑种人抽象类

package com.cbf4life.abstract_factory;

public abstract class BlackHuman implements Human {

@Override

public void laugh() {

System.out.println("黑种人会笑...");

}

@Override

public void cry() {

System.out.println("黑种人会哭...");

}

@Override

public void talk() {

System.out.println("黑种人说话，一般听不懂...");

}

}

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

女性黄种人的实现类：

package com.cbf4life.abstract_factory;

/**

* @Description: 女性黄种人

*/

public class YellowFemaleHuman extends YellowHuman {

@Override

public void sex() {

System.out.println("该黄种人的性别为女...");

}

}

男性黄种人的实现类：

package com.cbf4life.abstract_factory;

/**

* @Description: 男性黄种人

*/

public class YellowMaleHuman extends YellowHuman {

@Override

public void sex() {

System.out.println("该黄种人的性别为男...");

}

}

女性白种人的实现类：

package com.cbf4life.abstract_factory;

/**

* @Description: 女性白种人

*/

public class WhiteFemaleHuman extends YellowHuman {

@Override

public void sex() {

System.out.println("该白种人的性别为女...");

}

}

男性白种人的实现类：

package com.cbf4life.abstract_factory;

/**

* @Description: 男性白种人

*/

public class WhiteMaleHuman extends YellowHuman {

@Override

public void sex() {

System.out.println("该白种人的性别为男...");

}

}

女性黑种人的实现类：

package com.cbf4life.abstract_factory;

/**

* @Description: 女性黑种人

*/

public class BlackFemaleHuman extends YellowHuman {

@Override

public void sex() {

System.out.println("该黑种人的性别为女...");

}

}

男性黑种人的实现类：

package com.cbf4life.abstract_factory;

/**

* @Description: 男性黑种人

*/

public class BlackMaleHuman extends YellowHuman {

@Override

public void sex() {

System.out.println("该黑种人的性别为男...");

}

}

抽象工厂模式下的产品等级和产品族都已经完成，也就是人类以及产生出的人类是什么样子的都已经定义好了，下一步就等着工厂开工创建了，那我们来看工厂类。

在看工厂类之前我们先看那个枚举类型，这个是很有意思的：

package com.cbf4life.abstract_factory;

/**

* @Description:

* 世界上有哪些类型的人，列出来

* java enum类型简单易用，尽量不要使用多态、继承等方法

*/

public enum HumanEnum {

YellowMaleHuman("com.cbf4life.abstract_factory.YellowMaleHuman"),

YellowFemaleHuman("com.cbf4life.abstract_factory.YellowFemaleHuman"),

WhiteMaleHuman("com.cbf4life.abstract_factory.WhiteMaleHuman"),

WhiteFemaleHuman("com.cbf4life.abstract_factory.WhiteFemaleHuman"),

BlackMaleHuman("com.cbf4life.abstract_factory.BlackMaleHuman"),

BlackFemaleHuman("com.cbf4life.abstract_factory.BlackFemaleHuman");

private String value = "";

private HumanEnum(String value){

this.value = value;

}

public String getValue(){

return this.value;

}

}

使用Enum有很多好处，Enum类型作为一个参数传递到一个方法中时，在Junit进行单元测试的时候，不用判断输入参数是否为空、长度为0等边界异常条件，如果方法传入的参数不是Enum类型的话，根本就传递不进来，你说定义一个类，定义一堆的静态变量，这也可以呀，这个不和你抬杠，上面的代码我解释一下，构造函数没啥好说的，然后是getValue()方法，就是获得枚举类型中一个元素的值，枚举类型中的元素也是有名称和值的，这个和HashMap有点类似。

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

package com.cbf4life.abstract_factory;

/**

* @Description:

* 这次定一个接口，应该要造不同性别的人，需要不同的生产线

* 那这个八卦炉必须可以制造男人和女人

*/

public interface HumanFactory {

// 制造黄种人

Human createYellowHuman();

// 制造白种人

Human createWhiteHuman();

// 制造黑种人

Human createBlackHuman();

}

然后看抽象类：

package com.cbf4life.abstract_factory;

/**

* @Description: 编写一个抽象类，根据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) {

e.printStackTrace();

// 因为使用了enum，这个种异常情况不会产生了，除非你的enum有问题

}

}

return human;

}

}

看到没，这就是引入enum的好处，createHuman(HumanEnum humanEnum)这个方法定义了输入参数必须是HumanEnum类型，然后直接使用humanEnum.getValue()方法就能获得具体传递进来的值，这个不多说了，大家自己看程序领会，没多大难度，这个抽象类的目的就是减少下边实现类的代码量，我们看实现类：

男性工厂，只创建男性：

package com.cbf4life.abstract_factory;

/**

* @Description: 男性创建工厂

*/

public class MaleHumanFactory extends AbstractHumanFactory {

// 创造男性黄种人

@Override

public Human createYellowHuman() {

return super.createHuman(HumanEnum.YellowMaleHuman);

}

// 创造男性白种人

@Override

public Human createWhiteHuman() {

return super.createHuman(HumanEnum.WhiteMaleHuman);

}

// 创造男性黑种人

@Override

public Human createBlackHuman() {

return super.createHuman(HumanEnum.BlackMaleHuman);

}

}

女性工厂，只创建女性：

package com.cbf4life.abstract_factory;

/**

* @Description: 女性创建工厂

*/

public class FemaleHumanFactory extends AbstractHumanFactory {

// 创造女性黄种人

@Override

public Human createYellowHuman() {

return super.createHuman(HumanEnum.YellowFemaleHuman);

}

// 创造女性白种人

@Override

public Human createWhiteHuman() {

return super.createHuman(HumanEnum.WhiteFemaleHuman);

}

// 创造女性黑种人

@Override

public Human createBlackHuman() {

return super.createHuman(HumanEnum.BlackFemaleHuman);

}

}

产品定义好了，工厂也定义好了，万事俱备只欠东风，女娲开始造人了：

package com.cbf4life.abstract_factory;

/**

* @Description:

* 女娲建立起了两条生产线，分别是：

* 男性生产线

* 女性生产线

*/

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 和 Create Factory 就可以产生自己需要的对象和方法，Java 的高内聚低耦合的特性表现的一览无遗，哈哈。

本文原书：

《您的设计模式》 作者：CBF4LIFE