转载请标明出处：
http://blog.csdn.net/zxt0601/article/details/52798423

本文出自:【张旭童的博客】

系列开篇瞎BB

设计模式相关的文章学习与总结，一直有意为之，一直又觉得时机不到。

一是怕自己代码经验还不够，学习了也不懂，强行理解没有意义。

二是怕自己学习了以后总结出来，万一有不对的地方，误人子弟。

而在现在的公司摸爬滚打半年后，感觉自己写代码遇到了瓶颈，想写好写优雅，却不清楚这么写究竟是自以为优雅还是真的优雅。或对着看一些系统源码、框架源码时，不太理解他们这么写是为什么。

于是我开始了学习之路，从比较简单的工厂模式开刀，看了大概10+篇资料，发现各位大大对工厂模式的各种写法叫法不一，理解也不一，而且没有一篇是比较全的收录各种写法的。so，这也坚定了我将它总结写出来的决心，既然每个人的理解都有或多或少的缺失或冲突，那我也总结一份我的理解，呈现出来，供各位看官参考点评。

一概述：

属于创建型设计模式，需要生成的对象叫做产品，生成对象的地方叫做工厂。

使用场景：

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。
直接用new可以完成的不需要用工厂模式

个人理解，重点就是这个复杂（构造函数有很多参数）和是否可以 直接用new。（不理解这句话的话，看完一圈例子就理解了）

下面逐个介绍我所知道的各种工厂模式以及它们的特点，使用场景，并尽可能的找出JDK SDK里它们的身影。

二简单（静态）工厂：

一个栗子：
我喜欢吃面条，抽象一个面条基类，(接口也可以)，这是产品的抽象类。

public abstract class INoodles {/*** 描述每种面条啥样的*/public abstract void desc();
}

先来一份兰州拉面（具体的产品类）：

public class LzNoodles extends INoodles {@Overridepublic void desc() {System.out.println("兰州拉面 上海的好贵 家里才5 6块钱一碗");}
}

程序员加班必备也要吃泡面（具体的产品类）：

public class PaoNoodles extends INoodles {@Overridepublic void desc() {System.out.println("泡面好吃 可不要贪杯");}
}

还有我最爱吃的家乡的干扣面（具体的产品类）：

public class GankouNoodles extends INoodles {@Overridepublic void desc() {System.out.println("还是家里的干扣面好吃 6块一碗");}
}

准备工作做完了，我们来到一家“简单面馆”（简单工厂类），菜单如下：

public class SimpleNoodlesFactory {public static final int TYPE_LZ = 1;//兰州拉面public static final int TYPE_PM = 2;//泡面public static final int TYPE_GK = 3;//干扣面public static INoodles createNoodles(int type) {switch (type) {case TYPE_LZ:return new LzNoodles();case TYPE_PM:return new PaoNoodles();case TYPE_GK:default:return new GankouNoodles();}}
}

简单面馆就提供三种面条（产品），你说你要啥，他就给你啥。这里我点了一份干扣面:

/*** 简单工厂模式*/INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_GK);noodles.desc();

输出：

还是家里的干扣面好吃 6块一碗

特点

1 它是一个具体的类，非接口抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。

2 create()方法通常是静态的，所以也称之为静态工厂。

缺点

1 扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）

2 不同的产品需要不同额外参数的时候不支持。

三另一种简单工厂（反射）：

利用反射Class.forName(clz.getName()).newInstance()实现的简单工厂：

public class StaticNoodlesFactory {/*** 传入Class实例化面条产品类** @param clz* @param <T>* @return*/public static <T extends INoodles> T createNoodles(Class<T> clz) {T result = null;try {result = (T) Class.forName(clz.getName()).newInstance();} catch (Exception e) {e.printStackTrace();}return result;}
}

点菜时：

        /*** 另一种简单工厂* 利用Class.forName(clz.getName()).newInstance()*/System.out.println("=====另一种简单工厂利用Class.forName(clz.getName()).newInstance()======" +"\n个人觉得不好，因为这样和简单的new一个对象一样，工厂方法应该用于复杂对象的初始化" +"\n 这样像为了工厂而工厂");//兰州拉面INoodles lz = StaticNoodlesFactory.createNoodles(LzNoodles.class);lz.desc();//泡面INoodles pm = StaticNoodlesFactory.createNoodles(PaoNoodles.class);pm.desc();

输出：

