设计模式(3/23) - 抽象工厂模式抽象工厂模式 1 概述抽象工厂模式（Abstract Factory Patte

抽象工厂模式

1 概述

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。

2 优缺点及应用场景

2.1 优点

1）分离接口与实现：客户端通过抽象接口操作具体对象，无需知道具体实现类。
2）一致的产品族创建：保证同一产品族中的产品相互兼容。
3）遵循开闭原则：新增产品族时，只需增加具体工厂和具体产品类，无需修改现有代码

2.2 缺点

1）增加复杂性：每新增一个产品族都需要增加相应的工厂和产品类。
2）难以支持新种类的产品：增加新种类的产品需要修改抽象工厂接口，影响所有具体工厂。

2.3 应用场景

1）换皮肤时，整套皮肤一起更换。
2）创建跨平台应用时，生成不同操作系统的程序。

3 结构

1）抽象工厂（Abstract Factory）：声明了一组用于创建产品对象的方法，每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
2）具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体产品对象的实例。
3）抽象产品（Abstract Product）：定义了一组产品对象的共同接口或抽象类，描述了产品对象的公共方法。
4）具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
抽象工厂模式通常涉及一族相关的产品，每个具体工厂类负责创建该族中的具体产品。客户端通过使用抽象工厂接口来创建产品对象，而不需要直接使用具体产品的实现类。

4 实现

4.1 UML 类图

抽象工厂模式.jpg

4.2 代码示例

// 为形状创建一个接口
interface Shape {
  void draw();
}

// 创建实现接口的实体类：长方形
class Rectangle implements Shape {
  @Override
  public void draw() {
    System.out.println("Inside Rectangle::draw() method.");
  }
}

// 创建实现接口的实体类：正方形
class Square implements Shape {
  @Override
  public void draw() {
    System.out.println("Inside Square::draw() method.");
  }
}

// 创建实现接口的实体类：圆形
class Circle implements Shape {
  @Override
  public void draw() {
    System.out.println("Inside Circle::draw() method.");
  }
}

// 为颜色创建一个接口
interface Color {
  void fill();
}

// 创建实现接口的实体类：红色
class Red implements Color {
  @Override
  public void fill() {
    System.out.println("Inside Red::fill() method.");
  }
}

// 创建实现接口的实体类：绿色
class Green implements Color {
  @Override
  public void fill() {
    System.out.println("Inside Green::fill() method.");
  }
}

// 创建实现接口的实体类：蓝色
class Blue implements Color {
  @Override
  public void fill() {
    System.out.println("Inside Blue::fill() method.");
  }
}

// 为 Color 和 Shape 对象创建抽象类来获取工厂
abstract class AbstractFactory {
  public abstract Color getColor(String color);

  public abstract Shape getShape(String shape);
}

// 创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象：形状工厂
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;
  }
}

// 创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象：颜色工厂
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;
  }
}

// 创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂
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;
  }
}

// 使用 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.

5 总结

抽象工厂模式通过定义抽象工厂和抽象产品类，使得客户端能够创建一系列相关或相互依赖的对象，而无需指定具体类。它适用于需要创建一组相关产品对象的情况。虽然增加了系统的复杂性，但也提高了代码的灵活性和可扩展性，确保了产品族的一致性和互操作性。