1. 女娲的失误
上一节学习了工厂模式，女娲运用了该模式成功创建了三个人种，可是问题来了，她发现没有性别……这失误也忒大了点吧……竟然没有性别，那岂不是……无奈，只好抹掉重来了，于是所有人都被消灭掉了，重新造人。
女娲开始分析了，既然要区别男女，那么生产人种的工厂（八卦炉）要重新改造了，因为一个设备要么全男性，要么全女性。所以只能将八卦炉拆开了，把原先的一个变两个，并且略加修改，变成女性八卦炉和男性八卦炉，这样就可以了。于是女娲开始准备生产了，她先画了个示意图如下：
这个图虽然有点大，但是不复杂，她将HumanFactory接口用两个新的接口继承，分别带有男性和女性特征；将原来具体的Human类也改成了抽象类，用两个具体的Human类去继承。下面我们看看女娲的实现：
先看Human接口和它的几个抽象类：
-
//定义抽象人类接口
-
public interface Human {
-
public void getColor();
-
public void talk();
-
public void getSex(); //多了个性别
- }
-
//定义抽象黄种人类
-
public abstract class AbstractYellowHuman implements Human {
-
@Override
-
public void getColor() {
-
System.out.println("Yellow color");
- }
-
@Override
-
public void talk() {
-
System.out.println("Yellow people");
- }
- }
-
//抽象黑种人和白种人就不写了，跟抽象黄种人道理一样
-
//略
-
//黄种人男性类
-
public class MaleYellowHuman extends AbstractYellowHuman {
-
@Override
-
public void getSex() {
-
System.out.println("Yellow man!");
- }
- }
-
//黄种人女性类略
以上省略了类似的代码，实现方式都一样，很简单，就不啰嗦了，到此为止，女娲把人种都定义好了，下面就是去定义八卦炉了：
-
//抽象工厂接口的定义
-
public interface HumanFactory {
-
public Human createYellowHuman();
-
public Human createBlackHuman();
-
public Human createWhiteHuman();
- }
-
//生产女性的八卦炉
-
public class FemaleFactory implements HumanFactory {
-
@Override
-
public Human createYellowHuman() {
-
return new FemaleBlackHuman();
- }
-
@Override
-
public Human createBlackHuman() {
-
return new FemaleBlackHuman();
- }
-
@Override
-
public Human createWhiteHuman() {
-
return new FemaleWhiteHuman();
- }
- }
-
//生产男性的八卦炉
-
public class MaleFactory implements HumanFactory {
-
@Override
-
public Human createYellowHuman() {
-
return new MaleYellowHuman();
- }
-
@Override
-
public Human createBlackHuman() {
-
return new MaleBlackHuman();
- }
-
@Override
-
public Human createWhiteHuman() {
-
return new MaleWhiteHuman();
- }
- }
好了，现在人种有了，八卦炉也有了，女娲终于可以再次造人了！
-
public class NvWa {
-
public static void main(String[] args) {
-
HumanFactory maleHumanFactory = new MaleFactory(); //第一条生产线：男性生产线
-
HumanFactory femaleHumanFactory = new FemaleFactory(); //第二条生产线：女性生产线
-
//生产线建立完毕，开始造人
-
Human maleYellowHuman = maleHumanFactory.createYellowHuman(); //造黄色男性
-
Human femaleYellowHuman = femaleHumanFactory.createYellowHuman(); //造黄色女性
-
System.out.println("--生产一个黄色女性--");
- femaleYellowHuman.getColor();
- femaleYellowHuman.talk();
- femaleYellowHuman.getSex();
-
System.out.println("--生产一个黄色男性--");
- maleYellowHuman.getColor();
- maleYellowHuman.talk();
- maleYellowHuman.getSex();
- /*
- * ……
-
*/
- }
- }
到这里，抽象工厂模式的思路算是理清了，下面看看抽象工厂模式的定义。
2. 抽象工厂模式的定义
抽象工厂模式（Abstract Factory Pattern）是一种比较常用的模式，其定义如下：
Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 即为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。它的通用类图如下：
抽象工厂模式是工厂模式的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。我们来看看抽象工厂欧式的通用源代码，首先有两个互相影响的产品线（也叫产品族），例如汽车的左门和右门，这两个数量应该是相等的——两个对象之间的约束，每个型号的车门都是不一样的，这是产品等级结构约束的，我们先看看两个产品族的类图：
注意类图上的圈圈、框框相对应，两个抽象的产品类可以有关系，例如共同继承或实现一个抽象类或接口，其源代码如下：
-
public abstract class AbstractProductA {
-
//每个产品共有的方法
-
public void shareMethod() {
- }
-
//每个产品相同的方法，不同的实现
-
public abstract void doSomething();
- }
两个具体的产品实现类的代码如下：
-
public class productA1 extends AbstractProductA {
-
public abstract void doSomething(){
-
System.out.println("产品A1的实现方法");
- }
- }
-
public class productA2 extends AbstractProductA {
-
public abstract void doSomething(){
-
System.out.println("产品A2的实现方法");
- }
- }
产品B与此类似，不再赘述。抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能，在通用代码中，抽象工厂类定义了两个产品族的产品创建，如下：
-
public abstract class AbstractCreator {
-
//创建A产品家族
-
public abstract AbstracProductA createProductA();
-
//创建B产品家族
-
public abstract AbstracProductB createProductB();
-
//如果有N个产品族，这里就应该有N个创建方法
- }
如何创建一个产品呢？这是由具体的实现类来完成的，Creator1和Creator2代码如下：
-
public class Creator1 extends AbstractCreator {
-
//只生产产品等级为1的A产品
-
public AbstracProductA createProductA(){
-
return new ProductA1();
- }
-
//只生产产品等级为1的B产品
-
public AbstracProductB createProductB() {
-
return new ProductB1();
- }
- }
-
public class Creator2 extends AbstractCreator {
-
//只生产产品等级为1的A产品
-
public AbstracProductA createProductA(){
-
return new ProductA2();
- }
-
//只生产产品等级为1的B产品
-
public AbstracProductB createProductB() {
-
return new ProductB2();
- }
- }
注：有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务。
在具体的业务中就可以生产一个与实现无关的对象了，如：
-
public class AbstractFactoryTest {
-
public static void main(String[] args) {
-
AbstractCreator creator1 = new Creator1();
-
AbstractCreator creator2 = new Creator2();
- AbstractProductA a1 = creator1.createProductA();
- AbstractProductA a2 = creator2.createProductA();
- AbstractProductB b1 = creator1.createProductB();
- AbstractProductB b2 = creator2.createProductB();
-
//……
- }
- }
3. 抽象工厂模式的优缺点
3.1 优点
1）封装性。每个产品的实现类不是高层模块要关心的，它要关心的是接口，是抽象，它不关心对象是如何创建出来的，这都由工厂类负责的，只要知道工厂类是谁，我就能创建一个需要的对象，省时省力。
2）产品族内的约束为非公开状态。例如生产男女比例的问题上，猜想女娲娘娘肯定有自己的打算，那么在抽象工厂模式中，这些约束都在工厂内里面实现的。
3.2 缺点
抽象工厂模式最大的缺点就是产品族扩展非常困难。如果我们要增加一个产品C，也就是说产品族由原来的A和B增加到3个，那么我们首先要在抽象类AbstractCreator中增加createProductC()方法，然后两个实现类都要修改……说到这里，已经知道了扩展的弊端了……
注意这里是产品族扩展比较困难，而不是产品等级扩展困难。产品等级扩展还是非常容易的，增加一个产品等级，只要增加一个工厂类负责新增加出来的产品生产任务即可。也就是说横向扩展容易，纵向扩展难。
可以这么理解：假如现在要生产戴尔笔记本电脑和华硕笔记本电脑，两个电脑都只有一种型号，那么就可以用工厂模式，我想生产那个就把哪个类的字节码对象传到工厂里，它就可以给我弄出来一台我想要的电脑。假如现在两个电脑都有不同的型号了，比如超薄的和普通的，那我就没法直接扔一个类的字节码进去了吧，工厂怎么知道我要生产哪种类型的呢？现在就需要用抽象工厂模式了，以戴尔为例，将戴尔抽象成抽象类，然后用超薄的和普通的去继承这个抽象类，然后工厂也得抽象出来，专门生产超薄的和专门生产普通的，生产超薄和普通的工厂中分别定义了两个方法，超薄戴尔和超薄华硕，普通戴尔和普通华硕。那现在我就好生产了，如果我想要一台超薄的华硕，那我只要使用生产超薄电脑的工厂，调用里面生产华硕的方法即可。如果我想要一台普通的华硕，那我只要使用生产普通电脑的工厂，调用里面生产华硕的方法即可。