经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
创建模式--工厂模式、抽象工厂模式
来源：cnblogs　　作者：累成一条狗　　时间：2019/8/7 8:50:26　　对本文有异议

一、小案例分析

1、功能需求：

　　实现一个发送信息的功能，要便于扩展与维护。
（1）发送信息的工具有很多，比如短信、微信、邮件、QQ等。
（2）选择某个工具进行信息发送。

2、小菜鸡去实现：

（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个选择发送工具的类，用于调用发送工具（直接new个子类对象）。
（3）代码实现：

  1. package creative.pattern.factory.noFactory;
  3. import java.util.Scanner;
  5. /**
  6.  * 测试类
  7.  *
  8.  */
  9. public class Demo {
  10.     public static void main(String[] args) {
  11.         new SendMessage();// 实例化一个选择发送工具的类
  12.     }
  13. }
  15. /**
  16.  * 定义一个发送工具的接口
  17.  *
  18.  */
  19. interface Sender {
  20.     void sendMessage();
  21. }
  23. /**
  24.  * 定义一个短信发送工具，实现接口，重写方法
  25.  *
  26.  */
  27. class ShortMessageSender implements Sender {
  29.     @Override
  30.     public void sendMessage() {
  31.         System.out.println("发送短信");
  32.     }
  33. }
  35. /**
  36.  * 定义一个微信发送工具，实现接口，重写方法
  37.  *
  38.  */
  39. class WeChatSender implements Sender {
  41.     @Override
  42.     public void sendMessage() {
  43.         System.out.println("发送微信");
  44.     }
  45. }
  47. /**
  48.  * 定义一个邮件发送工具，实现接口，重写方法
  49.  *
  50.  */
  51. class MailSender implements Sender {
  53.     @Override
  54.     public void sendMessage() {
  55.         System.out.println("发送邮件");
  56.     }
  57. }
  59. /**
  60.  * 定义一个选择发送工具的类
  61.  */
  62. class SendMessage {
  63.     /**
  64.      * 用于获取需要发送信息工具
  65.      */
  66.     public Sender getSenderType() {
  67.         System.out.println("输入发送工具的类型（1-3）：");
  68.         System.out.println("1:短信");
  69.         System.out.println("2:微信");
  70.         System.out.println("3:邮件");
  71.         Scanner scanner = new Scanner(System.in);
  72.         String senderType = scanner.nextLine();
  73.         if ("1".equals(senderType)) {
  74.             return new ShortMessageSender();
  75.         } else if ("2".equals(senderType)) {
  76.             return new WeChatSender();
  77.         } else if ("3".equals(senderType)) {
  78.             return new MailSender();
  79.         } else {
  80.             return null;
  81.         }
  82.     }
  84.     public SendMessage() {
  85.         do {
  86.             Sender sender = getSenderType();// 选择发送信息的工具
  87.             if (sender == null) {
  88.                 System.out.println("欢迎下次使用");
  89.                 break;
  90.             } else {
  91.                 sender.sendMessage();
  92.             }
  93.         } while (true);
  94.     }
  95. }

（4）代码分析：
　　对于逻辑简单的代码，这样实现没有问题，但是逻辑稍微复杂一些且需要修改扩展某个地方时，需要改动很多地方。
　　比如：再增加一个 QQSender，其需要实现Sender接口，并重写相关方法，然后需要在 SendMessage 类中 去修改相关代码，这里违反了开闭原则。若需要增加几个SendMessage 类，比如SendMessage2、SendMessage3时，同样需要改动很多代码。
（5）UML图：

 

二、简单工厂模式（SimpleFactory）

1、什么是简单工厂模式：

　　简单工厂模式属于创建型模式，不属于常见的23种常见模式。简单的讲 简单工厂模式是由一个工厂对象决定创建出哪一类产品的实例。

2、使用：

（1）简单工厂模式，定义了一个创建对象的类，然后由这个类来封装实例化对象的操作。
（2）当需要大量创建某种类或者对象时，可以使用工厂模式。

3、使用简单工厂模式实现：

