演进顺序：传统写法 —>简单工厂—>工厂方法—>抽象工厂

需求案例：

制作蛋糕
1.准备
2.烘焙
3.包装
4.配送

传统写法


类图：

image.png

  1. 定义抽象类
  2. 实现类继承抽象类
  3. 预定方法
  4. 客户端测试
  5. 分析

定义抽象类

  1. /**
  2.  * 蛋糕抽象类
  3.  */
  4. public abstract class AbstractCake {
  6.     protected String name;
  8.     public abstract void prepare();
  10.     public void bake() {
  11.         System.out.println(name + "烘焙;");
  12.     }
  14.     public void box() {
  15.         System.out.println(name + "包装;");
  16.     }
  18.     public void send() {
  19.         System.out.println(name + "配送;");
  20.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  25. }

实现类继承抽象类

  1. /**
  2.  * 奶油蛋糕
  3.  */
  4. public class CreamCake extends AbstractCake{
  5.     @Override
  6.     public void prepare() {
  7.         System.out.println("原料：原胚、奶油");
  8.     }
  9. }
  1. /**
  2.  * 水果蛋糕
  3.  */
  4. public class fruitCake extends AbstractCake{
  5.     @Override
  6.     public void prepare() {
  7.         System.out.println("原料：原胚、水果");
  8.     }
  9. }

预定方法

  1. /**
  2.  * 预定方法
  3.  */
  4. public class OrderCake {
  6.     public OrderCake() {
  7.         AbstractCake cake;
  8.         String orderType;
  9.         do {
  10.             orderType = getType();
  11.             if (orderType.equals("水果")) {
  12.                 cake = new fruitCake(); // ===>耦合
  13.                 cake.setName(orderType+"蛋糕 ");
  14.             } else if (orderType.equals("奶油")) {
  15.                 cake = new CreamCake(); // ===>耦合
  16.                 cake.setName(orderType+"蛋糕 ");
  17.             } else {
  18.                 System.out.println("暂不支持的蛋糕类型");
  19.                 break;
  20.             }
  21.             //操作流程
  22.             cake.prepare();
  23.             cake.bake();
  24.             cake.box();
  25.             cake.send();
  26.         } while (true);
  27.     }
  29.     //输入蛋糕类型
  30.     private String getType() {
  31.         try {
  32.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  33.             System.out.println("请输入蛋糕类型：");
  34.             String str = strin.readLine();
  35.             return str;
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.             return "";
  39.         }
  40.     }
  41. }

客户端测试

  1. /**
  2.  * 客户端测试
  3.  */
  4. public class CakeStore {
  6.     public static void main(String[] args) {
  7.         new OrderCake();
  8.     }
  9. }
  11. //测试结果
  12. 请输入蛋糕类型：
  13. 水果
  14. 原料：原胚、水果
  15. 水果蛋糕 烘焙;
  16. 水果蛋糕 包装;
  17. 水果蛋糕 配送;
  18. 请输入蛋糕类型：
  19. 巧克力
  20. 暂不支持的蛋糕类型

分析：
如上代码可以看到：预定方法OrderCake在方法中直接new对应的实现类，此时上新新蛋糕类型，如：巧克力蛋糕，如果有orderCake1~n，则需要修改多个OrderCake方法，这违反了开闭原则。有没有什么好的方式只修改一处就可以实现全局修改呢？将创建对象依托给工厂去创建 ==》简单工厂模式