设计模式(10) -- 工厂设计模式(简单工厂，工厂方法，抽象工厂模式)

向右看齐 2023-06-13 09:45 157阅读 0赞

文章目录

  • 简单工厂模式
    • 需求1：
    • 传统实现
      • 优缺点:
    • 简单工厂方式实现
      • 基本介绍
  • 工厂方法模式
    • 介绍
    • 需求2:
    • 实现
  • 抽象工厂模式
    • 介绍
    • 需求
  • 工厂模式在JDK Calendar应用的源码 分析
  • 工厂模式小结

简单工厂模式

需求1：

看一个披萨的项目：要便于披萨种类的扩展，要便于维护
1)披萨的种类很多，比如GreekPizz 、 CheesePizz 等
2)披萨的制作有 prepare bake, cut, box
3)完成披萨店订购功能。

传统实现

在这里插入图片描述
Pizza 类

  1. //将Pizza 类做成抽象
  2. public abstract class Pizza { 
  3.     protected String name; //名字
  5.     //准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
  6.     public abstract void prepare();
  9.     public void bake() { 
  10.         System.out.println(name + " baking;");
  11.     }
  13.     public void cut() { 
  14.         System.out.println(name + " cutting;");
  15.     }
  17.     //打包
  18.     public void box() { 
  19.         System.out.println(name + " boxing;");
  20.     }
  22.     public void setName(String name) { 
  23.         this.name = name;
  24.     }
  25. }

CheesePizza类

  1. public class CheesePizza extends Pizza { 
  3.     @Override
  4.     public void prepare() { 
  5.         // TODO Auto-generated method stub
  6.         System.out.println(" 给制作奶酪披萨 准备原材料 ");
  7.     }
  8. }

GreekPizza

  1. public class GreekPizza extends Pizza { 
  3.     @Override
  4.     public void prepare() { 
  5.         // TODO Auto-generated method stub
  6.         System.out.println(" 给希腊披萨 准备原材料 ");
  7.     }
  9. }

PepperPizza

  1. public class PepperPizza extends Pizza { 
  2.     @Override
  3.     public void prepare() { 
  4.         // TODO Auto-generated method stub
  5.         System.out.println(" 给胡椒披萨准备原材料 ");
  6.     }
  7. }

OrderPizza 订购pizza

  1. public class OrderPizza { 
  3.     // 构造器
  4.     public OrderPizza() { 
  5.         Pizza pizza = null;
  6.         String orderType; // 订购披萨的类型
  7.         do { 
  8.             orderType = getType();
  9.             if (orderType.equals("greek")) { 
  10.                 pizza = new GreekPizza();
  11.                 pizza.setName(" 希腊披萨 ");
  12.             } else if (orderType.equals("cheese")) { 
  13.                 pizza = new CheesePizza();
  14.                 pizza.setName(" 奶酪披萨 ");
  15.             } else if (orderType.equals("pepper")) { 
  16.                 pizza = new PepperPizza();
  17.                 pizza.setName("胡椒披萨");
  18.             } else { 
  19.                 break;
  20.             }
  21.             //输出pizza 制作过程
  22.             pizza.prepare();
  23.             pizza.bake();
  24.             pizza.cut();
  25.             pizza.box();
  27.         } while (true);
  28.     }
  32.     // 写一个方法，可以获取客户希望订购的披萨种类
  33.     private String getType() { 
  34.         try { 
  35.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  36.             System.out.println("input pizza 种类:");
  37.             String str = strin.readLine();
  38.             return str;
  39.         } catch (IOException e) { 
  40.             e.printStackTrace();
  41.             return "";
  42.         }
  43.     }
  45. }

测试类：PizzaStore

  1. //相当于一个客户端，发出订购
  2. public class PizzaStore { 
  3.     public static void main(String[] args) { 
  4.         new OrderPizza();        
  5.     }
  6. }

运行结果:
在这里插入图片描述

优缺点:

在这里插入图片描述

简单工厂方式实现

基本介绍

