设计模式 —— 工厂模式（简单工厂、工厂方法、抽象工厂）

目录

一、简单工厂模式

1.1 使用传统的方式来完成

1.2 传统的方式的优缺点

二、简单工厂

2.1 简单工厂基本介绍

2.2 使用简单工厂模式

三、工厂方法模式

3.1 工厂方法模式介绍

3.2 工厂方法模式应用案例

四、抽象工厂模式

4.1 抽象工厂基本介绍

4.2 抽象工厂模式应用实例

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

六、工厂模式小结

一、简单工厂模式

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

  1. 披萨的种类很多(比如 GreekPizz、CheesePizz 等)
  2. 披萨的制作有 prepare，bake, cut, box
  3. 完成披萨店订购功能。

1.1 使用传统的方式来完成

思路分析(类图)

编写 OrderPizza.java 去订购需要的各种 Pizza，传统方式代码如下：

  1. public class OrderPizza {
  2.     // 构造器
  3. 	public OrderPizza() {
  4. 	    Pizza pizza = null;
  5. 	    String orderType; //  订购披萨的类型
  6. 	    do {
  7. 	        orderType = getType();
  8. 	        
  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. 	    } while (true);
  27. 	}
  28.  
  29. 	public String getType() {
  30. 	    return "";
  31.     }
  32. }
  33.  
  34. abstract class Pizza{
  35.     public void setName(String name){}
  36.     public void prepare(){}
  37.     public void bake() {}
  38.     public void cut() {}
  39.     public void box() {}
  40. }
  41.  
  42. class GreekPizza extends Pizza{
  43.  
  44. }
  45.  
  46. class CheesePizza extends Pizza {
  47.  
  48. }
  49.  
  50. class PepperPizza extends Pizza {
  51.  
  52. }

1.2 传统的方式的优缺点

  1. 优点是比较好理解，简单易操作。
  2. 缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
  3. 比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)，我们需要做如下修改. 如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码都需要修改.

改进的思路分析

  • 分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza 的代码，往往有多处。
  • 思路：把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可，其它有创建到 Pizza 对象的代码就不需要修改了  ->  简单工厂模式

二、简单工厂

2.1 简单工厂基本介绍

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

2.2 使用简单工厂模式

简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类，封装创建对象的代码。

示例代码：

  1. // 简单工厂类
  2. public class SimpleFactory {
  3.     // 简单工厂模式 也叫 静态工厂模式
  4.     public static Pizza createPizza(String orderType) {
  5.         Pizza pizza = null;
  6.  
  7.         System.out.println("使用简单工厂模式");
  8.         if (orderType.equals("greek")) {
  9.             pizza = new GreekPizza();
  10.             pizza.setName(" 希腊披萨 ");
  11.         } else if (orderType.equals("cheese")) {
  12.             pizza = new CheesePizza();
  13.             pizza.setName(" 奶酪披萨 ");
  14.         } else if (orderType.equals("pepper")) {
  15.             pizza = new PepperPizza();
  16.             pizza.setName("胡椒披萨");
  17.         }
  18.  
  19.         return pizza;
  20.     }
  21. }
  1. public class OrderPizza {
  2.     //定义一个简单工厂对象
  3.     SimpleFactory simpleFactory;
  4. 	Pizza pizza = null;
  5.  
  6.     //构造器
  7.     public OrderPizza(SimpleFactory simpleFactory) {
  8. 	    setFactory(simpleFactory);
  9.     }
  10.  
  11.     public void setFactory(SimpleFactory simpleFactory) {
  12.         String orderType = ""; //用户输入的
  13.         this.simpleFactory = simpleFactory; //设置简单工厂对象
  14.         do {
  15.             orderType = getType();
  16.             pizza = this.simpleFactory.createPizza(orderType);
  17.  
  18.             //输出 pizza
  19.             if (pizza != null) { //订购成功
  20.                 pizza.prepare();
  21.                 pizza.bake();
  22.                 pizza.cut();
  23.                 pizza.box();
  24.             } else {
  25.                 System.out.println(" 订购披萨失败 ");
  26.                 break;
  27.             }
  28.         } while (true);
  29.     }
  30.  
  31.     // 写一个方法，可以获取客户希望订购的披萨种类
  32.     private String getType() {
  33.         try {
  34.             BufferedReader strIn = new BufferedReader(new InputStreamReader(System.in));
  35.             System.out.println("input pizza 种类:");
  36.             String str = strIn.readLine();
  37.             return str;
  38.         } catch (IOException e) {
  39.             e.printStackTrace(); return "";
  40.         }
  41.     }
  42. }

三、工厂方法模式

  • 看一个新的需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪 pizza、北京的胡椒pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

 

  • 思路 1

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等.从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好

 

  • 思路 2

使用工厂方法模式

3.1 工厂方法模式介绍

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

3.2 工厂方法模式应用案例

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪 pizza、北京的胡椒pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza

思路分析图解

代码实现

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

四、抽象工厂模式

4.1 抽象工厂基本介绍

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

类图

4.2 抽象工厂模式应用实例

