Java设计模式（5：设计模式的分类及工厂模式详解）

1.设计模式的分类一般来说，设计模式可以大致分为以下三类。

创意图案

,

结构模式

,

运动模式

具体如下。

2. 工厂模式工厂模式分为如下。

简单工厂模式

,

工厂方法模式

和

抽象工厂模式。在

简单工厂模式

虽然它不属于23种设计模式，但这并不影响它的流行。存在

JDK

源代码中有很多这样的例子。

2.1 简单工厂模式让我们首先看一些代码。

public static void main(String[] args) { //日历类Calendar Calendar=Calendar.getInstance()=new SimpleDateFormat(\’yyyy-MM-dd HH:mm:ss\’); + simpleDateFormat.format(calendar.getTime); ())); Calendar.add(Calendar.HOUR,2); System.out.println(\’当前时间加2 小时得到时间：\’ + simpleDateFormat .format (calendar.getTime());}代码大家应该都很熟悉。

日历

我们来看一下打印当前时间和当前时间加两个小时的一系列操作的结果。

结果符合预期，两次打印输出相隔两个小时。但我们今天的重点是

日历日历=Calendar.getInstance()

这段代码是

获取实例()

我发现如何

日历

类的实例。我们来看看具体的源码。

public static Calendar getInstance(){ return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT)); }//代码不完整。如果有兴趣，可以查看JDK源码private static Calendar createCalendar( TimeZone zone , Locale aLocale){ //中间的代码已被省略. Calendar cal=null if (aLocale.hasExtensions() ) { String caltype=aLocale.getUnicodeLocaleType(\’ca\’) if (caltype !=null) ) { switch (caltype) { case \’buddhist\’: cal=new BuddhaCalendar(zone, aLocale) case \’japanese\’: cal=new JapaneseImperialCalendar( zone, aLocale); case \’gregory\’: cal=new GregorianCalendar; (zone , aLocale); //中间代码已被省略. return cal;

获取实例()

在方法内调用

创建日历()

如何获得

日历

该类的实例最终返回给调用者。和

创建日历()

方法中传入的

切换大小写}

对应返回判断

日历

类的一个实例。实际上

简单工厂模式

应用。

我读完了

简单工厂模式

存在

JDK

创建应用程序后，让我们设计自己的示例。

小明家里新开了一家小工厂，接到了帮助海尔集团生产冰箱的业务，需要设计相应的解决方案。小明本身也是一名程序员。想了一会儿，我写了下面的代码。

/** * 冰箱*/public Interface IFridge { //创建冰箱public void createFridge();}/** * Haier*/public class Haier Implements IFridge { @Override public void createFridge() { System. \’我们生产海尔冰箱.\’); 客户调用代码：

public static void main(String[] args) { IFridge iFridge=new Haier(); } 看上面的代码，父类。

冰箱

类指向子类

海尔

类引用，应用层必须依赖

海尔。如果业务扩大，格力（

高兴

) 或更多，客户端上的代码变得越来越臃肿。因此，削弱这种依赖，

冰箱

对象详细信息被隐藏。我们正在使用

简单工厂模式

优化：

创造

高兴

绿色型