（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个工厂类，用于调用发送工具。
（2）定义一个选择发送工具的类，用于调用工厂类。
（3）代码实现：

  1. package creative.pattern.factory.simpleFactory;
  3. import java.util.Scanner;
  5. /**
  6.  * 测试类
  7.  *
  8.  */
  9. public class SimpleFactoryDemo {
  10.     public static void main(String[] args) {
  11.         new SendMessage();
  12.     }
  13. }
  15. /**
  16.  * 定义一个发送工具的接口
  17.  *
  18.  */
  19. interface Sender {
  20.     void sendMessage();
  21. }
  23. /**
  24.  * 定义一个短信发送工具，实现接口，重写方法
  25.  *
  26.  */
  27. class ShortMessageSender implements Sender {
  29.     @Override
  30.     public void sendMessage() {
  31.         System.out.println("发送短信");
  32.     }
  33. }
  35. /**
  36.  * 定义一个微信发送工具，实现接口，重写方法
  37.  *
  38.  */
  39. class WeChatSender implements Sender {
  41.     @Override
  42.     public void sendMessage() {
  43.         System.out.println("发送微信");
  44.     }
  45. }
  47. /**
  48.  * 定义一个邮件发送工具，实现接口，重写方法
  49.  *
  50.  */
  51. class MailSender implements Sender {
  53.     @Override
  54.     public void sendMessage() {
  55.         System.out.println("发送邮件");
  56.     }
  57. }
  59. /**
  60.  * 使用简单工厂模式，管理需要生产的对象
  61.  *
  62.  */
  63. class SimpleFactory {
  64.     /**
  65.      * 用于获取需要发送信息工具
  66.      */
  67.     public static Sender createSender() {
  68.         System.out.println("输入发送工具的类型（1-3）：");
  69.         System.out.println("1:短信");
  70.         System.out.println("2:微信");
  71.         System.out.println("3:邮件");
  72.         Scanner scanner = new Scanner(System.in);
  73.         String senderType = scanner.nextLine();
  74.         if ("1".equals(senderType)) {
  75.             return new ShortMessageSender();
  76.         } else if ("2".equals(senderType)) {
  77.             return new WeChatSender();
  78.         } else if ("3".equals(senderType)) {
  79.             return new MailSender();
  80.         } else {
  81.             return null;
  82.         }
  83.     }
  84. }
  86. /**
  87.  * 定义一个选择发送工具的类
  88.  */
  89. class SendMessage {
  90.     public SendMessage() {
  91.         do {
  92.             Sender sender = SimpleFactory.createSender();// 选择发送信息的工具
  93.             if (sender == null) {
  94.                 System.out.println("欢迎下次使用");
  95.                 break;
  96.             } else {
  97.                 sender.sendMessage();
  98.             }
  99.         } while (true);
  100.     }
  101. }

（4）代码分析：
　　对于上述代码，SendMessage 只与工厂类SimpleFactory 相关联，此时需要扩展代码时，比如扩展QQSender，让其实现Sender并重写方法后，在SimpleFactory 中改变相关代码即可（违反开闭原则），不需要再改动SendMessage 的代码。
（5）UML图：

 

4、使用静态工厂模式实现（常用形式）：

　　将上例的SimpleFactory 中public Sender createSender()改为 public static Sender createSender()。
　　调用时，直接使用SimpleFactory.createSender() 即可。

  1.  public static Sender createSender() {
  2.         System.out.println("输入发送工具的类型（1-3）：");
  3.         System.out.println("1:短信");
  4.         System.out.println("2:微信");
  5.         System.out.println("3:邮件");
  6.         Scanner scanner = new Scanner(System.in);
  7.         String senderType = scanner.nextLine();
  8.         if ("1".equals(senderType)) {
  9.             return new ShortMessageSender();
  10.         } else if ("2".equals(senderType)) {
  11.             return new WeChatSender();
  12.         } else if ("3".equals(senderType)) {
  13.             return new MailSender();
  14.         } else {
  15.             return null;
  16.         }
  17.     }

三、工厂方法模式

1、什么是工厂方法模式：

　　在工厂内部定义一个创建对象的抽象方法，由子类去确定要实例化的对象。简单的讲 工厂方法模式将对象实例化的操作推迟到子类去实现。可以看做抽象工厂模式的一个常见类型。

2、使用工厂模式实现：