=====另一种简单工厂利用Class.forName(clz.getName()).newInstance()======
个人觉得不好，因为这样和简单的new一个对象一样，工厂方法应该用于复杂对象的初始化这样像为了工厂而工厂
兰州拉面 上海的好贵 家里才5 6块钱一碗
泡面好吃 可不要贪杯

特点

1 它也是一个具体的类，非接口抽象类。但它的create()方法，是利用反射机制生成对象返回，好处是增加一种产品时，不需要修改create()的代码。

缺点

这种写法粗看牛逼，细想之下，不谈reflection的效率还有以下问题：

1 个人觉得不好，因为Class.forName(clz.getName()).newInstance()调用的是无参构造函数生成对象，它和new Object()是一样的性质，而工厂方法应该用于复杂对象的初始化 ，当需要调用有参的构造函数时便无能为力了，这样像为了工厂而工厂。

2 不同的产品需要不同额外参数的时候不支持。

四多方法工厂（常用）

使用方法二三实现的工厂，都有一个缺点：不同的产品需要不同额外参数的时候不支持。

而且如果使用时传递的type、Class出错，将不能得到正确的对象，容错率不高。

而多方法的工厂模式为不同产品，提供不同的生产方法，使用时需要哪种产品就调用该种产品的方法，使用方便、容错率高。

工厂如下：

public class MulWayNoodlesFactory {/*** 模仿Executors 类* 生产泡面** @return*/public static INoodles createPm() {return new PaoNoodles();}/*** 模仿Executors 类* 生产兰州拉面** @return*/public static INoodles createLz() {return new LzNoodles();}/*** 模仿Executors 类* 生产干扣面** @return*/public static INoodles createGk() {return new GankouNoodles();}
}

使用时：

        /*** 多方法静态工厂(模仿Executor类）*/System.out.println("==============================模仿Executor类==============================" +"\n 这种我比较青睐，增加一个新面条，只要去增加一个static方法即可,也不修改原方法逻辑");INoodles lz2 = MulWayNoodlesFactory.createLz();lz2.desc();INoodles gk2 = MulWayNoodlesFactory.createGk();gk2.desc();

输出：

==============================模仿Executor类==============================
 这种我比较青睐，增加一个新面条，只要去增加一个static方法即可,也不修改原方法逻辑
兰州拉面 上海的好贵 家里才5 6块钱一碗
还是家里的干扣面好吃 6块一碗

源码撑腰环节

查看java源码：java.util.concurrent.Executors类便是一个生成Executor 的工厂，其采用的便是 多方法静态工厂模式：

例如ThreadPoolExecutor类构造方法有5个参数，其中三个参数写法固定，前两个参数可配置，如下写。

    public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}

又如JDK想增加创建ForkJoinPool类的方法了，只想配置parallelism参数，便在类里增加一个如下的方法：

    public static ExecutorService newWorkStealingPool(int parallelism) {return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);}

这个例子可以感受到工厂方法的魅力了吧：方便创建同种类型的复杂参数对象。

五普通工厂

普通工厂就是把简单工厂中具体的工厂类，划分成两层：抽象工厂层+具体的工厂子类层。（一般->特殊）

面条工厂（抽象工厂类），作用就是生产面条：

public abstract class NoodlesFactory {public abstract INoodles create();
}

兰州拉面工厂（具体工厂子类）：

public class LzFactory extends NoodlesFactory {@Overridepublic INoodles create() {return new LzNoodles();}
}

泡面工厂（具体工厂子类）：

public class PaoFactory extends NoodlesFactory {@Overridepublic INoodles create() {return new PaoNoodles();}
}

最爱的干扣面工厂（具体工厂子类）：

public class GankouFactory extends NoodlesFactory {@Overridepublic INoodles create() {return new GankouNoodles();}
}

使用时：

        /*** 普通工厂方法：*/System.out.println("===========================普通工厂方法==============================" +"\n 这种要多写一个类，不过更面向对象吧 = = ，实际中我更倾向于使用【模仿Executor类】的方式");NoodlesFactory factory1 = new GankouFactory();INoodles gk3 = factory1.create();gk3.desc();

输出：

===========================普通工厂方法==============================
 这种要多写一个类，不过更面向对象吧 = = ，实际中我更倾向于使用【模仿Executor类】的方式
还是家里的干扣面好吃 6块一碗

普通工厂与简单工厂模式的区别：

