抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

场景

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

实现

源码来自于《设计模式之禅》

抽象产品类A
  1. public abstract class AbstractProductA {
  2.     public void shareMethod(){
  3.        // 每个产品共有的方法
  4.     }
  5.     public abstract void doSomething();
  6. }

产品A1的实现类
  1. public class ProductA1 extends AbstractProductA {
  2.     @Override
  3.     public void doSomething() {
  4.         System.out.println("产品A1的实现方法");
  5.     }
  6. }

产品A2的实现类
  1. public class ProductA2 extends AbstractProductA {
  2.     @Override
  3.     public void doSomething() {
  4.         System.out.println("产品A2的实现方法");
  5.     }
  6. }

抽象产品类B
  1. public abstract class AbstractProductB {
  2.     public void shareMethod(){
  3.        // 每个产品共有的方法
  4.     }
  5.     public abstract void doSomething();
  6. }

产品B1的实现类
  1. public class ProductB1 extends AbstractProductB {
  2.     @Override
  3.     public void doSomething() {
  4.         System.out.println("产品B1的实现方法");
  5.     }
  6. }

产品B2的实现类
  1. public class ProductB2 extends AbstractProductB {
  2.     @Override
  3.     public void doSomething() {
  4.         System.out.println("产品B2的实现方法");
  5.     }
  6. }

抽象工厂类
  1. public abstract class AbstractCreator {
  2.     /** 创建A产品家族 */
  3.     public abstract AbstractProductA createProductA();
  4.     /** 创建B产品家族 */
  5.     public abstract AbstractProductB createProductB();
  6. }

有N个产品族，在抽象共产类中就应该有N个创建方法。

实现产品等级1的实现类
  1. public class Creator1 extends AbstractCreator {
  3.     /** 只生产产品等级为1的A产品 */
  4.     public AbstractProductA createProductA() {
  5.         return new ProductA1();
  6.     }
  8.     /** 只生产产品等级为1的B产品 */
  9.     public AbstractProductB createProductB() {
  10.         return new ProductB1();
  11.     }
  12. }

实现产品等级2的实现类
  1. public class Creator2 extends AbstractCreator {
  3.     /** 只生产产品等级为2的A产品 */
  4.     public AbstractProductA createProductA() {    
  5.         return new ProductA2();
  6.     }
  8.     /** 只生产铲平等级为2的B产品 */
  9.     public AbstractProductB createProductB() {
  10.         return new ProductB2();
  11.     }
  12. }

有M个产品等级就应该有M个实现工厂类，在每个实现工厂类中实现不同产品族的生产创造

优点

  • 封装性，每个产品的实现类不是上层模块要关心的，它不关心对象是如何创建出来，只需要关心接口抽象
  • 产品族内的约束为非公开状态，生产过程对调用工厂类的高层模块来说是透明的

缺点

  • 产品族扩展非常困难，如果要增加一个产品C，也就是说有产品家族由原来的2个，增加到3个，抽象类AbstractCreator要增加一个方法createProductC()，然后，两个实现类都要修改，严重违反了开闭原则

工厂方法模式与抽象工厂模式比较

  • 在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法具有唯一性。
  • 抽象工厂模式则可以提供多个产品对象，而不是单一的产品对象。

Android 中的应用

暂未找到合适的例子
掘金看到：WebViewFactoryProvider和WebViewChromiumFactoryProvider，未做深入

参考

书籍：《设计模式之禅》、《Android源码设计模式》
技术文章：菜鸟教程-设计模式