设计模式 --抽象工厂模式 (Abstract Factory Pattern)

---

什么是抽象工厂模式？
定义：为创建一组相关或者相互依赖的对象提供一个接口，而且无需指定它们的具体类。

抽象工厂模式是工厂方法模式的升级版本，中间多加了一层抽象类，在有多个业务品种，业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式，通用类图如下所示：

抽象工厂模式 .png

问题重现：现在有两个产品，分别为产品A与产品B，每个产品都有两个模块：A1,A2 和 B1,B2。现在通过抽象工厂模式来生产各个产品。

抽象产品类：

public abstract class AbstractProductA {
   //公共方法
   public void ShareMethod(){}
   //产品抽象方法
   public abstract void doSomething();
}

public abstract class AbstractProductB {
   //公共方法
   public void ShareMethod(){}
   //产品抽象方法
   public abstract void doSomething();
}

各自产品的实现类：

//产品A的A1模块生产线
public class ProductA1 extends AbstractProductA {
   @Override
   public void doSomething() {
      System.out.println("产品A1的生产线");
   }
}

//产品A的A2模块生产线
public class ProductA2 extends AbstractProductA {
   @Override
   public void doSomething() {
      System.out.println("产品A2的生产线");
   }
}

//产品B的B1模块生产线
public class ProductB1 extends AbstractProductB {
   @Override
   public void doSomething() {
      System.out.println("产品B1的生产线");
   }
}

//产品B的B2模块生产线
public class ProductB2 extends AbstractProductB {
   @Override
   public void doSomething() {
      System.out.println("产品B2的生产线");
   }
}

抽象工厂类：

//定义两条生产线
public abstract class AbstractFactory {
   //创建A产品的生产线
   public abstract AbstractProductA createProductA();
   //创建B产品的生产线
   public abstract AbstractProductB createProductB();
}

工厂实现类：

public class Factory1 extends AbstractFactory {
   @Override
   //A产品线生产A1产品
   public AbstractProductA createProductA() {
      return new ProductA1();
   }
   
   @Override
   //B产品线生产B1产品
   public AbstractProductB createProductB() {
      return new ProductB1();
   }
}

public class Factory2 extends AbstractFactory {
   @Override
   //A产品线生产A2产品
   public AbstractProductA createProductA() {
      return new ProductA2();
   }
   
   @Override
   //B产品线生产B2产品
   public AbstractProductB createProductB() {
      return new ProductB2();
   }
}

客户端类：

public class Client {
   public static void main(String[] args) {
      //定义两个工厂
      AbstractFactory factory1 = new Factory1();
      AbstractFactory factory2 = new Factory2();
      //产生各类对象
      AbstractProductA productA1 = factory1.createProductA();
      AbstractProductA productA2 = factory2.createProductA();
      AbstractProductB productB1 = factory1.createProductB();
      AbstractProductB productB2 = factory2.createProductB();
      productA1.doSomething();
      productA2.doSomething();
      productB1.doSomething();
      productB2.doSomething();
   }
}
-------------------output-----------------------
产品A1的生产线
产品A2的生产线
产品B1的生产线
产品B1的生产线

在客户端类中并没有涉及到产品的实现类，对于一个产品而言，我们不需要知道它的实现类，只需要知道它的工厂方法就可以直接产生一个产品对象。

抽象工厂模式的优点
①封装性：高层模块不需要知道每个产品的实现类，它只关心接口和抽象，对象由工厂类负责创建，我只需要知道工厂类就能创建对应的对象。
②产品内部约束是不对外公开的：比如产品A和B有一定的比例关系，这个比例关系对外界来讲是不透明的，只需要在工厂中实现对应的比例。

抽象工厂模式的缺点
抽象工厂模式最大的缺点是产品类扩展困难，比如上述代码中要是再增加一个产品C，那么在抽象产品类及其实现类，抽象工厂类及其实现类均需要修改代码，严重违反了开闭原则。

使用场景
如果存在一组对象（相互之间可以有关系也可以没有关系）都有相同的约束，那么可以使用抽象工厂模式。

参考书籍：设计模式之禅 --- 秦小波 著