在这里插入图片描述
在这里插入图片描述
类:
在这里插入图片描述
其中: 这下面的4个类代码不变。
在这里插入图片描述
SimpleFactory

  1. //简单工厂类
  2. public class SimpleFactory { 
  4.     //更加orderType 返回对应的Pizza 对象
  5.     public Pizza createPizza(String orderType) { 
  7.         Pizza pizza = null;
  9.         System.out.println("使用简单工厂模式");
  10.         if (orderType.equals("greek")) { 
  11.             pizza = new GreekPizza();
  12.             pizza.setName(" 希腊披萨 ");
  13.         } else if (orderType.equals("cheese")) { 
  14.             pizza = new CheesePizza();
  15.             pizza.setName(" 奶酪披萨 ");
  16.         } else if (orderType.equals("pepper")) { 
  17.             pizza = new PepperPizza();
  18.             pizza.setName("胡椒披萨");
  19.         }
  21.         return pizza;
  22.     }
  24.     //简单工厂模式 也叫 静态工厂模式 
  26.     public static Pizza createPizza2(String orderType) { 
  28.         Pizza pizza = null;
  30.         System.out.println("使用简单工厂模式2");
  31.         if (orderType.equals("greek")) { 
  32.             pizza = new GreekPizza();
  33.             pizza.setName(" 希腊披萨 ");
  34.         } else if (orderType.equals("cheese")) { 
  35.             pizza = new CheesePizza();
  36.             pizza.setName(" 奶酪披萨 ");
  37.         } else if (orderType.equals("pepper")) { 
  38.             pizza = new PepperPizza();
  39.             pizza.setName("胡椒披萨");
  40.         }
  42.         return pizza;
  43.     }
  45. }

OrderPizza

  1. public class OrderPizza { 
  3.     // 构造器
  4. // public OrderPizza() { 
  5. // Pizza pizza = null;
  6. // String orderType; // 订购披萨的类型
  7. // do { 
  8. // orderType = getType();
  9. // if (orderType.equals("greek")) { 
  10. // pizza = new GreekPizza();
  11. // pizza.setName(" 希腊披萨 ");
  12. // } else if (orderType.equals("cheese")) { 
  13. // pizza = new CheesePizza();
  14. // pizza.setName(" 奶酪披萨 ");
  15. // } else if (orderType.equals("pepper")) { 
  16. // pizza = new PepperPizza();
  17. // pizza.setName("胡椒披萨");
  18. // } else { 
  19. // break;
  20. // }
  21. // //输出pizza 制作过程
  22. // pizza.prepare();
  23. // pizza.bake();
  24. // pizza.cut();
  25. // pizza.box();
  26. // 
  27. // } while (true);
  28. // }
  30.     //定义一个简单工厂对象
  31.     SimpleFactory simpleFactory;
  32.     Pizza pizza = null;
  34.     //构造器
  35.     public OrderPizza(SimpleFactory simpleFactory) { 
  36.         setFactory(simpleFactory);
  37.     }
  39.     public void setFactory(SimpleFactory simpleFactory) { 
  40.         String orderType = ""; //用户输入的
  42.         this.simpleFactory = simpleFactory; //设置简单工厂对象
  44.         do { 
  45.             orderType = getType(); 
  46.             pizza = this.simpleFactory.createPizza(orderType);
  48.             //输出pizza
  49.             if(pizza != null) {  //订购成功
  50.                 pizza.prepare();
  51.                 pizza.bake();
  52.                 pizza.cut();
  53.                 pizza.box();
  54.             } else { 
  55.                 System.out.println(" 订购披萨失败 ");
  56.                 break;
  57.             }
  58.         }while(true);
  59.     }
  61.     // 写一个方法，可以获取客户希望订购的披萨种类
  62.     private String getType() { 
  63.         try { 
  64.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  65.             System.out.println("input pizza 种类:");
  66.             String str = strin.readLine();
  67.             return str;
  68.         } catch (IOException e) { 
  69.             e.printStackTrace();
  70.             return "";
  71.         }
  72.     }
  74. }

