抽象工厂模式——创建型设计模式

● 抽象工厂模式介绍

        重新工厂模式（Abstract Factory Pattern），也是创建型设计模式之一。上一篇我们已经了解工厂方法模式，那么这个抽象工厂又是怎么一回事呢？大家联想一下现实生活中的工厂肯定都是具体的，也就是说每个工厂都会生产某一种具体的产品，那么抽象工厂意味着生产出来的产品是不确定的，那这岂不是很奇怪？抽象工厂模式起源于以前对不同操作系统的图形化解决方案，如不同操作系统中的按钮和文本框控件其实现不同，展示效果也不一样，对于每一个操作系统，其本身就构成一个产品类，而按钮与文本框也构成一个产品类，两种产品类两种变化，各自有自己的特性，如Android中的Button和TextView、IOS中的Button和TextView、Window Phone中的Buttin和TextView等。

● 抽象工厂模式的定义

        为创建一组相关或者是互相依赖的对象提供一个接口，而不需要指定它们的具体类。

● 抽象工厂模式的使用场景

        一个对象族有相同的约束时可以使用抽象工厂模式。是不是听起来很抽象？举个例子，Android、IOS、Window Phone下都有短信软件和拨号软件，两者都属于软件范畴，但是，它们所在的操作系统平台不一样，即便是同一家公司出品的软件，其代码的实现逻辑也是不同的，这时候就可以考虑使用抽象工厂方法模式来生产Android、IOS、Window Phone下的短信软件和拨号软件。

● 抽象工厂模式的UML类图

        UML类图如下图所示：

         根据类图可以得出如下一个抽象工厂模式的通用模式代码。

        抽象产品类A

public abstract class AbstractProductA {

    /**
     *  每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

        抽象产品类B

public abstract class AbstractProductB {

    /**
     *  每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

        具体产品类A1

public class ConcreteProductA1 extends AbstractProductA {

    @Override
    public void method() {
        System.out.println("具体产品A1的方法");
    }
}

        具体产品类A2

public class ConcreteProductA2 extends AbstractProductA {

    @Override
    public void method() {
        System.out.println("具体产品A2的方法");
    }
}

        具体产品类B1

public class ConcreteProductB1 extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("具体产品B1的方法");
    }
}

        具体产品类B2

public class ConcreteProductB2 extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("具体产品B2的方法");
    }
}

        抽象工厂类

public abstract class AbstractFactory {

    /**
     * 创建产品A的方法
     *
     * @return 产品A对象
     */
    public abstract AbstractProductA createPrductA();

    /**
     * 创建产品B的方法
     *
     * @return 产品B对象
     */
    public abstract AbstractProductB createPrductB();
}

        具体工厂类1

public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createPrductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createPrductB() {
        return new ConcreteProductB1();
    }
}

        具体工厂类2

public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createPrductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createPrductB() {
        return new ConcreteProductB2();
    }
}

        虽然抽象工厂方法模式的类繁多，但是，主要还是分为4类。

        （1）AbstractFactory：抽象工厂角色，他声明了一组用于创建一种产品的方法，每一个方法对应一份产品，如上诉类图中AbstracFactory中就定义了两个方法，分别创建产品A和产品B。

        （2）ConcreteFactory：具体工厂角色，它实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如上诉类图中的ConcreteFactory1和ConcreteFactory2。

        （3）AbstractProduct：抽象产品角色，它为每种产品声明接口，比如上诉类图中的AbstractProductA和AbstractProductB。

        （4）ConcretePrduct：具体产品角色，它定义具体工厂生成的具体产品对象，实现抽象产品接口中声明的业务方法，如上诉类图中ConcreteProudctA1、ConcreteProudctA2、ConcreteProudctB1、ConcreteProudctB1。

● 抽象工厂方法模式的简单实现

        在上一篇我们讲过工厂方法模式中，以张三的车厂为了阐述了工厂方法模式，但是，后来张三发现一个问题，虽然Q3、Q5、Q7都是一个车系，但是三者之间的零部件差别却是很大，就拿Q3和Q7来说，Q3使用的发动机是国产的，而Q7则是原装进口的；Q3轮胎是普通轮胎，而Q7则是用的全尺寸越野轮胎；还有Q3使用的是比较普通的制动系统，而Q7则使用的是制动性能极好的制动系统。Q3、Q7对应的是一系列车，而发动机、轮胎、制动系统则对应的一系列零部件，两者是两种不同的产品类型，这时候就可以将抽象工厂模式应用到其中，首先，汽车工厂需要生成轮胎、发动机、制动系统这3种部件。

        抽象车厂类

public abstract class CarFactory {

    /**
     * 生产轮胎
     *
     * @return 轮胎
     */
    public abstract ITire createTire();

    /**
     * 生产发动机
     *
     * @return 发动机
     */
    public abstract IEngine createEnging();

    /**
     * 生产制动系统
     *
     * @return 制动系统
     */
    public abstract IBrake carateBrake();

}

        轮胎相关类

public interface ITire {

    /**
     * 轮胎
     */
    void tire();
}

public class NormalTire implements ITire {
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

public class SUVTire implements ITire {
    @Override
    public void tire() {
        System.out.println("越野轮胎");
    }
}

        发动机相关类

public interface IEngine {

    /**
     * 发动机
     */
    void engine();
}

public class DomesticEnging implements IEngine {
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}

public class ImportEnging implements IEngine {
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

        制动系统相关类

public interface IBrake {

    /**
     * 制动系统
     */
    void brake();
}

public class NormalBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}

public class SeniorBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

        Q3工厂类

public class Q3Factory extends CarFactory {
    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEnging() {
        return new DomesticEnging();
    }

    @Override
    public IBrake carateBrake() {
        return new NormalBrake();
    }
}

        Q7工厂类

public class Q7Factory extends CarFactory{
    @Override
    public ITire createTire() {
        return new SUVTire();
    }

    @Override
    public IEngine createEnging() {
        return new ImportEnging();
    }

    @Override
    public IBrake carateBrake() {
        return new SeniorBrake();
    }
}

        客户类

public class Client {
    public static void main(String[] args) {
        //构造一个生产Q3的工厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEnging().engine();
        factoryQ3.carateBrake().brake();

        System.out.println("--------------------------------------------");

        //构造一个生产Q7的工厂
        CarFactory factoryQ7 = new Q7Factory();
        factoryQ7.createTire().tire();
        factoryQ7.createEnging().engine();
        factoryQ7.carateBrake().brake();
    }
}

        输出结果如下：

普通轮胎
国产发动机
普通制动
--------------------------------------------
越野轮胎
进口发动机
高级制动

        上面我们只是模拟了两个车系Q3和Q7的工厂，如果此时我们需要增加Q5的工厂呢？那么对应的轮胎、制动系统和发动机类又要增加，这里就可以看出抽象工厂方法模式的一个弊端，就是类徒增，如果工厂类过多，势必导致类文件非常多，因此，在实际开发中一定要权衡慎用。