（ 七 ）、设计模式 之 抽象工厂模式（ObstractFactory）

（ 七 ）、设计模式 之 抽象工厂模式（ObstractFactory）

 

 

1、简介

 前面介绍的  工厂方法模式  中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。
同种类称为同等级，也就是说： 工厂方法模式  只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。
本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，图 1 所示的是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。

 

2、模式的定义与特点

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。
使用抽象工厂模式一般要满足以下条件：

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下：

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的 抽象性 和 理解难度。

 

3、模式的结构与实现

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

1. 模式的结构

抽象工厂模式的主要角色如下。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

抽象工厂模式的结构图  如图所示：

2. 模式的实现

从图 2 可以看出抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。下面给出抽象工厂和具体工厂的代码。

/**
 * @Author dw
 * @ClassName AbstractFactory
 * @Description 抽象工厂接口， 声明创建一系列抽象产品对象的操作。通常是一个产品簇。
 * AbstractFactory 在 Java中通常实现成为接口，大家不要被名称误导了，以为是实现成为抽象类。当然，如果需要为这个产品簇提供公共的功能，
 * 也不是不可以把AbstractFactory 实现成为抽象类，但一般不这么做。
 * 抽象工厂的功能是为一系列相关对象或相互依赖的对象创建一个接口。一定要注意这个接口内的方法不是任意堆砌的，而是一系列相关或相互依赖的方法，
 * 比如CPU和主板，都是为了组装一台电脑的相关对象。从某种意义上看，抽象工厂其实是一个产品系列，或者是产品簇。 例如：每个不同的装机方案，
 * 代表一种具体的电脑系列。
 * @Date 2023/8/18 14:35
 * @Version 1.0
 */
public interface AbstractFactory {

    /**
     * 示例方法，创建抽象产品A的对象
     * @return 抽象产品A
     */
    public AbstractProductA createProductA();

    /**
     * 示例方法，创建抽象产品B的对象
     * @return 抽象产品B
     */
    public AbstractProductB createProductB();

}


/**
 * @Author dw
 * @ClassName ConcreteFactory1
 * @Description 具体的工厂实现对象，实现创建具体的产品对象的操作
 * @Date 2023/8/18 14:52
 * @Version 1.0
 */
public class ConcreteFactory1 implements AbstractFactory{

    /**
     * 示例方法，创建具体产品A的对象
     *
     * @return 具体产品A
     */
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    /**
     * 示例方法，创建具体产品B的对象
     *
     * @return 具体产品B
     */
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}


/**
 * @Author dw
 * @ClassName ConcreteFactory2
 * @Description 具体的工厂实现对象，实现创建具体的产品对象的操作
 * @Date 2023/8/18 14:52
 * @Version 1.0
 */
public class ConcreteFactory2 implements AbstractFactory{

    /**
     * 示例方法，创建具体产品A的对象
     *
     * @return 具体产品A
     */
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    /**
     * 示例方法，创建具体产品B的对象
     *
     * @return 具体产品B
     */
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}



/**
 * @Author dw
 * @ClassName AbstractProductA
 * @Description 抽象产品A的接口
 * @Date 2023/8/18 14:39
 * @Version 1.0
 */
public interface AbstractProductA {
    // 定义一系列抽象产品A的操作
}



/**
 * @Author dw
 * @ClassName AbstractProductB
 * @Description 抽象产品B的接口
 * @Date 2023/8/18 14:39
 * @Version 1.0
 */
public interface AbstractProductB {
   // 定义一系列抽象产品B的操作
}



/**
 * @Author dw
 * @ClassName ProductA1
 * @Description ProductA 产品1的具体实现
 * @Date 2023/8/18 14:48
 * @Version 1.0
 */
public class ProductA1 implements AbstractProductA{


}


/**
 * @Author dw
 * @ClassName ProductA2
 * @Description ProductA 产品2的具体实现
 * @Date 2023/8/18 14:48
 * @Version 1.0
 */
public class ProductA2 implements AbstractProductA{
    
}


/**
 * @Author dw
 * @ClassName ProductB1
 * @Description ProductB 产品B1的具体实现
 * @Date 2023/8/18 14:48
 * @Version 1.0
 */
public class ProductB1 implements AbstractProductB {
    
}


/**
 * @Author dw
 * @ClassName ProductB2
 * @Description ProductB 产品B2的具体实现
 * @Date 2023/8/18 14:48
 * @Version 1.0
 */
public class ProductB2 implements AbstractProductB {
    
}


/**
 * @Author dw
 * @ClassName ClientTest
 * @Description 客户端使用测试
 * @Date 2023/8/18 15:03
 * @Version 1.0
 */
public class ClientTest {

    public static void main(String[] args) {
        ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
        AbstractProductA productA = concreteFactory1.createProductA();
        AbstractProductB productB = concreteFactory1.createProductB();
        // ...面向这些产品对象的接口编程，以实现需要的功能
    }
}

 

4、模式的应用场景

抽象工厂模式通常适用于以下场景：

1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2. 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
3. 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。