可以看出，普通工厂模式特点：不仅仅做出来的产品要抽象， 工厂也应该需要抽象。

工厂方法使一个产品类的实例化延迟到其具体工厂子类.

工厂方法的好处就是更拥抱变化。当需求变化，只需要增删相应的类，不需要修改已有的类。

而简单工厂需要修改工厂类的create()方法，多方法静态工厂模式需要增加一个静态方法。

缺点：

引入抽象工厂层后，每次新增一个具体产品类，也要同时新增一个具体工厂类，所以我更青睐多方法静态工厂。

六抽象工厂：

以上介绍的工厂都是单产品系的。抽象工厂是多产品系 （貌似也有产品家族的说法）。

举个例子来说，每个店(工厂)不仅仅卖面条，还提供饮料卖。
提供饮料卖，饮料是产品，先抽象一个产品类，饮料：

public abstract class IDrinks {/*** 描述每种饮料多少钱*/public abstract void prices();
}

然后实现两个具体产品类:
可乐：

public class ColaDrinks extends IDrinks {@Overridepublic void prices() {System.out.println("可乐三块五");}
}

屌丝还是多喝水吧：

public class WaterDrinks extends IDrinks {@Overridepublic void prices() {System.out.println("和我一样的穷鬼都喝水，不要钱~！");}
}

抽象饭店，无外乎吃喝（抽象工厂类）：

public abstract class AbstractFoodFactory {/*** 生产面条** @return*/public abstract INoodles createNoodles();/*** 生产饮料*/public abstract IDrinks createDrinks();
}

兰州大酒店（具体工厂类）：

public class LzlmFoodFactory extends AbstractFoodFactory {@Overridepublic INoodles createNoodles() {return new LzNoodles();//卖兰州拉面}@Overridepublic IDrinks createDrinks() {return new WaterDrinks();//卖水}
}

KFC（具体工厂类）：

public class KFCFoodFactory extends AbstractFoodFactory {@Overridepublic INoodles createNoodles() {return new PaoNoodles();//KFC居然卖泡面}@Overridepublic IDrinks createDrinks() {return new ColaDrinks();//卖可乐}
}

使用：