OrderPizza2

  1. public class OrderPizza2 { 
  3.     Pizza pizza = null;
  4.     String orderType = "";
  5.     // 构造器
  6.     public OrderPizza2() { 
  8.         do { 
  9.             orderType = getType();
  10.             pizza = SimpleFactory.createPizza2(orderType);
  12.             // 输出pizza
  13.             if (pizza != null) {  // 订购成功
  14.                 pizza.prepare();
  15.                 pizza.bake();
  16.                 pizza.cut();
  17.                 pizza.box();
  18.             } else { 
  19.                 System.out.println(" 订购披萨失败 ");
  20.                 break;
  21.             }
  22.         } while (true);
  23.     }
  25.     // 写一个方法，可以获取客户希望订购的披萨种类
  26.     private String getType() { 
  27.         try { 
  28.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  29.             System.out.println("input pizza 种类:");
  30.             String str = strin.readLine();
  31.             return str;
  32.         } catch (IOException e) { 
  33.             e.printStackTrace();
  34.             return "";
  35.         }
  36.     }
  37. }

测试类 PizzaStore

  1. //相当于一个客户端，发出订购
  2. public class PizzaStore { 
  3.     public static void main(String[] args) { 
  4.         // TODO Auto-generated method stub
  5.         //new OrderPizza(); 
  6.         //使用简单工厂模式
  7.         new OrderPizza(new SimpleFactory());
  8.         //System.out.println("~~退出程序~~"); 
  9.         //new OrderPizza2();
  10.     }
  11. }

在这里插入图片描述

工厂方法模式

介绍

在这里插入图片描述

需求2:

在这里插入图片描述

实现

在这里插入图片描述
在这里插入图片描述
BJCheesePizza

  1. public class BJCheesePizza extends Pizza { 
  3.     @Override
  4.     public void prepare() { 
  5.         // TODO Auto-generated method stub
  6.         setName("北京的奶酪pizza");
  7.         System.out.println(" 北京的奶酪pizza 准备原材料");
  8.     }
  10. }

BJPepperPizza

  1. public class BJPepperPizza extends Pizza { 
  2.     @Override
  3.     public void prepare() { 
  4.         // TODO Auto-generated method stub
  5.         setName("北京的胡椒pizza");
  6.         System.out.println(" 北京的胡椒pizza 准备原材料");
  7.     }
  8. }

LDCheesePizza

  1. public class LDCheesePizza extends Pizza{ 
  3.     @Override
  4.     public void prepare() { 
  5.         // TODO Auto-generated method stub
  6.         setName("伦敦的奶酪pizza");
  7.         System.out.println(" 伦敦的奶酪pizza 准备原材料");
  8.     }
  9. }

LDPepperPizza

  1. public class LDPepperPizza extends Pizza{ 
  2.     @Override
  3.     public void prepare() { 
  4.         // TODO Auto-generated method stub
  5.         setName("伦敦的胡椒pizza");
  6.         System.out.println(" 伦敦的胡椒pizza 准备原材料");
  7.     }
  8. }

OrderPizza

  1. public abstract class OrderPizza { 
  3.     //定义一个抽象方法，createPizza , 让各个工厂子类自己实现
  4.     abstract Pizza createPizza(String orderType);
  6.     // 构造器
  7.     public OrderPizza() { 
  8.         Pizza pizza = null;
  9.         String orderType; // 订购披萨的类型
  10.         do { 
  11.             orderType = getType();
  12.             pizza = createPizza(orderType); //抽象方法，由工厂子类完成
  13.             //输出pizza 制作过程
  14.             pizza.prepare();
  15.             pizza.bake();
  16.             pizza.cut();
  17.             pizza.box();
  19.         } while (true);
  20.     }    
  22.     // 写一个方法，可以获取客户希望订购的披萨种类
  23.     private String getType() { 
  24.         try { 
  25.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  26.             System.out.println("input pizza 种类:");
  27.             String str = strin.readLine();
  28.             return str;
  29.         } catch (IOException e) { 
  30.             e.printStackTrace();
  31.             return "";
  32.         }
  33.     }
  35. }

BJOrderPizza

  1. public class BJOrderPizza extends OrderPizza { 
  4.     @Override
  5.     Pizza createPizza(String orderType) { 
  7.         Pizza pizza = null;
  8.         if(orderType.equals("cheese")) { 
  9.             pizza = new BJCheesePizza();
  10.         } else if (orderType.equals("pepper")) { 
  11.             pizza = new BJPepperPizza();
  12.         }
  13.         // TODO Auto-generated method stub
  14.         return pizza;
  15.     }
  17. }

