设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › Java交流 › 工厂模式
返回列表 发新帖
查看: 2638|回复: 1

[学习笔记] 工厂模式

[复制链接]
DAY
发表于 2019-7-17 09:55:43 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
###简单工厂模式
    看一个具体的需求
        看一个披萨的项目，要便于披萨种类的扩展，要便于维护
        1.披萨的种类很多
        2.披萨的制作者有prepare,bake,cut,box
        3.完成披萨店订购功能

使用传统的方法来实现

  2. public abstract class Pizza{
  3.     protected String name;//披萨名字
  4.     //准备原材料，不同的披萨不一样，因此，我们做成抽象方法
  5.     public void prepare(){System.out.println(name+"prepare");}
  6.     public void bake(){System.out.println(name+"bake");}
  7.     public void cut(){System.out.println(name+"cut");}
  8.     public void box(){System.out.println(name+"box");}
  9.     public void setName(String name){this.name=name;}
  10. }

  12. class CheesePizza extends Pizza{
  13.     public void prepare(){
  14.         System.out.println("给制作奶酪披萨，准备原材料");
  15.     }
  16. }

  18. class GreekPizza extends Pizza{
  19.     public void prepare(){
  20.         System.out.println("给制作希纳披萨，准备原材料");
  21.     }
  22. }
  23. class OrderPizza{
  24.     public OrderPizza(){
  25.         Pizza pizza = null;
  26.         String orderType;//订购披萨的类型
  27.         do{
  28.             orderType = getType();
  29.             if(orderType.equals("greek")){
  30.                 pizza = new GreekPizza();
  31.                 pizza.setName("希纳披萨");
  32.             }else if(orderType.equals("cheese")){
  33.                 pizza = new CheesePizza();
  34.                 pizza.setName("奶酪披萨");
  35.             }else{
  36.                 break;
  37.             }
  38.             //输出pizza 制作过程
  39.             pizza.prepare();
  40.             pizza.bake();
  41.             pizza.cut();
  42.             pizza.box();
  43.         }while(true)
  44.     }

  46.     //写一个方法，可以获取客户希望订购的披萨种类
  47.     private String getType(){
  48.         try{
  49.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  50.             System.out.println("Input pizza type:");
  51.             String str = strin.readLine();
  52.             return  str;
  53.         }catch(Exception e){
  54.             e.printStackTrace();
  55.             return "";
  56.         }
  57.     }
  58. }

  60. class PizzaStore{
  61.     public static void main(String[]args){
  62.         new OrderPizza();
  63.     }
  64. }
复制代码


传统的方式的优缺点
    1.优点是比较理解，简单易操作
    2.缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候
    ，尽量不修改代码，或者尽可能少修改代码
    3.比如我们这时要新增加一个Pizza的种类(Pepper披萨)，我们需要做如下修改。
    4.改进的思路分析
    分析->修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味这，也需要修改，而
    创建Pizza的代码，往往有多处
    思路->把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其他有创建
    到Pizza对象的代码就不需要修改了

  2. //新增 写
  3. public class PepperPizza extends Pizza{
  4.     public void prepare(){
  5.         System.out.println(name+"prepare");
  6.     }
  7. }
  8. //增加一段代码OrderPizza.java 写
  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("Pepper披萨");
  18.     }else{
  19.         break;
  20.     }
  21. }
复制代码




基本介绍
    1.简单工厂模式是属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例
    。简单工厂模式是工厂模式家族中最简单使用的模式
    2.简单工厂模式：定义来了一个创建对象的类，由这个类来封装实例化对象的行为（代码）
    3.在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

  2. //简单工厂类
  3. public class SimpleFactory{
  4.     public Pizza createPizza(String orderType){
  5.         Pizza pizza = null;
  6.         System.out.println("使用简单工厂模式");
  7.         if(orderType.equals("greek")){
  8.                 pizza = new GreekPizza();
  9.                 pizza.setName("希纳披萨");
  10.             }else if(orderType.equals("cheese")){
  11.                 pizza = new CheesePizza();
  12.                 pizza.setName("奶酪披萨");
  13.             }else if(orderType.equals("pepper")){
  14.                 pizza = new PepperPizza();
  15.                 pizza.setName("Pepper披萨");
  16.             }
  17.         }
  18.         return pizza;
  19.     }
  20. }
复制代码


  2. //做成静态方便
  3. public static Pizza createPizza(String orderType){
  4.     Pizza pizza = null;
  5.     System.out.println("使用简单工厂模式");
  6.     if(orderType.equals("greek")){
  7.             pizza = new GreekPizza();
  8.             pizza.setName("希纳披萨");
  9.         }else if(orderType.equals("cheese")){
  10.             pizza = new CheesePizza();
  11.             pizza.setName("奶酪披萨");
  12.         }else if(orderType.equals("pepper")){
  13.             pizza = new PepperPizza();
  14.             pizza.setName("Pepper披萨");
  15.         }
  16.     }
  17.     return pizza;
  18. }
