设计模式学习之抽象工厂模式（抽象工厂模式类图）

一、模式定义

抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。

二、主要作用

允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，这样就可以从具体产品中被解耦。

三、解决的问题

解决工厂方法模式的缺点：每个工厂只能创建一类产品。

四、模式原理

4.1、UML类图

4.2、模式组成

如何理解抽象产品族、抽象产品和具体产品的区别呢？请看下图：

4.3、使用步骤

• 创建抽象工厂类，定义具体工厂的公共接口；
• 创建抽象产品族类 ，定义抽象产品的公共接口；
• 创建抽象产品类 （继承抽象产品族类），定义具体产品的公共接口；
• 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
• 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
• 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例。

五、模式优点

1. 降低耦合

抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展。

2. 更符合开-闭原则

新增一种产品类时，只需要增加相应的具体产品类和相应的工厂子类即可。

3. 符合单一职责原则

每个具体工厂类只负责创建对应的产品。

4. 不使用静态工厂方法，可以形成基于继承的等级结构。

六、模式缺点

抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开放——封闭”原则。

七、应用场景

• 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
• 这个系统有多个系列产品，而系统中只消费其中某一系列产品。
• 系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。

八、模式示例

8.1、示例背景

背景：假设有两间塑料加工厂（A厂仅生产容器类产品；B厂仅生产模具类产品）；随着客户需求的变化，A厂所在地的客户需要也模具类产品，B厂所在地的客户也需要容器类产品；

冲突：没有资源（资金+租位）在当地分别开设多一家注塑分厂

解决方案：在原有的两家塑料厂里增设生产需求的功能，即A厂能生产容器+模具产品；B厂间能生产模具+容器产品。

8.2、抽象工厂类

/**
 * @description: 抽象工厂类，定义具体工厂的公共接口
 */
public abstract class Factory {
    /**
     * 生产容器
     *
     * @return
     */
    public abstract AbstractProduct manufactureContainer();


    /**
     * 生产模具
     *
     * @return
     */
    public abstract AbstractProduct manufactureMould();
}

8.3、抽象产品族类

/**
 * @description: 抽象产品族类 ，定义具体产品的公共接口；
 */
public abstract class AbstractProduct {
    /**
     * 展示产品
     */
    public abstract void show();
}

8.4、抽象产品类

8.4.1、容器产品抽象类

/**
 * @description: 抽象产品类--容器 ，定义具体产品的公共接口
 */
public abstract class ContainerProduct extends AbstractProduct {
    @Override
    public abstract void show();
}

8.4.2、模具产品抽象类

/**
 * @description: 抽象产品类--模具 ，定义具体产品的公共接口
 */
public abstract class MouldProduct extends AbstractProduct {
    @Override
    public abstract void show();
}

8.5、具体产品类

8.5.1、容器产品A类

/**
 * @description: 具体产品类--容器A（继承抽象产品类）， 定义生产的具体产品
 */
public class ContainerProductA extends ContainerProduct {
    @Override
    public void show() {
        System.out.println("生产出了容器产品A...");
    }
}

8.5.2、容器产品B类

/**
 * @description: 具体产品类-容器B（继承抽象产品类）， 定义生产的具体产品
 */
public class ContainerProductB extends ContainerProduct {
    @Override
    public void show() {
        System.out.println("生产出了容器产品B...");
    }
}

8.5.3、模具产品A类

/**
 * @description: 具体产品类--模具A（继承抽象产品类）， 定义生产的具体产品
 */
public class MouldProductA extends MouldProduct {


    @Override
    public void show() {
        System.out.println("生产出了模具产品A...");
    }
}

8.5.4、模具产品B类

/**
 * @description: 具体产品类--模具B（继承抽象产品类）， 定义生产的具体产品
 */
public class MouldProductB extends MouldProduct {


    @Override
    public void show() {
        System.out.println("生产出了模具产品B...");
    }
}

8.6、具体工厂类

8.6.1、A厂 - 生产模具+容器产品

/**
 * @description: 具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法
 * A厂 - 生产模具+容器产品
 */
public class FactoryA extends Factory {


    @Override
    public AbstractProduct manufactureContainer() {
        return new ContainerProductA();
    }


    @Override
    public AbstractProduct manufactureMould() {
        return new MouldProductA();
    }
}

8.6.2、B厂 - 生产模具+容器产品

/**
 * @description: 具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法
 * B厂 - 生产模具+容器产品
 */
public class FactoryB extends Factory {


    @Override
    public AbstractProduct manufactureContainer() {
        return new ContainerProductB();
    }


    @Override
    public AbstractProduct manufactureMould() {
        return new MouldProductB();
    }
}

8.7、客户端调用

/**
 * @description: 客户端调用
 */
public class Client {
    public static void main(String[] args) {
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.manufactureContainer().show();
        //A厂当地客户需要模具产品A
        mFactoryA.manufactureMould().show();


        //B厂当地客户需要容器产品B
        mFactoryB.manufactureContainer().show();
        //B厂当地客户需要模具产品B
        mFactoryB.manufactureMould().show();


    }
}