设计模式：抽象工厂模式，结合类图秒懂！

通过前篇文章的介绍，我们对工厂模式有了深入的了解，今天继续介绍一种特殊的工厂模式，也就是抽象工厂模式。

定义

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为kit模式，属于对象创建型模式，是工厂方法模式的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

抽象工厂模式包含了几个角色：

abstractfactory：用于声明生成抽象产品的方法

concretefactory：实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；

abstractproduct：为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；

product：定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。

这是它的通用类图：

其中 abstractproducta 和 abstractproductb 就是两个产品族的抽象类 (或者接口)，而 product1 和 product2 就是产品族下的具体产品类，abstractcreator 就是工厂的抽象。

我们可以用操作系统来举例，现在市面上用的最多的两种pc端操作系统是windows和linux，两个系统都有共同类型的组件，如文件夹，按钮，文本等。套用下抽象工厂的通用类图，我们不难发现，两个系统就相当于产品组抽象类abstractproducta 和 abstractproductb，而按钮、文本这些组件就是具体的产品类。

然后再来分析一下，如果有一个应用要在两个系统上运行，应该怎么设计？是编写两套程序运行于不同的系统上？这样实在是太浪费资源了，我们可以通过抽象工厂模式屏蔽掉操作系统对应用的影响。软件功能、逻辑、ui 都一个非常类似，唯一的不同是调用不同的工厂方法，由不同的产品类去处理与操作系统交互的信息，而这就是抽象工厂的优势。

代码编写

抽象工厂的通用类图我们已经了解了，下面就是具体代码的实现：

产品族的抽象类，abstractproducta 和 abstractproductb，

public abstract class abstractproducta {
    //每个产品共有的方法
    public void sharemethod() {
    }

    // 每个产品相同方法，不同实现
    public abstract void dosomething();
}

public abstract class abstractproductb {
    //每个产品共有的方法
    public void sharemethod() {
    }

    // 每个产品相同方法，不同实现
    public abstract void dosomething();
}

两个产品族的具体实现类代码，

public class producta1 extends abstractproducta {
    public void dosomething() {
        system.out.println("我是产品a1");
    }
}

public class producta2 extends abstractproducta {
    public void dosomething() {
        system.out.println("我是产品a2");
    }
}

public class productb1 extends abstractproductb {
    public void dosomething() {
        system.out.println("我是产品b1");
    }
}
public class productb2 extends abstractproductb {
    public void dosomething() {
        system.out.println("我是产品b2");
    }
}

抽象工厂类abstractcreator，有n个产品族，在抽象工厂类中就应该有n个创建方法。我们这里定义两个产品族的产品创建，代码如下：

public abstract class abstractcreator {
    //创建a产品
    public abstract abstractproducta createproducta();

    //创建b产品
    public abstract abstractproductb createproductb();
}

然后是创建产品的具体工厂，有n个产品等级就应该有n个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务。

public class creator1 extends abstractcreator {
    public abstractproducta createproducta() {
        return new producta1();
    }

    public abstractproductb createproductb() {
        return new productb1();
    }
}
public class creator2 extends abstractcreator {
    public abstractproducta createproducta() {
        return new producta2();
    }

    public abstractproductb createproductb() {
        return new productb2();
    }
}

到此为止，我们把所有的角色都创建出来了，最后设计一个场景类，验证下是否能输出对应产品的信息，

public class client {
    public static void main(string[] args) {
        //定义出两个工厂
        abstractcreator creator1 = new creator1();
        abstractcreator creator2 = new creator2();
        //产生a1对象
        abstractproducta a1 = creator1.createproducta();
        //产生a2对象
        abstractproducta a2 = creator2.createproducta();
        //产生b1对象
        abstractproductb b1 = creator1.createproductb();
        //产生b2对象
        abstractproductb b2 = creator2.createproductb();
        a1.dosomething();
        a2.dosomething();
        b1.dosomething();
        b2.dosomething();
    }
}

运行的结果为：

我是产品a1
我是产品a2
我是产品b1
我是产品b2

总结

总结下抽象工厂模式的特点，抽象工厂是所有形式的工厂模式中最为抽象和最具一般性的一种形态，其优缺点大致如下：

1、隔离了具体类的生成，使得客户并不需要知道什么被创建，具有良好的封装性。

2、横向扩展容易。同个产品族如果需要增加多个 产品，只需要增加新的工厂类和产品类即可。

3、纵向扩展困难。如果增加新的产品组，抽象工厂类也要添加创建该产品组的对应方法，这样一来所有的具体工厂类都要做修改了，严重违背了开闭原则。

参考：
《设计模式之禅》