/** * 格力*/public class Greeimplements IFridge { @Override public void createFridge() { System.out.println(\’格力冰箱正在制造中.\’);

冰箱厂

工厂类

/** * Fridge Factory*/public class FridgeFactory { //创建对应的IFridge 实例public static IFridge createFridge(String name){ if (\’haier\’.equals(name)){ return new Haier() } else if ( \’ gree\’.equals(name)){ return new Gree() } return null; 更改客户端调用的代码。

public static void main(String[] args) { //海尔IFridge haier=FridgeFactory.createFridge(\’haier\’); //格力IFridge gree=FridgeFactory.createFridge(\’gree\’); } 看起来像这样很多代码，但更容易维护和扩展。我们来看一下类图。

当然，以上

冰箱厂

如果需要增加美的的产量，代码仍然存在一些问题。

美的

）冰箱，这种情况你需要更换

创建冰箱（）

方法中的代码明显违反了

开闭原理

我们来改造一下：

修订

冰箱厂

工厂类

/** * Fridge Factory*/public class FridgeFactory { //创建对应的IFridge 实例public static IFridge createFridge(String className){ try { if (null !=className !\’\’.equals(className)){ //反射return (IFridge)Class.forName(className).newInstance(); }catch (Exception e){ e.printStackTrace() }}更改客户端调用的代码。

public static void main(String[] args) { //将com.xxx.Haier 替换为项目中HaierIFridge 的位置haier=FridgeFactory.createFridge(\’com.xxx.Haier\’); //com.xxx.Gree 替换IFridge gree=FridgeFactory.createFridge(\’com.xxx.Gree\’); 与Gree在您项目中的位置进行优化后，不再需要遵循更改。基于业务改进

冰箱厂

类中的代码消失了。但还有一个问题，

创建冰箱（）

方法参数是字符串。如果有人随意输入的话，就会报错，我们再尝试优化一下。

修订

冰箱厂

工厂类

/** * Fridge Factory*/public class FridgeFactory { //创建对应的IFridge 实例public static IFridge createFridge(Class extends IFridge clazz){ try { if (clazz !=null){ return clazz.newInstance() } }catch; (Exception e){ e.printStackTrace() } return null; 更改客户端调用的代码。

public static void main(String[] args) { //Haier FridgeFactory.createFridge(Haier.class).createFridge(); //Gree FridgeFactory.createFridge(Gree.class).createFridge();} 看一下类图再次见面：

简单工厂模式

虽然它很容易使用，但它确实有一些限制。工厂类有很多责任，不适合扩展更复杂的产品结构。

2.2 工厂方法该模式定义了一个用于创建对象的接口，但工厂方法将类的实例化留给了子类。

使用工厂方法模式，用户只需要关心与自己想要的产品对应的工厂，而不用关心自己创建了什么，并且添加新产品是合规的。

开闭原理。

小敏新工厂的经营业绩不错，各品牌厂家纷纷希望小敏的工厂生产冰箱，小敏只好开设分厂，向客户提供产品。工厂有对应的名称：海尔工厂生产海尔冰箱，格力工厂生产格力冰箱，美的工厂生产美的冰箱。以下是如何使用代码演化：

我冰箱厂

类接口

公共接口IFridgeFactory { public IFridge createIFridge();} 海尔

//海尔工厂public class HaierFactoryimplements IFridgeFactory { @Override public IFridge createIFridge() { return new Haier(); }

//格力工厂public class GreeFactoryimplements IFridgeFactory { @Override public IFridge createIFridge() { return new Gree(); }

/** * 美的*/public class Mideaimplements IFridge { @Override public void createFridge() { System.out.println(\’美的冰箱生产中.\’); //美的public class MideaFactoryimplemented IFridge { @Override public IFridge createIFridge () { return new Midea() }}客户端调用：

public static void main(String[] args) { //格力new GreeFactory().createIFridge().createFridge(); //海尔new HaierFactory().createIFridge().createFridge(); //美的new MideaFactory();这实际上是改进了工厂，划分了业务，利用了设计模式的原理。

单一职责原则

，每个品牌对应的工厂只做一件事，不干涉其他品牌的运营。我们来看一下类图。

工厂方法模式适用于以下场景：

创建对象需要多次代码迭代

客户端（应用程序层）不依赖于诸如如何创建或实现产品类实例之类的细节。

类指定您通过其子类创建的对象。

工厂方法模式也有缺点。

太多的类很容易增加复杂性。

系统变得更加抽象和难以理解

2.3 抽象工厂模式定义：提供一个接口，用于创建一组相关或相互依赖的对象，而无需指定特定的类。

这个定义非常混乱、非常抽象、难以理解。或者将其与上面的示例结合起来。

冰箱大批量生产并销往市场后，美的、格力、海尔等企业非常满意，逐步将空调、热水器交给小民工厂生产。为此，小明在相应品牌工厂内预留了相应生产设备的空间（

为了您的方便，我将把所有代码放在这里。

）：冰箱、空调、热水器接口

//冰箱公共接口IFridge { //创建冰箱public void createFridge();}//空调公共接口IAirConditioner { //创建空调public void createAirConditioner();}//热水器公共接口IWaterHeater {//产生水的加热器public void createWaterHeater();} 海尔

/** * 海尔冰箱*/public class HaierFridgeimplements IFridge{ @Override public void createFridge() { System.out.println(\’海尔冰箱生产中.\’); //海尔空调public class HaierAirConditioner Implements IAirConditioner 要做的事情。 { @Override public void createAirConditioner() { System.out.println(\’海尔空调制造.\’) }}//海尔热水器public class HaierWaterHeater Implements IWaterHeater { @Override public void createWaterHeater() { System.out . println( \’海尔热水器制造.\’ }} 格力

/** * 格力冰箱*/public class GreeFridgeimplements IFridge { @Override public void createFridge() { System.out.println(\’Producting Gree Refrigerator.\’) }}//格力空调public class GreeAirConditioner 实现IAirConditioner Masu。 { @Override public void createAirConditioner() { System.out.println(\’制造格力空调.\’) }}//格力热水器public class GreeWaterHeater is IWaterHeater { @Override public void createWaterHeater() { System. println( \’生产格力热水器.\’ }} 美的

/** * 美的冰箱*/public class MideaFridgeimplements IFridge{ @Override public void createFridge() { System.out.println(\’制造美的冰箱.\’ }}//美的空调public class MideaAirConditionerimplement IAirConditioner; @Override public void createAirConditioner() { System.out.println(\’制作美的空调.\’) }}//美的热水器public class MideaWaterHeater Implements IWaterHeater { @Override public void createWaterHeater() { System.out .制作美的热水器.\’ }}工厂界面

12345678public Interface IFactory {//冰箱public IFridge createIFridge();//空调public IAirConditioner createIConditioner();//热水器public IWaterHeater createIWaterHeater();} 海尔工厂

//海尔工厂public class HaierFactoryimplemented IFactory { //冰箱@Override public IFridge createIFridge() { return new HaierFridge(); } //空调@Override public IAirConditioner createIConditioner() { return new HaierAirConditioner();Heater @Override public IWaterHeater createIWaterHeater () { return new HaierWaterHeater() }} 格力工厂

//Gree public class GreeFactoryimplements IFactory { //冰箱@Override public IFridge createIFridge() { return new GreeFridge(); }//空调@Override public IAirConditioner createIConditioner() { return new GreeAirConditioner(); @Override public IWaterHeater createIWaterHeater( ) { return new GreeWaterHeater() }} 美的工厂

public class MideaFactoryimplements IFactory { //冰箱@Override public IFridge createIFridge() { return new MideaFridge() } //空调@Override public IAirConditioner createIConditioner() { return new MideaAirConditioner() } //热水器@Override public IWaterHeater createIWaterHeater ( ) { return new MideaWaterHeater() }} 客户端调用

public static void main(String[] args) {//HaierFactory haierFactory=new HaierFactory.createIFridge().createFridge(); haierFactory.createIWaterHeater().createWaterHeater() ;//GreeFactory greeFactory=new GreeFactory.createIFridge().createFridge (); greeFactory.createIWaterHeater().createWaterHeater();mideaFactory.createIFridge().createFridge();mideaFactory.createIConditioner().createAirConditioner();} 类图

上面的大部分代码，尤其是

类图

，我们可以清楚地感觉到

抽象工厂

我可以完美清晰地讲解海尔、格力、美的三个品牌的冰箱、空调、热水器的庞大系统。但这就是为什么，

抽象工厂

对我们的视觉冲击是巨大的，我们可以清楚地感受到系统的效果。

复杂的

,

抽象

和系统化的

很难扩展

; 这里也隐藏了违规行为。

开闭原理

问题：

具有工厂接口

工厂

类，如果未来产品升级需要增加洗衣机制造业务，这里修改后，全部实现

工厂

所有接口类都必须更改，这显着增加了系统的稳定性。

为此，在实际的业务开发中，我们认为系统的结构设计必须完全符合各种原则，不能有很强的强迫症或洁癖。毕竟，如果系统结构的层次不经常更新，某些原则就不应该遵循。

所有技术都有助于商业。

作者：蔡晓明链接：https://www.cnblogs.com/caimm/p/14899740.html