        /*** 抽象工厂方法：*/System.out.println("==============================抽象方法==============================" +"\n 老实说，以我这一年的水平我体会不到抽象工厂有何巨大优势，所以在我这里我没有想到很好的使用场景。希望以后在慢慢体会吧。");AbstractFoodFactory abstractFoodFactory1 = new KFCFoodFactory();abstractFoodFactory1.createDrinks().prices();abstractFoodFactory1.createNoodles().desc();abstractFoodFactory1= new LzlmFoodFactory();abstractFoodFactory1.createDrinks().prices();abstractFoodFactory1.createNoodles().desc();

输出：

==============================抽象方法==============================
 老实说，以我这一年的水平我体会不到抽象工厂有何巨大优势，所以在我这里我没有想到很好的使用场景。希望以后在慢慢体会吧。
可乐三块五
泡面好吃 可不要贪杯
和我一样的穷鬼都喝水，不要钱~！
兰州拉面 上海的好贵 家里才5 6块钱一碗

小结：

将工厂也抽象了，在使用时，工厂和产品都是面向接口编程，OO（面向对象）的不得了。

缺点

但是将工厂也抽象后，有个显著问题，就是类爆炸了。而且每次拓展新产品种类，例如不仅卖吃卖喝，我还想卖睡，提供床位服务，这需要修改抽象工厂类，因此所有的具体工厂子类，都被牵连，需要同步被修改。

老实说，以我这一年的水平我体会不到抽象工厂有何巨大优势，所以在我这里我没有想到很好的使用场景。希望以后在慢慢体会吧。如有您知道，希望不吝赐教。

七个人总结和使用场景

一句话总结工厂模式：方便创建同种产品类型的复杂参数对象

工厂模式重点就是适用于构建同产品类型（同一个接口基类）的不同对象时，这些对象new很复杂，需要很多的参数，而这些参数中大部分都是固定的，so，懒惰的程序员便用工厂模式封装之。
（如果构建某个对象很复杂，需要很多参数，但这些参数大部分都是“不固定”的，应该使用Builder模式）

为了适应程序的扩展性，拥抱变化，便衍生出了普通工厂、抽象工厂等模式。

代码传送门：
github：
https://github.com/mcxtzhang/Demos/tree/master/libfactorypattern

学习参考：

http://blog.csdn.net/zhangerqing/article/details/8194653
http://blog.csdn.net/column/details/code-design.html
Android源码设计模式书籍
Java设计模式深入研究书籍
一些搜工厂模式出来的文章….

设计模式(一) 工厂模式五种写法总结相关推荐

工厂模式五种写法总结
一概述: 属于创建型设计模式,需要生成的对象叫做产品 ,生成对象的地方叫做工厂 . 使用场景: 在任何需要生成复杂对象的地方,都可以使用工厂方法模式. 直接用new可以完成的不需要用工厂模式个人理解 ...
JAVA设计模式之工厂模式（三种工厂模式）
1.工厂模式可以分为三类: 简单工厂模式(Simple Factory) 工厂方法模式(Factory Method) 抽象工厂模式(Abstract Factory) 简单工厂其实不是一个标准的的设 ...
Java 设计模式之工厂模式（二）
原文地址:Java 设计模式之工厂模式(二) 博客地址:http://www.extlight.com 一.背景本篇内容是 Java 设计模式创建型模式的第二篇.上一篇主题为 <Java 设计 ...
系统架构技能之设计模式-抽象工厂模式
一.上篇回顾上篇我们主要讲述了简单工厂模式和工厂模式.并且分析了每种模式的应用场景和一些优缺点,我们现在来回顾一下: 简单工厂模式:一个工厂负责所有类型对象的创建,不支持无缝的新增新的类型对象的创建 ...
java 设计模式路由器_java设计模式2————工厂模式
java设计模式2----工厂模式 1.工厂模式介绍: 1.1.实现了创建者与调用者的分离 1.2.详细分类: 简单工厂模式工厂方法模式抽象工厂模式 1.3.所遵循的OOP原则: 开闭原则:对扩展 ...
Java设计模式之工厂模式（简单工厂模式）
前一阵子学习了Java 中据说是最简单的设计模式的单例模式,想一起讨论学习的小伙伴请点击这里: Java 设计模式之单例模式那么今天就把学习的工厂模式记录下来工厂模式: 实现了创建者和调用者的分 ...
Java设计模式（工厂模式＞抽象工厂模式和原型模式）
Java设计模式Ⅱ 1.工厂模式 1.1 简单工厂模式 1.2 工厂方法模式 2.抽象工厂模式 3.总结 4.原型模式 4.1 原型模式 4.2 浅拷贝 4.3 深拷贝 5.建造者模式 1.工厂模式 ...
策略模式和工厂模式的区别_设计模式之工厂模式-工厂方法模式
设计模式之工厂模式-工厂方法模式大家好,欢迎来到污污弹公司,今天司小司又接到了一个新活-披萨项目. 来源:凯哥Java(kaigejava) 需求: 披萨项目: 要方便披萨品种的扩展.要便于维护.要 ...
回字有四种写法，那你知道单例有五种写法吗
点击上方好好学java ,选择星标公众号重磅资讯.干货,第一时间送达今日推荐:2020年7月程序员工资统计,平均14357元,又跌了,扎心个人原创100W+访问量博客:点击前往,查看更多转自 ...

设计模式(一) 工厂模式五种写法总结

系列开篇瞎BB

一概述：

使用场景：

二简单（静态）工厂：

特点

缺点

三另一种简单工厂（反射）：

特点

缺点

四多方法工厂（常用）

源码撑腰环节

五普通工厂

普通工厂与简单工厂模式的区别：

缺点：

六抽象工厂：

小结：

缺点

七个人总结和使用场景

学习参考：

设计模式(一) 工厂模式五种写法总结相关推荐

最新文章

热门文章

设计模式(一) 工厂模式 五种写法总结

系列开篇瞎BB

一概述：

使用场景：

二 简单（静态）工厂：

特点

缺点

三 另一种简单工厂（反射）：

特点

缺点

四 多方法工厂（常用）

源码撑腰环节

五 普通工厂

普通工厂与简单工厂模式的区别：

缺点：

六 抽象工厂：

小结：

缺点

七 个人总结和使用场景

学习参考：

设计模式(一) 工厂模式 五种写法总结相关推荐

最新文章

热门文章

设计模式(一) 工厂模式五种写法总结

二简单（静态）工厂：

三另一种简单工厂（反射）：

四多方法工厂（常用）

五普通工厂

六抽象工厂：

七个人总结和使用场景

设计模式(一) 工厂模式五种写法总结相关推荐