复制代码


###工厂方法模式
    看一个新的需求
        披萨项目新的需求:客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza，北京的胡椒pizza
        或者伦敦的奶酪pizza，伦敦的胡椒pizza
    思路一：
        使用简单工厂模式，创建不同的简单工厂类，
        比如BJPizzaSimpleFactory、LDPizzaSimpleFactory等等，从当前这个案例来说，也是可以的，但是考虑到
        项目的规模，以及软件的可维护性、可扩展性并不是特别好

    思路二：
        使用工厂方法模式

工厂方法模式介绍
    工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现
    工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

工厂方法模式应用案例
    披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza，北京的胡椒pizza
    或者伦敦的奶酪pizza，伦敦的胡椒pizza


  2. public class BJCheesePizza extends Pizza{
  3.     public void prepare(){}
  4. }

  6. public class BJPepperPizza extends Pizza{
  7.     public void prepare(){}
  8. }

  10. public class LDPepperPizza extends Pizza{
  11.     public void prepare(){}
  12. }
  13. public class LDCheesePizza extends Pizza{
  14.     public void prepare(){}
  15. }
  16. public abstract class  OrderPizza{
  17.     //定义一个抽象方法，让各个工厂子类自己实现
  18.     abstract Pizza createPizza(String orderType);
  19.     public OrderPizza(){
  20.         Pizza pizza = null;
  21.         String orderType ;
  22.         do{
  23.             orderType = getType();
  24.             pizza = createPizza(orderType);//抽象方法，由工厂子类完成
  25.             pizza.prepare();
  26.             pizza.bake();
  27.             pizza.cut();
  28.             pizza.box();
  29.         }while(true);
  30.     }
  31. }
  32. public class BJOrderPizza extends OrderPizza{
  33.     Pizza createPizza(String orderType){
  34.         pizza pizza = null;
  35.         if(orderType.equals('cheese'))pizza = new BJCheesePizza();
  36.         else if(orderType.equals('pepper'))pizza = new BJPepperPizza();
  37.         return pizza;
  38.     }
  39. }

  41. public class LDOrderPizza extends OrderPizza{
  42.     Pizza createPizza(String orderType){
  43.         pizza pizza = null;
  44.         if(orderType.equals('cheese'))pizza = new LDCheesePizza();
  45.         else if(orderType.equals('pepper'))pizza = new LDPepperPizza();
  46.         return pizza;
  47.     }
  48. }
复制代码


###抽象工厂模式
    基本介绍
    1.抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
    2.抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
    3.从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称之为进一步的抽象）。
    4.将工厂抽象成两层，absfactory（抽象工厂）和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的
    工厂子类。这样将单个的简单工厂类变成了工厂簇。
    更有利于代码的维护和扩展。

  2. public interface AbsFactory{
  3.     public Pizza createPizza(String orderType);
  4. }

  6. //这是一个工厂子类
  7. public class BJFactory implements AbsFactory{
  8.     public Pizza createPizza(String orderType){
  9.         Pizza pizza = null;
  10.         if(orderType.equals("cheese")){
  11.             pizza = new BJCheesePizza();
  12.         }else if(orderType.equals("pepper")){
  13.             pizza = new BJPepperPizza();
  14.         }
  15.         return pizza;
  16.     }
  17. }

  19. public class LDFactory implements AbsFactory{
  20.     public Pizza createPizza(String orderType){
  21.         Pizza pizza = null;
  22.         if(orderType.equals("cheese")){
  23.             pizza = new LDCheesePizza();
  24.         }else if(orderType.equals("pepper")){
  25.             pizza = new LDPepperPizza();
  26.         }
  27.         return pizza;
  28.     }
  29. }

  31. public class OrderPizza{
  32.     AbsFactory absFactory;
  33.     private void setFactory(AbsFactory factory){
  34.         Pizza pizza = null;
  35.         Striing orderType ="";
  36.         this.factory = factory;
  37.         do{
  38.             orderType = getType();
  39.             //factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
  40.             pizza = factory.createPizza(orderType);
  41.         }while(true);
  42.     }

  44.     public OrderPizza(AbsFactory factory){
  45.         setFactory(factory);
  46.     }
  47. }
复制代码


工厂模式在jdk-Calendar应用的源码分析
    1.jdk中的Calendar类中，就使用了简单工厂模式
    2.源码分析+Debug源码+说明
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

SYCh
发表于 2019-7-21 16:58:06 | 显示全部楼层
厉害了
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-4-18 19:17

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表