Factory pattern(抽象工厂模式）

抽象工厂(AbstractFactory) 模式的定义： 是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

工厂方法模式针对多个产品系列结构，例如畜牧场只养动物、电视机厂只生产电视机、洗衣机厂只生产洗衣机等（工厂方法模式只考虑一类产品的生产）
抽象工厂模式针对多个产品族结构，例如电器厂既生产电视机有生产微波炉、冰箱、路由器等（抽象工厂模式将考虑多等级产品的生产，不同等级的一组产品称之为产品族）

抽象工厂模式（Abstract Factory Pattern）是一个超级工厂创建其他工厂即（工厂之工厂）.
工厂方法模式产生多个产品系列结构，抽象工厂模式针对多个产品族结构。即一个产品族内有多个产品系列。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可以生产多个等级的产品。

使用抽象工厂模式的场景

  * 系统中有多个产品组，每个具体工厂创建同一族但不同等级结构的产品（即要创建一个产品族）
  * 一个产品族中具体产品之间是一个组合关系即同族产品一起使用
  * 提供一个产品类库，而只想显示它们的接口而不是实现时。

抽象工厂模式优点

  - 可以在类内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
  - 当增加一个新的产品族时不需要修改原代码，满足开闭原则。

缺点： 当产品族需要增加一个新的产品时，所有的工厂类都需要更改

抽象工厂模式的结构图

抽象工厂模式具体实现

产品的种类（对象的类型是多个）

• 抽象工厂： 提供产品的生成方法

interface AbstractFactory{
      public Product1 newProduct1();
      public Product2 newProduct2();
}

• 具体工厂：实现产品的生成方法

class ConcreteFactory1 implements AbstractFactory{
      public Product1 new Product1(){
            System.out.println("具体工厂 1 生成 --> 具体产品 11 ...");
            return new ConcreteProduct1();
      }
 
      public Product2 new Product1(){
            System.out.println("具体工厂 2 生成 --> 具体产品 21 ...");
            return new ConcreteProduct21();
      }
}

实例

假设两个电脑工厂不仅要生产鼠标还要生产键盘，PC厂商是父类，存在生产🖱、生产⌨️两个接口。A工厂和B工厂继承PC工厂可以分别生成A鼠标+A键盘和B鼠标+B键盘。

• 类图

• 实例代码

抽象工厂模式： 提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类。
当产品只有一个的时候，抽象工厂模式即转变成工厂模式
当工厂模式的产品变为多个（级别不同）时，工厂模式即变成抽象产品模式

/**
 * 产品类接口：Mouse
 * */
interface Mouse{
    public abstract void printInfo();
}
 
/**
 * 产品类
 * */
class AMouse implements Mouse{
    @Override
    public void printInfo() {
        System.out.println("Mouse made in A工厂 -> PCFactory");
    }
}
 
/**
 * 产品类
 * */
class BMouse implements Mouse{
    @Override
    public void printInfo() {
       System.out.println("Mouse made in B工厂 -> PCFactory");
    }
}
 
/**
 * 产品类接口： KeyBoard
 * */
interface KeyBoard{
    public abstract void printInfo();
}
 
/**
 * 产品类
 * */
class AKeyBoard implements KeyBoard{
    @Override
    public void printInfo() {
        System.out.println("KeyBoard made in A工厂 -> PCFactory");
    }
}
 
/**
 * 产品类
 * */
class BKeyBoard implements KeyBoard{
    @Override
    public void printInfo() {
        System.out.println("KeyBoard made in B工厂 -> PCFactory");
    }
}
 
/**
 *  抽象工厂 PCFactory
 * */
abstract class PCFactory{
    public abstract Mouse createMouse();
    public abstract KeyBoard createKeyBoard();
}
 
/**
 *  抽象工厂实现类
 * */
class AFactory extends PCFactory{
 
    @Override
    public Mouse createMouse() {
        return new AMouse();
    }
 
    @Override
    public KeyBoard createKeyBoard() {
        return new AKeyBoard();
    }
}
 
/**
 *  抽象工厂实现类
 * */
class BFactory extends PCFactory{
 
    @Override
    public Mouse createMouse() {
        return new BMouse();
    }
 
    @Override
    public KeyBoard createKeyBoard() {
        return new BKeyBoard();
    }
}
 
public class FactoryPatternSampleSpace {
    public static void main(String[] args) {
        PCFactory pcFactoryA = new AFactory();
        PCFactory pcFactoryB = new BFactory();
        KeyBoard keyBoard = pcFactoryA.createKeyBoard();
        Mouse mouse = pcFactoryB.createMouse();
        keyBoard.printInfo();
        mouse.printInfo();
    }
}
// 输出
KeyBoard made in A工厂 -> PCFactory
Mouse made in B工厂 -> PCFactory

参考：

• http://c.biancheng.net/view/1351.html
• https://www.runoob.com/design-pattern/abstract-factory-pattern.html
• https://baike.baidu.com/item/抽象工厂模式