（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个工厂方法接口，并通过工厂实现类去实例化对象。
（3）定义一个选择发送工具的类，用于调用工厂实现类。
（4）代码实现：

  1. package creative.pattern.factory.factoryMethod;
  3. import java.util.Scanner;
  5. /**
  6.  * 工厂方法模式测试类
  7.  *
  8.  */
  9. public class factoryMethodDemo {
  10.     public static void main(String[] args) {
  11.         new SendMessage();
  12.     }
  13. }
  15. /**
  16.  * 定义一个发送工具的接口
  17.  *
  18.  */
  19. interface Sender {
  20.     void sendMessage();
  21. }
  23. /**
  24.  * 定义一个短信发送工具，实现接口，重写方法
  25.  *
  26.  */
  27. class ShortMessageSender implements Sender {
  29.     @Override
  30.     public void sendMessage() {
  31.         System.out.println("发送短信");
  32.     }
  33. }
  35. /**
  36.  * 定义一个微信发送工具，实现接口，重写方法
  37.  *
  38.  */
  39. class WeChatSender implements Sender {
  41.     @Override
  42.     public void sendMessage() {
  43.         System.out.println("发送微信");
  44.     }
  45. }
  47. /**
  48.  * 定义一个邮件发送工具，实现接口，重写方法
  49.  *
  50.  */
  51. class MailSender implements Sender {
  53.     @Override
  54.     public void sendMessage() {
  55.         System.out.println("发送邮件");
  56.     }
  57. }
  59. /**
  60.  * 使用工厂方法模式，让子类去创建对象
  61.  *
  62.  */
  63. interface FactoryMethod {
  64.     Sender sendMessage();
  65. }
  67. /**
  68.  * 短信工厂类，实现工厂方法类并重写相关方法
  69.  *
  70.  */
  71. class ShortMessageFactory implements FactoryMethod {
  73.     @Override
  74.     public Sender sendMessage() {
  75.         return new ShortMessageSender();
  76.     }
  77. }
  79. /**
  80.  * 微信工厂类，实现工厂方法类并重写相关方法
  81.  *
  82.  */
  83. class WeChatFactory implements FactoryMethod {
  85.     @Override
  86.     public Sender sendMessage() {
  87.         return new WeChatSender();
  88.     }
  89. }
  91. /**
  92.  * 邮件工厂类，实现工厂方法类并重写相关方法
  93.  *
  94.  */
  95. class MailFactory implements FactoryMethod {
  97.     @Override
  98.     public Sender sendMessage() {
  99.         return new MailSender();
  100.     }
  101. }
  103. /**
  104.  * 定义一个选择发送工具的类
  105.  */
  106. class SendMessage {
  107.     public SendMessage() {
  108.         do {
  109.             System.out.println("输入发送工具的类型（1-3）：");
  110.             System.out.println("1:短信");
  111.             System.out.println("2:微信");
  112.             System.out.println("3:邮件");
  113.             Scanner scanner = new Scanner(System.in);
  114.             String senderType = scanner.nextLine();
  115.             if ("1".equals(senderType)) {
  116.                 FactoryMethod factoryMethod = new ShortMessageFactory();
  117.                 Sender sender = factoryMethod.sendMessage();// 选择发送短信
  118.                 sender.sendMessage();
  119.             } else if ("2".equals(senderType)) {
  120.                 FactoryMethod factoryMethod = new WeChatFactory();
  121.                 Sender sender = factoryMethod.sendMessage();// 选择发送微信
  122.                 sender.sendMessage();
  123.             } else if ("3".equals(senderType)) {
  124.                 FactoryMethod factoryMethod = new MailFactory();
  125.                 Sender sender = factoryMethod.sendMessage();// 选择发送邮件
  126.                 sender.sendMessage();
  127.             } else {
  128.                 System.out.println("欢迎下次使用");
  129.                 break;
  130.             }
  131.         } while (true);
  132.     }
  133. }

（5）代码分析：
　　SendMessage 类只与FactoryMethod 有关，当扩展新的功能时，比如QQSender，只需创建一个QQFactory，实现FactoryMethod 并重写其方法即可，调用时无需更改其他代码（必要的逻辑处理除外，符合开闭原则）。
（6）UML图：

 

四、抽象工厂模式

1、什么是抽象工厂模式

　　为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
注：
　　产品族：是指位于不同产品等级结构中功能相关联的产品组成的家族。
　　产品等级结构：可以理解为一个接口或者一个抽象类。

2、抽象工厂模式与工厂方法模式的区别

（1）抽象工厂模式是工厂方法模式的升级版，其针对的是多个产品等级结构，即抽象工厂模式所提供的产品是衍生自不同的接口或抽象类。
（2）工厂方法模式：针对一个产品等级结构，即工厂方法模式衍生自同一个接口或者抽象类。
（3）如下图所示，ShortMessage 与 WeChat属于同一个产品等级，ShortMessage 与 ShortMessage2属于两个产品等级，为产品族。所以若存在两个产品等级及以上的情况，即为抽象工厂模式，若是同一个产品等级，则为工厂方法模式。
　　下图为工厂方法模式：

下图为抽象工厂模式：

3、举例：

