抽象工厂模式

  1. 抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类
  2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
  3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。

  4. 将工厂抽象成两层， AbsFactory( 抽象工厂 ) 和 具体实现的工厂子类。可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

    分析实现步骤

    类图
    image.png

  5. 创建抽象类(不变)

  6. 创建地域特色的产品类
  7. 创建接口抽象工厂
  8. 创建具体实现抽象工厂的子类工厂
  9. 预定类实现
  10. 客户端测试

  11. 分析

    代码实现

    创建接口抽象工厂

    1. /**
    2. * 抽象工厂模式的抽象层(接口)
    3. */
    4. public interface AbstractFactory {
    5.  //让子类工厂来具体实现
    6.  public AbstractCake createCake(String orderType);
    7. }

    创建具体实现抽象工厂的子类工厂

    1. /**
    2. * （中国）工厂实现类
    3. */
    4. public class CNFactory implements AbstractFactory{
    5.  @Override
    6.  public AbstractCake createCake(String orderType) {
    7.      AbstractCake cake = null;
    8.      if(orderType.equals("水果")){
    9.          cake = new CNfruitCake();
    10.          cake.setName(orderType + "蛋糕(中国味道)");
    11.      }else if(orderType.equals("奶油")){
    12.          cake = new CNCreamCake();
    13.          cake.setName(orderType + "蛋糕(中国味道)");
    14.      } else {
    15.          System.out.println("暂不支持的蛋糕类型");
    16.          return cake;
    17.      }
    18.      return cake;
    19.  }
    20. }
    1. /**
    2. * （美国）工厂实现类
    3. */
    4. public class USFactory implements AbstractFactory{
    5.  @Override
    6.  public AbstractCake createCake(String orderType) {
    7.      AbstractCake cake = null;
    8.      if(orderType.equals("水果")){
    9.          cake = new CNfruitCake();
    10.          cake.setName(orderType + "蛋糕(美国味道)");
    11.      }else if(orderType.equals("奶油")){
    12.          cake = new CNCreamCake();
    13.          cake.setName(orderType + "蛋糕(美国味道)");
    14.      } else {
    15.          System.out.println("暂不支持的蛋糕类型");
    16.          return cake;
    17.      }
    18.      return cake;
    19.  }
    20. }

    预定类实现

    1. /**
    2. * 预定方法实现类
    3. */
    4. public class OrderCake {
    6.  AbstractFactory factory;
    8.  public OrderCake( AbstractFactory factory){
    9.      setFactory(factory);
    10.  }
    12.  private void setFactory(AbstractFactory factory) {
    13.      String orderType;
    14.      AbstractCake cake;
    15.      do {
    16.          orderType = getType();
    17.          //获取简单(静态)工厂
    18.          cake = factory.createCake(orderType);
    19.          if(cake != null) {
    20.              cake.prepare();
    21.              cake.bake();
    22.              cake.box();
    23.              cake.send();
    24.          } else {
    25.              System.out.println("预定失败");
    26.              break;
    27.          }
    28.      }while(true);
    29.  }
    31.  //输入蛋糕类型
    32.  private String getType() {
    33.      try {
    34.          BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
    35.          System.out.println("请输入蛋糕类型：");
    36.          String str = strin.readLine();
    37.          return str;
    38.      } catch (IOException e) {
    39.          e.printStackTrace();
    40.          return "";
    41.      }
    42.  }
    43. }

    客户端测试 ```java public class CakeStore {

    public static void main(String[] args) {

    1.  //中国
    2.  new OrderCake(new CNFactory());

    } }

//测试结果 请输入蛋糕类型： 水果 原料：原胚、水果、中国元素 水果蛋糕(中国味道)烘焙; 水果蛋糕(中国味道)包装; 水果蛋糕(中国味道)配送; 请输入蛋糕类型： 测试 暂不支持的蛋糕类型 预定失败 ``` 分析
很精妙，待深入使用

框架或项目源码分析
应用场景