简单工厂模式

又称静态工厂方法模式（Static Factory Method Pattern）

分析实现步骤

将在类中直接创建对象(new)，提取到一个公共的工厂类中，达到创建对象和业务类解耦目的

代码实现

image.png

  1. 定义抽象类
  2. 实现具体类
  3. 定义简单工厂类
  4. 实现预定方法
  5. 客户端测试
  6. 分析

定义简单工厂类

  1. /**
  2.  * 简单工厂模式
  3.  */
  4. public class SimpleFactory {
  6.     public static AbstractCake createCake(String orderType) {
  7.         AbstractCake cake = null;
  8.         if (orderType.equals("水果")) {
  9.             cake = new fruitCake();
  10.             cake.setName(orderType + "蛋糕 ");
  11.         } else if (orderType.equals("奶油")) {
  12.             cake = new CreamCake();
  13.             cake.setName(orderType + "蛋糕 ");
  14.         } else {
  15.             System.out.println("暂不支持的蛋糕类型");
  16.             return cake;
  17.         }
  18.         return cake;
  19.     }
  20. }

实现预定方法

  1. /**
  2.  * 预定方法实现类
  3.  */
  4. public class OrderCake {
  6.     public OrderCake(){
  7.         setFactory();
  8.     }
  10.     private void setFactory() {
  11.         String orderType;
  12.         do {
  13.             orderType = getType();
  14.             //获取简单(静态)工厂
  15.             AbstractCake cake = SimpleFactory.createCake(orderType);
  16.             if(cake != null) {
  17.                 cake.prepare();
  18.                 cake.bake();
  19.                 cake.box();
  20.                 cake.send();
  21.             } else {
  22.                 System.out.println("预定失败");
  23.                 break;
  24.             }
  25.         }while(true);
  26.     }
  28.     //输入蛋糕类型
  29.     private String getType() {
  30.         try {
  31.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  32.             System.out.println("请输入蛋糕类型：");
  33.             String str = strin.readLine();
  34.             return str;
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.             return "";
  38.         }
  39.     }
  40. }

由上代码可知：此时上新一个新品蛋糕，只需新增一个新品蛋糕类，修改SimpleFactory工厂类一处即可实现需求调整。

新需求：如果此时需要生产同一类型的蛋糕不同口味，如：奶油蛋糕的中国口味，奶油蛋糕的美国口味。
实现方式一：细化蛋糕类，新增一种口味蛋糕当做一个新品蛋糕（即把原来的奶油蛋糕类细化成不同口味的奶油蛋糕）
实现方式二：复制多份简单工厂，如一个中国简单工厂，一个美国简单工厂

方式一、二可以实现，但考虑到项目规模，可维护性和可扩展性来说，不是一个很好的方案。有没有什么好的方式可以很好的解决这个问题？==》工厂方法模式

框架或项目源码分析

JDK中的Calendar类使用的是简单工厂模式

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


应用场景

对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。