　　在之前案例的基础上，增加一个功能，微信、短信均可以图片。
（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个工厂方法接口，在方法中对产品族进行约束，并通过工厂实现类去实例化对象。
（3）定义一个选择发送工具的类（测试类），用于调用工厂实现类。
（4）代码实现：

  1. package creative.pattern.factory.absFactory;
  3. /**
  4.  * 抽象工厂模式测试类
  5.  *
  6.  */
  7. public class AbsFactoryDemo {
  8.     public static void main(String[] args) {
  9.         AbsFactory absFactory = new WeChatFactory();
  10.         absFactory.getSender().sendMessage();
  11.         absFactory.getSender2().sendMessage();
  12.         ((WeChatSender2) absFactory.getSender2()).sendPicture();
  14.         AbsFactory absFactory2 = new ShortMessageFactory();
  15.         absFactory2.getSender().sendMessage();
  16.         absFactory2.getSender2().sendMessage();
  17.         ((ShortMessageSender2) absFactory2.getSender2()).sendPicture();
  18.     }
  19. }
  21. /**
  22.  * 定义一个发送工具的接口
  23.  *
  24.  */
  25. interface Sender {
  26.     void sendMessage();
  27. }
  29. /**
  30.  * 定义一个微信发送工具，实现接口，重写方法
  31.  *
  32.  */
  33. class WeChatSender implements Sender {
  35.     @Override
  36.     public void sendMessage() {
  37.         System.out.println("使用微信，发送短信");
  38.     }
  39. }
  41. /**
  42.  * 定义一个微信发送工具，实现接口，重写方法，并新增自己的方法
  43.  *
  44.  */
  45. class WeChatSender2 implements Sender {
  47.     @Override
  48.     public void sendMessage() {
  49.         System.out.println("使用微信，发送短信");
  50.     }
  52.     public void sendPicture() {
  53.         System.out.println("使用微信，发送图片");
  54.     }
  55. }
  57. /**
  58.  * 定义一个短信发送工具，实现接口，重写方法
  59.  *
  60.  */
  61. class ShortMessageSender implements Sender {
  63.     @Override
  64.     public void sendMessage() {
  65.         System.out.println("使用短信，发送短信");
  66.     }
  67. }
  69. /**
  70.  * 定义一个短信发送工具，实现接口，重写方法，并新增自己的方法
  71.  *
  72.  */
  73. class ShortMessageSender2 implements Sender {
  75.     @Override
  76.     public void sendMessage() {
  77.         System.out.println("使用短信，发送短信");
  78.     }
  80.     public void sendPicture() {
  81.         System.out.println("使用短信，发送图片");
  82.     }
  83. }
  85. /**
  86.  * 抽象工厂模式
  87.  *
  88.  */
  89. interface AbsFactory {
  90.     Sender getSender();
  92.     Sender getSender2();
  93. }
  95. /**
  96.  * 工厂子类，实现抽象工厂类，重写相关方法，
  97.  *
  98.  */
  99. class WeChatFactory implements AbsFactory {
  101.     @Override
  102.     public Sender getSender() {
  103.         return new WeChatSender();
  104.     }
  106.     @Override
  107.     public Sender getSender2() {
  108.         return new WeChatSender2();
  109.     }
  110. }
  112. /**
  113.  * 工厂子类，实现抽象工厂类，重写相关方法，
  114.  *
  115.  */
  116. class ShortMessageFactory implements AbsFactory {
  118.     @Override
  119.     public Sender getSender() {
  120.         return new ShortMessageSender();
  121.     }
  123.     @Override
  124.     public Sender getSender2() {
  125.         return new ShortMessageSender2();
  126.     }
  127. }

（5）代码分析：
　　对于产品族，定义在一个接口中，然后通过不同的子类去实现。扩展时，只需要实现接口并重写相关方法即可，满足开闭原则。

（6）UML图：

五、JDK中工厂模式举例（Calendar）

1、部分源码

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

2、源码分析

　　Calendar内部采用简单工厂模式进行对象的实例化。其根据不同的逻辑判断条件来选择实例化具体的对象。

 

六、总结：

1、工厂模式的意义：

　　将实例化对象的代码提取出来，放到一个类（工厂类）里面进行维护，使其与主项目解耦，提高程序的维护性与扩展性。

2、传统模式：

　　直接在需要的地方实例化某对象。扩展代码时，需要在使用到的地方进行修改，违反了开闭原则。

3、简单工厂模式：

　　在需要用到的地方，调用工厂类即可，扩展代码时，修改工厂类即可，也违反了开闭原则。
（1）简单工厂模式（普通方法）：
　　使用一个工厂类，在某方法中通过逻辑处理并实例化需要的对象。
（2）简单工厂模式（静态方法）：
　　将简单工厂模式（普通方法）的普通方法改为静态方法，并通过”类名.方法名“来调用。
（3）简单工厂模式（多方法）：
　　使用一个工厂类，并通过调用不同的方法去实例化不同的对象。

4、工厂方法模式：

　　使用一个工厂类接口与多个工厂实现类，在不同的工厂实现类中去实例化不同的对象。扩展代码时，定义一个工厂实现类，实现工厂类接口并重写相关方法即可，满足开闭原则。可以理解为抽象工厂模式的一般形式。

5、抽象工厂模式：

　　可以理解为工厂方法模式的升级版，其在一个接口中定义了一个产品族的处理（多个方法），子类实现该接口，并重写相关方法即可，扩展类似于工厂方法模式，满足开闭原则。

原文链接：http://www.cnblogs.com/l-y-h/p/11305441.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) &#183;装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号