使用抽象工厂模式来完成披萨项目.

  1. //一个抽象工厂模式的抽象层(接口)
  2. public interface AbsFactory {
  3.     //让下面的工厂子类来 具体实现
  4.     public Pizza createPizza(String orderType);
  5. }
  1. //这是工厂子类
  2. public class BJFactory 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 BJCheesePizza();
  9.         } else if (orderType.equals("pepper")){
  10.             pizza = new BJPepperPizza();
  11.         }
  12.         return pizza;
  13.     }
  14. }
  1. public class LDFactory implements AbsFactory {
  2.     @Override
  3.     public Pizza createPizza(String orderType) {
  4.         System.out.println("~使用的是抽象工厂模式~");
  5.         Pizza pizza = null;
  6.         if (orderType.equals("cheese")) {
  7.             pizza = new LDCheesePizza();
  8.         } else if (orderType.equals("pepper")) {
  9.             pizza = new LDPepperPizza();
  10.         }
  11.         return pizza;
  12.     }
  13. }
  1. public class OrderPizza {
  2.     AbsFactory factory;
  3.  
  4.     // 构造器
  5.     public OrderPizza(AbsFactory factory) {
  6.         setFactory(factory);
  7.     }
  8.  
  9.     private void setFactory(AbsFactory factory) {
  10.         Pizza pizza = null;
  11.         String orderType = ""; //  用户输入
  12.         this.factory = factory; do {
  13.             orderType = getType();
  14.             // factory  可能是北京的工厂子类，也可能是伦敦的工厂子类
  15.             pizza = factory.createPizza(orderType);
  16.             if (pizza != null) { // 订 购 ok
  17.                 pizza.prepare();
  18.                 pizza.bake();
  19.                 pizza.cut();
  20.                 pizza.box();
  21.             } else {
  22.                 System.out.println("订购失败");
  23.                 break;
  24.             }
  25.         } while (true);
  26.     }
  27.  
  28.     // 写一个方法，可以获取客户希望订购的披萨种类
  29.     private String getType() {
  30.         try {
  31.             BufferedReader strIn = new BufferedReader(new InputStreamReader(System.in));
  32.             System.out.println("input pizza 种类:");
  33.             String str = strIn.readLine();
  34.             return str;
  35.         } catch (IOException e) {
  36.             e.printStackTrace(); return "";
  37.         }
  38.     }
  39. }

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

  • JDK 中的 Calendar 类中，就使用了简单工厂模式
  • 源码分析+Debug 源码+说明
  1. import java.util.Calendar;
  2.  
  3. public class Factory {
  4.     public static void main(String[] args) {
  5.         // getInstance 是 Calendar 静态方法
  6.         Calendar cal = Calendar.getInstance();
  7.         // 注意月份下标从 0 开始，所以取月份要+1
  8.         System.out.println("年:" + cal.get(Calendar.YEAR));
  9.         System.out.println(" 月 :" + (cal.get(Calendar.MONTH) + 1)); 
  10.         System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
  11.         System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
  12.         System.out.println("分:" + cal.get(Calendar.MINUTE));
  13.         System.out.println("秒:" + cal.get(Calendar.SECOND));
  14.     }
  15. }

在Calendar.java 中：

  1.     public static Calendar getInstance()
  2.     {
  3.         return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
  4.     }
  1.     private static Calendar createCalendar(TimeZone zone,
  2.                                            Locale aLocale)
  3.     {
  4.         CalendarProvider provider =
  5.             LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
  6.                                  .getCalendarProvider();
  7.         if (provider != null) {
  8.             try {
  9.                 return provider.getInstance(zone, aLocale);
  10.             } catch (IllegalArgumentException iae) {
  11.                 // fall back to the default instantiation
  12.             }
  13.         }
  14.  
  15.         Calendar cal = null;
  16.  
  17.         if (aLocale.hasExtensions()) {
  18.             String caltype = aLocale.getUnicodeLocaleType("ca");
  19.             if (caltype != null) {
  20.                 switch (caltype) {
  21.                 case "buddhist":
  22.                 cal = new BuddhistCalendar(zone, aLocale);
  23.                     break;
  24.                 case "japanese":
  25.                     cal = new JapaneseImperialCalendar(zone, aLocale);
  26.                     break;
  27.                 case "gregory":
  28.                     cal = new GregorianCalendar(zone, aLocale);
  29.                     break;
  30.                 }
  31.             }
  32.         }
  33.         if (cal == null) {
  34.             // If no known calendar type is explicitly specified,
  35.             // perform the traditional way to create a Calendar:
  36.             // create a BuddhistCalendar for th_TH locale,
  37.             // a JapaneseImperialCalendar for ja_JP_JP locale, or
  38.             // a GregorianCalendar for any other locales.
  39.             // NOTE: The language, country and variant strings are interned.
  40.             if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
  41.                 cal = new BuddhistCalendar(zone, aLocale);
  42.             } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
  43.                        && aLocale.getCountry() == "JP") {
  44.                 cal = new JapaneseImperialCalendar(zone, aLocale);
  45.             } else {
  46.                 cal = new GregorianCalendar(zone, aLocale);
  47.             }
  48.         }
  49.         return cal;
  50.     }

六、工厂模式小结

  1. 工厂模式的意义: 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
  3. 设计模式的依赖抽象原则

使用建议：

  • 创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说， 变量不要直接持有具体类的引用。
  • 不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)
  • 不要覆盖基类中已经实现的方法。

 

文章最后，给大家推荐一些受欢迎的技术博客链接：

  1. JAVA相关的深度技术博客链接
  2. Flink 相关技术博客链接
  3. Spark 核心技术链接
  4. 设计模式 —— 深度技术博客链接
  5. 机器学习 —— 深度技术博客链接
  6. Hadoop相关技术博客链接
  7. 超全干货--Flink思维导图，花了3周左右编写、校对
  8. 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
  9. 请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”
  10. 聊聊RPC通信，经常被问到的一道面试题。源码+笔记，包懂
  11. 深入聊聊Java 垃圾回收机制【附原理图及调优方法】

欢迎扫描下方的二维码或 搜索 公众号“大数据高级架构师”，我们会有更多、且及时的资料推送给您，欢迎多多交流！

                                           

       

 

注：本文转载自blog.csdn.net的不埋雷的探长的文章"https://blog.csdn.net/weixin_32265569/article/details/108314331"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！