设计模式抽象工厂模式

• 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

• 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

• 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

• 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

• 注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

实例

• 我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。
• AbstractFactoryPatternDemo 类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

步骤 1

• 为形状创建一个接口，并创建实现接口的实体类。

public interface Shape {
   void draw();
}

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.");
   }
}

步骤 2

• 为颜色创建一个接口，并创建实现接口的实体类。

public interface Color {
   void fill();
}

public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}

public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}

public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}

步骤 3

• 为 Color 和 Shape 对象创建抽象类来获取工厂，创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

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

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
    public 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;
    }
}

步骤 4

• 创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

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;
    }
}

步骤 5

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

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();
   }
}

• 执行程序，输出结果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.