设计模式-抽象工厂模式

设计模式-抽象工厂模式

• 定义

  为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类

  我们知道工厂常常会生产多个产品，而这些产品又有一定的关联性和相互的影响，比如杯子 和杯盖 组成了一个杯子，杯子和杯盖又有不同的颜色，这时候就可以使用抽象工厂方式

• 代码

  定义抽象产品A和抽象产品B

  public abstract class AbstractProductA {
  
      public abstract void  say();
  
  }
  

  public abstract class AbstractProductB {
  
      public abstract void say();
  
  }
  

  抽象产品A 和抽象产品B 的实现类，产品A和B 分别有对应的两个系列

  public class ProductA1 extends AbstractProductA {
      @Override
      public void say() {
          System.out.println("product A1");
      }
  }
  

  public class ProductA2 extends AbstractProductA {
      @Override
      public void say() {
          System.out.println("product A2");
      }
  }
  

  public class ProductB1 extends AbstractProductB {
  
      @Override
      public void say() {
          System.out.println("product B1");
      }
  }
  

  public class ProductB2 extends AbstractProductB {
      @Override
      public void say() {
          System.out.println("product B2");
      }
  }
  

  定义一个抽象的工厂，生产A和B

  public abstract class AbstractProductFactory {
      public abstract AbstractProductA createProductA();
      public abstract AbstractProductB createProductB();
  }
  

  产品系列的工厂实现

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

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

  产品1和产品2工厂都生产产品A和B，但是生产的该系列的产品

  下面测试:

  	@Test
      public void testAbstractFactory(){
          AbstractProductFactory f1 = new Product1Factory();
          AbstractProductFactory f2 = new Product2Factory();
          AbstractProductA a1 =  f1.createProductA();
          AbstractProductB b1 =  f1.createProductB();
          AbstractProductA a2 =  f2.createProductA();
          AbstractProductB b2 =  f2.createProductB();
          a1.say();
          a2.say();
          b1.say();
          b2.say();
      }
  
  

  输出：

  product A1 product A2 product B1 product B2

  从测试可以看出，在生产产品的时候并没有用到具体的产品实现类，只要知道改系列的工厂就能生产不同的系列的产品，并不关心具体的实现类