工厂模式之抽象工厂模式

前面介绍了简单工厂模式和工厂方法模式，前面两种模式都适用于只有一种产品等级结构的情形。也即只有一个抽象的产品接口

public interface Product {}的情况。例如一个水果农场，只需一个抽象的水果接口作为具体的产品抽象即可。而抽象工厂模式适用于有多个产品等级结构的情形，例如该农场扩大规模不仅产水果，还要产蔬菜。此种情况下会有多个抽象的产品接口，此时可以使用抽象工厂模式。

首先了解两个概念：产品等级结构和产品族。

产品族：很多不同的产品，但是这些产品具有一个共同的特征。

产品等级结构：只能是同一类产品，但是可以具有不同的特点。

具体例子：热带水果，热带蔬菜，亚热带水果，亚热带蔬菜。抽象一下的话，产品族是：热带和亚热带，产品等级结构是：水果和蔬菜。

抽象工厂模式的一个示意性系统中几个角色：

• 抽象工厂角色（Creator）：这个角色是工厂方法模式的核心，它是与应用程序无关的。任何在模式中创建对象的工厂类必须实现这个接口。
• 具体工厂角色（Concrete Creator）：这个角色是实现了抽象工厂接口的具体类。具体工厂角色含有与应用密切相关的逻辑，并且受到应用程序的调用以创建产品对象。
• 抽象产品角色（Product）：工厂方法模式所创建对象的超类型
• 具体产品角色（Concrete Product）：该角色实现了抽象产品角色所声明的接口，工厂方法模式所创建的每一个对象都是对应的产品角色的实例。

  /*
   * 抽象工厂角色源代码
   * 规定了两个工厂方法，分别提供两个不同等级结构的产品对象。
   * */
  public interface Creator {
  	/*
  	 * 产品等级结构A的工厂方法
  	 * */
      public ProductA factoryA();
      /*
       * 产品等级结构B的工厂方法
       * */
      public ProductB factoryB(); 
  }
  

  /*
   * 具体工厂ConcreteCreator1的源代码
   * */
  public class ConcreteCreator1 implements Creator {
  
  	/*
  	 * 产品等级结构A的工厂方法
  	 * */
  	@Override
  	public ProductA factoryA() {
  		// TODO Auto-generated method stub
  		return new ProductA1();
  	}
  
  	/*
  	 * 产品等级结构B的工厂方法
  	 * */
  	@Override
  	public ProductB factoryB() {
  		// TODO Auto-generated method stub
  		return new ProductB1();
  	}
  
  }
  

  /*
   * 具体工厂ConcreteCreator1的源代码
   * */
  public class ConcreteCreator2 implements Creator {
  
  	/*
  	 * 产品等级结构A的工厂方法
  	 * */
  	@Override
  	public ProductA factoryA() {
  		// TODO Auto-generated method stub
  		return new ProductA2();
  	}
  
  	/*
  	 * 产品等级结构B的工厂方法
  	 * */
  	@Override
  	public ProductB factoryB() {
  		// TODO Auto-generated method stub
  		return new ProductB2();
  	}
  
  }
  

  /*
   * 抽象产品A的源代码
   * */
  public interface ProductA {
  
  }
  /*
   * 具体产品A1的源代码
   * */
  public class ProductA1 implements ProductA {
  	public ProductA1(){
  		
  	}
  }
  /*
   * 具体产品A2的源代码
   * */
  public class ProductA2 implements ProductA {
  	public ProductA2(){
  		
  	}
  }
  

  /*抽象产品B的源代码*/
  public interface ProductB {
  
  }
  /*
   * 具体产品B1的源代码
   * */
  public class ProductB1 implements ProductB {
  	public ProductB1(){
  		
  	}
  }
  /*
   * 具体产品B2的源代码
   * */
  public class ProductB2 implements ProductB {
  	public ProductB2(){
  		
  	}
  }
  

  /*
   * 客户端源代码
   * */
  public class Client {
  	public static void main(String[] args) {
  		Creator creator1=new ConcreteCreator1();
  		ProductA productA1=creator1.factoryA();
  		ProductB productB1=creator1.factoryB();
  		
  		Creator creator2=new ConcreteCreator2();
  		ProductA productA2=creator2.factoryA();
  		ProductB productB2=creator2.factoryB();
  	}
  }
  

   “开闭原则”要求一个软件系统可以在不修改原来代码的情况下，通过扩展达到其增强功能的目的。那么：

• 增加产品族
• 增加产品等级结构

      这两种情况的改变，抽象工厂模式会有什么支持呢？

      1.增加产品族

　　　这种情况下，设计师只要增加新的具体工厂即可，对于本系统设计师可以增加public class ConcreteCreator2 implements Creator（）{}来增加第三个产品族，不用改变原来的代码结构，因此在增加产品族的时候，系统支持“开闭原则”。

      2.增加产品等级结构

         这种情况下，相当于出现了第三种产品productC，因此不得不改变改变原来的代码，这显然违背了“开闭原则”。

     总结一下：抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，而不能为新的产品等级结构的增加提供方便。