创建模式--工厂模式、抽象工厂模式
一、小案例分析
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、抽象工厂模式:
可以理解为工厂方法模式的升级版,其在一个接口中定义了一个产品族的处理(多个方法),子类实现该接口,并重写相关方法即可,扩展类似于工厂方法模式,满足开闭原则。
上一篇: 设计模式之装饰者模式
下一篇: js验证小数或者数字