设计模式三--抽象工厂模式

定义

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

解释

通俗点，抽象工厂模式就是工厂模式的升级版本，抽象工厂类是工厂类的工厂，当业务产生了产品族群，可以通过它获取生产某一个产品的工厂

抽象工厂的角色

思考良久，还是觉得使用一个最经典的案例，代码出处：
http://www.runoob.com/design-pattern
如有侵权，请联系我删除
1：抽象工厂（AbstractFactory）
该角色是抽象工厂模式的核心，与应用系统无关，任何创建对象的工厂类必须实现这个接口

public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape) ;
}

2：具体工厂（ConcreteFactory）
该角色实现了抽象工厂，含有选择合适的产品对象的逻辑，并且受到应用程序的调用以创建产品对象

具体形状工厂类

public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}

具体颜色工厂类（颜色并不是一个产品，所以没有进行抽象）

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

3：抽象产品（AbstractProduct）
该角色负责定义产品的共性，实现对产品最抽象的定义

public interface Shape {
   void draw();
}

4：具体产品（ConcreteProduct）
该角色实现抽象产品角色声明的接口，抽象工厂所创建的每个产品对象都是某个具体产品的实例
长方形

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

正方形

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

圆形

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

抽象工厂模式重点
一个获取工厂的工厂生成器

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

具体业务代码调用

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
 
      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
 
      //调用 Red 的 fill 方法
      color1.fill();
 
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("Green");
 
      //调用 Green 的 fill 方法
      color2.fill();
 
      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");
 
      //调用 Blue 的 fill 方法
      color3.fill();
   }
}

代码解读

1：形状工厂负责创建形状，不会实现颜色的功能，同理颜色工厂也不会负责生产形状
2：通过高度抽象，来获取一个形状工厂，获取一个颜色工厂，通过不同颜色和形状，组成图形

优点

除了工厂模式以外的优点，抽象工厂还拥有以下优点：
1：产品的依赖，不会被公开，对使用者不可见
2：生产线容易扩展，建立新的生产线只需要实现产品族中的所有产品接口并建立新的工厂类

缺点

产品族本身的扩展比较复杂，需要修改已有接口等等

使用场景

1：应用需要涉及不同操作系统的时候
2：产品族群非常庞大的时候

参考资料：
  设计模式之禅（二）
  菜鸟教程 http://www.runoob.com