创建型设计模式--工厂模式、抽象工厂模式
一、小案例分析
1、功能需求:
实现一个发送信息的功能,要便于扩展与维护。
(1)发送信息的工具有很多,比如短信、微信、邮件、QQ等。
(2)选择某个工具进行信息发送。
2、小菜鸡去实现:
(1)定义一个发送工具的父类(接口),并将各种发送工具作为子类(实现类)。
(2)定义一个选择发送工具的类,用于调用发送工具(直接new个子类对象)。
(3)代码实现:
package creative.pattern.factory.noFactory; import java.util.Scanner; /** * 测试类 * */ public class Demo { public static void main(String[] args) { new SendMessage();// 实例化一个选择发送工具的类 } } /** * 定义一个发送工具的接口 * */ interface Sender { void sendMessage(); } /** * 定义一个短信发送工具,实现接口,重写方法 * */ class ShortMessageSender implements Sender { @Override public void sendMessage() { System.out.println("发送短信"); } } /** * 定义一个微信发送工具,实现接口,重写方法 * */ class WeChatSender implements Sender { @Override public void sendMessage() { System.out.println("发送微信"); } } /** * 定义一个邮件发送工具,实现接口,重写方法 * */ class MailSender implements Sender { @Override public void sendMessage() { System.out.println("发送邮件"); } } /** * 定义一个选择发送工具的类 */ class SendMessage { /** * 用于获取需要发送信息工具 */ public Sender getSenderType() { System.out.println("输入发送工具的类型(1-3):"); System.out.println("1:短信"); System.out.println("2:微信"); System.out.println("3:邮件"); Scanner scanner = new Scanner(System.in); String senderType = scanner.nextLine(); if ("1".equals(senderType)) { return new ShortMessageSender(); } else if ("2".equals(senderType)) { return new WeChatSender(); } else if ("3".equals(senderType)) { return new MailSender(); } else { return null; } } public SendMessage() { do { Sender sender = getSenderType();// 选择发送信息的工具 if (sender == null) { System.out.println("欢迎下次使用"); break; } else { sender.sendMessage(); } } while (true); } }
(4)代码分析:
对于逻辑简单的代码,这样实现没有问题,但是逻辑稍微复杂一些且需要修改扩展某个地方时,需要改动很多地方。
比如:再增加一个 QQSender,其需要实现Sender接口,并重写相关方法,然后需要在 SendMessage 类中 去修改相关代码,这里违反了开闭原则。若需要增加几个SendMessage 类,比如SendMessage2、SendMessage3时,同样需要改动很多代码。
(5)UML图:
二、简单工厂模式(SimpleFactory)
1、什么是简单工厂模式:
简单工厂模式属于创建型模式,不属于常见的23种常见模式。简单的讲 简单工厂模式是由一个工厂对象决定创建出哪一类产品的实例。
2、使用:
(1)简单工厂模式,定义了一个创建对象的类,然后由这个类来封装实例化对象的操作。
(2)当需要大量创建某种类或者对象时,可以使用工厂模式。
3、使用简单工厂模式实现:
(1)定义一个发送工具的父类(接口),并将各种发送工具作为子类(实现类)。
(2)定义一个工厂类,用于调用发送工具。
(2)定义一个选择发送工具的类,用于调用工厂类。
(3)代码实现:
package creative.pattern.factory.simpleFactory; import java.util.Scanner; /** * 测试类 * */ public class SimpleFactoryDemo { public static void main(String[] args) { new SendMessage(); } } /** * 定义一个发送工具的接口 * */ interface Sender { void sendMessage(); } /** * 定义一个短信发送工具,实现接口,重写方法 * */ class ShortMessageSender implements Sender { @Override public void sendMessage() { System.out.println("发送短信"); } } /** * 定义一个微信发送工具,实现接口,重写方法 * */ class WeChatSender implements Sender { @Override public void sendMessage() { System.out.println("发送微信"); } } /** * 定义一个邮件发送工具,实现接口,重写方法 * */ class MailSender implements Sender { @Override public void sendMessage() { System.out.println("发送邮件"); } } /** * 使用简单工厂模式,管理需要生产的对象 * */ class SimpleFactory { /** * 用于获取需要发送信息工具 */ public static Sender createSender() { System.out.println("输入发送工具的类型(1-3):"); System.out.println("1:短信"); System.out.println("2:微信"); System.out.println("3:邮件"); Scanner scanner = new Scanner(System.in); String senderType = scanner.nextLine(); if ("1".equals(senderType)) { return new ShortMessageSender(); } else if ("2".equals(senderType)) { return new WeChatSender(); } else if ("3".equals(senderType)) { return new MailSender(); } else { return null; } } } /** * 定义一个选择发送工具的类 */ class SendMessage { public SendMessage() { do { Sender sender = SimpleFactory.createSender();// 选择发送信息的工具 if (sender == null) { System.out.println("欢迎下次使用"); break; } else { sender.sendMessage(); } } while (true); } }
(4)代码分析:
对于上述代码,SendMessage 只与工厂类SimpleFactory 相关联,此时需要扩展代码时,比如扩展QQSender,让其实现Sender并重写方法后,在SimpleFactory 中改变相关代码即可(违反开闭原则),不需要再改动SendMessage 的代码。
(5)UML图:
4、使用静态工厂模式实现(常用形式):
将上例的SimpleFactory 中public Sender createSender()改为 public static Sender createSender()。
调用时,直接使用SimpleFactory.createSender() 即可。
public static Sender createSender() { System.out.println("输入发送工具的类型(1-3):"); System.out.println("1:短信"); System.out.println("2:微信"); System.out.println("3:邮件"); Scanner scanner = new Scanner(System.in); String senderType = scanner.nextLine(); if ("1".equals(senderType)) { return new ShortMessageSender(); } else if ("2".equals(senderType)) { return new WeChatSender(); } else if ("3".equals(senderType)) { return new MailSender(); } else { return null; } }
三、工厂方法模式
1、什么是工厂方法模式:
在工厂内部定义一个创建对象的抽象方法,由子类去确定要实例化的对象。简单的讲 工厂方法模式将对象实例化的操作推迟到子类去实现。可以看做抽象工厂模式的一个常见类型。
2、使用工厂模式实现:
(1)定义一个发送工具的父类(接口),并将各种发送工具作为子类(实现类)。
(2)定义一个工厂方法接口,并通过工厂实现类去实例化对象。
(3)定义一个选择发送工具的类,用于调用工厂实现类。
(4)代码实现:
package creative.pattern.factory.factoryMethod; import java.util.Scanner; /** * 工厂方法模式测试类 * */ public class factoryMethodDemo { public static void main(String[] args) { new SendMessage(); } } /** * 定义一个发送工具的接口 * */ interface Sender { void sendMessage(); } /** * 定义一个短信发送工具,实现接口,重写方法 * */ class ShortMessageSender implements Sender { @Override public void sendMessage() { System.out.println("发送短信"); } } /** * 定义一个微信发送工具,实现接口,重写方法 * */ class WeChatSender implements Sender { @Override public void sendMessage() { System.out.println("发送微信"); } } /** * 定义一个邮件发送工具,实现接口,重写方法 * */ class MailSender implements Sender { @Override public void sendMessage() { System.out.println("发送邮件"); } } /** * 使用工厂方法模式,让子类去创建对象 * */ interface FactoryMethod { Sender sendMessage(); } /** * 短信工厂类,实现工厂方法类并重写相关方法 * */ class ShortMessageFactory implements FactoryMethod { @Override public Sender sendMessage() { return new ShortMessageSender(); } } /** * 微信工厂类,实现工厂方法类并重写相关方法 * */ class WeChatFactory implements FactoryMethod { @Override public Sender sendMessage() { return new WeChatSender(); } } /** * 邮件工厂类,实现工厂方法类并重写相关方法 * */ class MailFactory implements FactoryMethod { @Override public Sender sendMessage() { return new MailSender(); } } /** * 定义一个选择发送工具的类 */ class SendMessage { public SendMessage() { do { System.out.println("输入发送工具的类型(1-3):"); System.out.println("1:短信"); System.out.println("2:微信"); System.out.println("3:邮件"); Scanner scanner = new Scanner(System.in); String senderType = scanner.nextLine(); if ("1".equals(senderType)) { FactoryMethod factoryMethod = new ShortMessageFactory(); Sender sender = factoryMethod.sendMessage();// 选择发送短信 sender.sendMessage(); } else if ("2".equals(senderType)) { FactoryMethod factoryMethod = new WeChatFactory(); Sender sender = factoryMethod.sendMessage();// 选择发送微信 sender.sendMessage(); } else if ("3".equals(senderType)) { FactoryMethod factoryMethod = new MailFactory(); Sender sender = factoryMethod.sendMessage();// 选择发送邮件 sender.sendMessage(); } else { System.out.println("欢迎下次使用"); break; } } while (true); } }
(5)代码分析:
SendMessage 类只与FactoryMethod 有关,当扩展新的功能时,比如QQSender,只需创建一个QQFactory,实现FactoryMethod 并重写其方法即可,调用时无需更改其他代码(必要的逻辑处理除外,符合开闭原则)。
(6)UML图:
四、抽象工厂模式
1、什么是抽象工厂模式
为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。
注:
产品族:是指位于不同产品等级结构中功能相关联的产品组成的家族。
产品等级结构:可以理解为一个接口或者一个抽象类。
2、抽象工厂模式与工厂方法模式的区别
(1)抽象工厂模式是工厂方法模式的升级版,其针对的是多个产品等级结构,即抽象工厂模式所提供的产品是衍生自不同的接口或抽象类。
(2)工厂方法模式:针对一个产品等级结构,即工厂方法模式衍生自同一个接口或者抽象类。
(3)如下图所示,ShortMessage 与 WeChat属于同一个产品等级,ShortMessage 与 ShortMessage2属于两个产品等级,为产品族。所以若存在两个产品等级及以上的情况,即为抽象工厂模式,若是同一个产品等级,则为工厂方法模式。
下图为工厂方法模式:
下图为抽象工厂模式:
3、举例:
在之前案例的基础上,增加一个功能,微信、短信均可以图片。
(1)定义一个发送工具的父类(接口),并将各种发送工具作为子类(实现类)。
(2)定义一个工厂方法接口,在方法中对产品族进行约束,并通过工厂实现类去实例化对象。
(3)定义一个选择发送工具的类(测试类),用于调用工厂实现类。
(4)代码实现:
package creative.pattern.factory.absFactory; /** * 抽象工厂模式测试类 * */ public class AbsFactoryDemo { public static void main(String[] args) { AbsFactory absFactory = new WeChatFactory(); absFactory.getSender().sendMessage(); absFactory.getSender2().sendMessage(); ((WeChatSender2) absFactory.getSender2()).sendPicture(); AbsFactory absFactory2 = new ShortMessageFactory(); absFactory2.getSender().sendMessage(); absFactory2.getSender2().sendMessage(); ((ShortMessageSender2) absFactory2.getSender2()).sendPicture(); } } /** * 定义一个发送工具的接口 * */ interface Sender { void sendMessage(); } /** * 定义一个微信发送工具,实现接口,重写方法 * */ class WeChatSender implements Sender { @Override public void sendMessage() { System.out.println("使用微信,发送短信"); } } /** * 定义一个微信发送工具,实现接口,重写方法,并新增自己的方法 * */ class WeChatSender2 implements Sender { @Override public void sendMessage() { System.out.println("使用微信,发送短信"); } public void sendPicture() { System.out.println("使用微信,发送图片"); } } /** * 定义一个短信发送工具,实现接口,重写方法 * */ class ShortMessageSender implements Sender { @Override public void sendMessage() { System.out.println("使用短信,发送短信"); } } /** * 定义一个短信发送工具,实现接口,重写方法,并新增自己的方法 * */ class ShortMessageSender2 implements Sender { @Override public void sendMessage() { System.out.println("使用短信,发送短信"); } public void sendPicture() { System.out.println("使用短信,发送图片"); } } /** * 抽象工厂模式 * */ interface AbsFactory { Sender getSender(); Sender getSender2(); } /** * 工厂子类,实现抽象工厂类,重写相关方法, * */ class WeChatFactory implements AbsFactory { @Override public Sender getSender() { return new WeChatSender(); } @Override public Sender getSender2() { return new WeChatSender2(); } } /** * 工厂子类,实现抽象工厂类,重写相关方法, * */ class ShortMessageFactory implements AbsFactory { @Override public Sender getSender() { return new ShortMessageSender(); } @Override public Sender getSender2() { return new ShortMessageSender2(); } }
(5)代码分析:
对于产品族,定义在一个接口中,然后通过不同的子类去实现。扩展时,只需要实现接口并重写相关方法即可,满足开闭原则。
(6)UML图:
五、JDK中工厂模式举例(Calendar)
1、部分源码
public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> { /** * Gets a calendar using the default time zone and locale. The * <code>Calendar</code> returned is based on the current time * in the default time zone with the default * {@link Locale.Category#FORMAT FORMAT} locale. * * @return a Calendar. */ public static Calendar getInstance() { return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT)); } private static Calendar createCalendar(TimeZone zone, Locale aLocale) { CalendarProvider provider = LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale) .getCalendarProvider(); if (provider != null) { try { return provider.getInstance(zone, aLocale); } catch (IllegalArgumentException iae) { // fall back to the default instantiation } } Calendar cal = null; if (aLocale.hasExtensions()) { String caltype = aLocale.getUnicodeLocaleType("ca"); if (caltype != null) { switch (caltype) { case "buddhist": cal = new BuddhistCalendar(zone, aLocale); break; case "japanese": cal = new JapaneseImperialCalendar(zone, aLocale); break; case "Gregory": cal = new GregorianCalendar(zone, aLocale); break; } } } if (cal == null) { // If no known calendar type is explicitly specified, // perform the traditional way to create a Calendar: // create a BuddhistCalendar for th_TH locale, // a JapaneseImperialCalendar for ja_JP_JP locale, or // a GregorianCalendar for any other locales. // NOTE: The language, country and variant strings are interned. if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") { cal = new BuddhistCalendar(zone, aLocale); } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja" && aLocale.getCountry() == "JP") { cal = new JapaneseImperialCalendar(zone, aLocale); } else { cal = new GregorianCalendar(zone, aLocale); } } return cal; } }
2、源码分析
Calendar内部采用简单工厂模式进行对象的实例化。其根据不同的逻辑判断条件来选择实例化具体的对象。
六、总结:
1、工厂模式的意义:
将实例化对象的代码提取出来,放到一个类(工厂类)里面进行维护,使其与主项目解耦,提高程序的维护性与扩展性。
2、传统模式:
直接在需要的地方实例化某对象。扩展代码时,需要在使用到的地方进行修改,违反了开闭原则。
3、简单工厂模式:
在需要用到的地方,调用工厂类即可,扩展代码时,修改工厂类即可,也违反了开闭原则。
(1)简单工厂模式(普通方法):
使用一个工厂类,在某方法中通过逻辑处理并实例化需要的对象。
(2)简单工厂模式(静态方法):
将简单工厂模式(普通方法)的普通方法改为静态方法,并通过”类名.方法名“来调用。
(3)简单工厂模式(多方法):
使用一个工厂类,并通过调用不同的方法去实例化不同的对象。
4、工厂方法模式:
使用一个工厂类接口与多个工厂实现类,在不同的工厂实现类中去实例化不同的对象。扩展代码时,定义一个工厂实现类,实现工厂类接口并重写相关方法即可,满足开闭原则。可以理解为抽象工厂模式的一般形式。
5、抽象工厂模式:
可以理解为工厂方法模式的升级版,其在一个接口中定义了一个产品族的处理(多个方法),子类实现该接口,并重写相关方法即可,扩展类似于工厂方法模式,满足开闭原则。