LDOrderPizza

  1. public class LDOrderPizza extends OrderPizza { 
  3.     @Override
  4.     Pizza createPizza(String orderType) { 
  6.         Pizza pizza = null;
  7.         if(orderType.equals("cheese")) { 
  8.             pizza = new LDCheesePizza();
  9.         } else if (orderType.equals("pepper")) { 
  10.             pizza = new LDPepperPizza();
  11.         }
  12.         // TODO Auto-generated method stub
  13.         return pizza;
  14.     }
  16. }

测试类 PizzaStore

  1. public class PizzaStore { 
  3.     public static void main(String[] args) { 
  4.         String loc = "bj";
  5.         if (loc.equals("bj")) { 
  6.             //创建北京口味的各种Pizza
  7.             new BJOrderPizza();
  8.         } else { 
  9.             //创建伦敦口味的各种Pizza
  10.             new LDOrderPizza();
  11.         }
  12.         // TODO Auto-generated method stub
  13.     }
  15. }

在这里插入图片描述

抽象工厂模式

介绍

在这里插入图片描述

需求

使用:抽象工厂模式来完成披萨项目(需求2）
在这里插入图片描述
在这里插入图片描述
AbsFactory

  1. //一个抽象工厂模式的抽象层(接口)
  2. public interface AbsFactory { 
  3.     //让下面的工厂子类来 具体实现
  4.     public Pizza createPizza(String orderType);
  5. }

BJFactory

  1. //这是工厂子类
  2. public class BJFactory implements AbsFactory { 
  4.     @Override
  5.     public Pizza createPizza(String orderType) { 
  6.         System.out.println("~使用的是抽象工厂模式~");
  7.         // TODO Auto-generated method stub
  8.         Pizza pizza = null;
  9.         if(orderType.equals("cheese")) { 
  10.             pizza = new BJCheesePizza();
  11.         } else if (orderType.equals("pepper")){ 
  12.             pizza = new BJPepperPizza();
  13.         }
  14.         return pizza;
  15.     }
  17. }

LDFactory

  1. public class LDFactory implements AbsFactory { 
  3.     @Override
  4.     public Pizza createPizza(String orderType) { 
  5.         System.out.println("~使用的是抽象工厂模式~");
  6.         Pizza pizza = null;
  7.         if (orderType.equals("cheese")) { 
  8.             pizza = new LDCheesePizza();
  9.         } else if (orderType.equals("pepper")) { 
  10.             pizza = new LDPepperPizza();
  11.         }
  12.         return pizza;
  13.     }
  15. }

订购pizza类 OrderPizza

  1. public class OrderPizza { 
  3.     AbsFactory factory;
  5.     // 构造器
  6.     public OrderPizza(AbsFactory factory) { 
  7.         setFactory(factory);
  8.     }
  10.     private void setFactory(AbsFactory factory) { 
  11.         Pizza pizza = null;
  12.         String orderType = ""; // 用户输入
  13.         this.factory = factory;
  14.         do { 
  15.             orderType = getType();
  16.             // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
  17.             pizza = factory.createPizza(orderType);
  18.             if (pizza != null) {  // 订购ok
  19.                 pizza.prepare();
  20.                 pizza.bake();
  21.                 pizza.cut();
  22.                 pizza.box();
  23.             } else { 
  24.                 System.out.println("订购失败");
  25.                 break;
  26.             }
  27.         } while (true);
  28.     }
  30.     // 写一个方法，可以获取客户希望订购的披萨种类
  31.     private String getType() { 
  32.         try { 
  33.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  34.             System.out.println("input pizza 种类:");
  35.             String str = strin.readLine();
  36.             return str;
  37.         } catch (IOException e) { 
  38.             e.printStackTrace();
  39.             return "";
  40.         }
  41.     }
  42. }

测试类 PizzaStore

  1. public class PizzaStore { 
  3.     public static void main(String[] args) { 
  4.         // TODO Auto-generated method stub
  5.         //new OrderPizza(new BJFactory());
  6.         new OrderPizza(new LDFactory());
  7.     }
  9. }

运行结果:
在这里插入图片描述

工厂模式在JDK Calendar应用的源码 分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

工厂模式小结

在这里插入图片描述

完

发表评论

表情：
评论列表 （有 0 条评论，157人围观）

还没有评论，来说两句吧...

相关阅读