一、简单工厂模式

简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为
简单工厂模式属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
简单工厂模式是工厂模式家族中最简单使用的模式。
先将抽象类或接口写出来

public abstract class Pizza {
  protected String name;
  public Pizza() {
  }
  public Pizza(String name) {
    this.name = name;
  }
  public abstract void prepare();
  public void bake() {
    System.out.println("烘焙" + name + "披萨");
  }
  public void cut() {
    System.out.println("切割" + name + "披萨");
  }
  public void box() {
    System.out.println("打包" + name + "披萨");
  }
}

再继承/实现抽象，写成具体类

public class CheesePizza extends Pizza {
  public CheesePizza() {
    super("cheese");
  }
  @Override
  public void prepare() {
    System.out.println("准备芝士");
  }
}

public class CheesePizza extends Pizza {
  public CheesePizza() {
    super("cheese");
  }
  @Override
  public void prepare() {
    System.out.println("准备芝士");
  }
}

public class GreekPizza extends Pizza {
  public GreekPizza() {
    super("Greek");
  }

  @Override
  public void prepare() {
    System.out.println("准备希腊的原料");
  }
}

工厂通过需要，构造出相应类的对象

public class SimpleFactory {
  public Pizza createPizza(String name) {
    return switch (name) {
      case "Greek" -> new GreekPizza();
      case "Cheese" -> new CheesePizza();
      case "Chinese" -> new ChinesePizza();
      default -> null;
    };
  }
}

调用者通过工厂，获取实例化的对象

public class OrderPizza {
  private SimpleFactory simpleFactory;

  public OrderPizza(SimpleFactory simpleFactory) {
    this.simpleFactory = simpleFactory;
  }

  public void manage(Scanner scan) {
    // 获取需求
    while (scan.hasNextLine()) {
      String s = scan.nextLine();
      Pizza pizza = simpleFactory.createPizza(s);
      if (pizza != null) {
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
      } else {
        System.out.println("订购披萨失败");
        break;
      }
    }
  }

  public static void main(String[] args) {
    OrderPizza orderPizza = new OrderPizza(new SimpleFactory());
    orderPizza.manage(new Scanner(System.in));
  }
}

二、抽象工厂模式

抽象工厂模式：定义了一个interface用于创建相关或有依赖的对象簇，而无需指明具体的类
将工厂分成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。
这样将单个简单的工厂变成工厂簇，更利于代码的维护和拓展
存储路径
首先，定义Pizza的接口

public interface Pizza {
  void prepare();
  void bake();
  void cut();
  void box();
}

Pizza的实现类

public class BJCheesePizza implements Pizza {
  @Override
  public void prepare() {
    System.out.println("准备北京芝士披萨的原料");
  }

  @Override
  public void bake() {
    System.out.println("烘焙北京芝士披萨");
  }

  @Override
  public void cut() {
    System.out.println("切割北京芝士披萨");
  }

  @Override
  public void box() {
    System.out.println("打包北京芝士披萨");
  }
}

抽象工厂

public interface AbsFactory {
        Pizza createPizza(String name);
}

具体的工厂

public class BJFactory implements AbsFactory {
  @Override
  public Pizza createPizza(String name) {
    return switch (name) {
      case "Cheese" -> new BJCheesePizza();
      case "Pepper" -> new BJPepperPizza();
      default -> null;
    };
  }
}

三、总结

工厂模式意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系解耦。从而提高项目的拓展和维护性

设计模式之工厂设计模式

一、简单工厂模式

二、抽象工厂模式

三、总结