抽象工厂模式

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

通用类图

• 抽象工厂模式的通用类图
  
• 抽象工厂模式的通用源码类图
  

抽象工厂模式的通用源码

• 抽象产品类A

  public abstract class AbstractProductA {
  
      /**
       * 没个产品共有的方法
       */
      public void shareMethod(){
  
      }
  
      /**
       * 每个产品相同方法，不同实现
       */
      public abstract void doSomething();
  }
  

• 抽象产品类B

  public abstract class AbstractProductB {
  
      /**
       * 每个产品共有的方法
       */
      public void shareMethod() {
  
      }
  
      /**
       * 每个产品相同方法，不同实现
       */
      public abstract void doSomething();
  }
  

• 产品A1的实现类

  public class ProductA1 extends AbstractProductA {
  
      @Override
      public void doSomething() {
          System.out.println("产品A1的实现方法");
      }
  }
  

• 产品A2的实现类

  public class ProductA2 extends AbstractProductA {
  
      @Override
      public void doSomething() {
          System.out.println("产品A2的实现方法");
      }
  }
  

• 产品B1的实现类

  public class ProductB1 extends AbstractProductB {
  
      @Override
      public void doSomething() {
          System.out.println("产品B1的实现方法");
      }
  }
  

• 产品B2的实现类

  public class ProductB2 extends AbstractProductB {
  
      @Override
      public void doSomething() {
          System.out.println("产品B2的实现方法");
      }
  }
  

• 抽象工厂类

  public abstract class AbstractCreator {
  
      /**
       * 创建A产品家族
       * @return
       */
      public abstract AbstractProductA createProductA();
  
      /**
       * 创建B产品家族
       * @return
       */
      public abstract AbstractProductB createProductB();
  }
  

• 产品等级1的实现类

  public class Creator1 extends AbstractCreator {
  
      @Override
      public AbstractProductA createProductA() {
          return new ProductA1();
      }
  
      @Override
      public AbstractProductB createProductB() {
          return new ProductB1();
      }
  }
  

• 产品等级2的实现类

  public class Creator2 extends AbstractCreator {
  
      @Override
      public AbstractProductA createProductA() {
          return new ProductA2();
      }
  
      @Override
      public AbstractProductB createProductB() {
          return new ProductB2();
      }
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          AbstractCreator creator1 = new Creator1();
          AbstractCreator creator2 = new Creator2();
  
          AbstractProductA productA1 = creator1.createProductA();
          AbstractProductB productB1 = creator1.createProductB();
  
          AbstractProductA productA2 = creator2.createProductA();
          AbstractProductB productB2 = creator2.createProductB();
  
          productA1.doSomething();
          productA2.doSomething();
          productB1.doSomething();
          productB2.doSomething();
      }
  }
  

抽象工厂模式的优点

• 封装性，每个产品的实现类不是高层模块要关心的，它关心的是接口，是抽象，不关心对象的是如何创建出来的。
• 产品族内的约束为非公开状态，比如生成男女比例问题。

抽象工厂模式的缺点

产品族扩展非常困难，如产品从ProductA和ProductB，增加ProductC，这时AbstractCreator类中要增加一个方法createProductC()，接着还有ProductC衍生出来的类要实现。违背了开闭原则。

抽象工厂模式的使用场景

一个对象族（或者一组没有任何关系的对象）都有相同的约束，则抽象工厂模式非常适用。

举例：需要在三个不同的平台（Windows、Linux、Max）上运行同一个软件，三个不同操作系统的软件功能、应用逻辑、UI都应该是类似的。唯一不同的调用不同的工厂方法。