java 设计模式之 -- 工厂模式
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。
我们以类Sample为例， 如果我们要创建Sample的实例对象:
Sample sample=new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。
首先，我们想到的是，可以使用Sample的 构造函数，这样生成实例就写成:
Sample sample=new Sample(参数);
但是，如果创建sample实例时所做的初始化工作不是像赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。
为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有悖于Java 面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间耦合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。
在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。
这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照 面向接口编程,我们需要将Sample抽象成一个接口.ISample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
ISample mysample=new MySample();
ISample hissample=new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
你会建立一个专门生产Sample实例的工厂:
|
1
2
3
4
5
6
7
8
|
public
class
Factory{
public
static
ISample creator(
int
which){
if
(which==
1
)
return
new
SampleA();
else
if
(which==
2
)
return
new
SampleB();
}
}
|
那么在你的程序中,如果要创建ISample的实列时候可以使用
iSample sampleA=Factory.creator(1);
这样,在整个就不涉及到ISample的具体的实现类, 达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易犯错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,犯错误可能性就越少.好象我们从编程序中也能悟出人生道理。
使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample类的接口,产品接口下有ISample接口的实现类,如SampleA,其次要有一个Factory类，用来生成产品ISample接口的具体实例。
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).
这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
这里假设：Sample有两个实体类SampleA和SampleB，而Sample2也有两个实体类Sample2A和Sample2B
那么，我们就将上例中Factory变成 抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public
abstract
class
Factory{
public
abstract
Sample creator();
public
abstract
Sample2 creator(String name);
}
public
class
SimpleFactory
extends
Factory{
public
Sample creator(){
.........
return
new
SampleA
}
public
Sample2 creator(String name){
.........
return
new
Sample2A
}
}
public
class
BombFactory
extends
Factory{
public
Sample creator(){
......
return
new
SampleB
}
public
Sample2 creator(String name){
......
return
new
Sample2B
}
}
|
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2?
抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。
简单（静态）工厂：
一个例子：
我喜欢吃面条，抽象一个面条基类，(接口也可以)，这是产品的抽象类。
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
先来一份兰州拉面（具体的产品类）：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
程序员加班必备也要吃泡面（具体的产品类）：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
还有我最爱吃的家乡的干扣面（具体的产品类）：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
准备工作做完了，我们来到一家“简单面馆”（简单工厂类），菜单如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
简单面馆就提供三种面条（产品），你说你要啥，他就给你啥。这里我点了一份干扣面:
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
输出：
特点
1 它是一个具体的类，非接口 抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。
2 create()方法通常是静态的，所以也称之为静态工厂。
缺点
1 扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）
2 不同的产品需要不同额外参数的时候 不支持。
Class.forName(clz.getName()).newInstance()实现的简单工厂：
点菜时：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
输出：
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
特点
1 它也是一个具体的类，非接口 抽象类。但它的create()方法，是利用反射机制生成对象返回，好处是增加一种产品时，不需要修改create()的代码。
缺点
这种写法粗看牛逼，细想之下，reflection的效率还有以下问题：
1 个人觉得不好，因为Class.forName(clz.getName()).newInstance()调用的是无参构造函数生成对象，它和new Object()是一样的性质，而工厂方法应该用于复杂对象的初始化 ，当需要调用有参的构造函数时便无能为力了，这样像为了工厂而工厂。
2 不同的产品需要不同额外参数的时候 不支持。
多方法工厂（常用）
使用方法二 三实现的工厂，都有一个缺点：不同的产品需要不同额外参数的时候 不支持。
而且如果使用时传递的type、Class出错，将不能得到正确的对象，容错率不高。
而多方法的工厂模式为不同产品，提供不同的生产方法，使用时 需要哪种产品就调用该种产品的方法，使用方便、容错率高。
工厂如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
使用时：
源码撑腰环节
查看Java源码：java.util.concurrent.Executors类便是一个生成Executor 的工厂 ，其采用的便是 多方法静态工厂模式：
例如ThreadPoolExecutor类构造方法有5个参数，其中三个参数写法固定，前两个参数可配置，如下写。
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
又如JDK想增加创建ForkJoinPool类的方法了，只想配置parallelism参数，便在类里增加一个如下的方法：
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
这个例子可以感受到工厂方法的魅力了吧：方便创建 同种类型的 复杂参数 对象。
Android应用
我们知道Android中的fragment，listview，线程池会频繁调用，所以可以用工厂模式加以实现
public class FragmentFactory {
public static final int FRAGMENT_HOME = 0;
public static final int FRAGMENT_APP = 1;
public static final int FRAGMENT_GAME = 2;
public static final int FRAGMENT_SUBJECT = 3;
public static final int FRAGMENT_RECOMMEND = 4;
public static final int FRAGMENT_CATEGORY = 5;
public static final int FRAGMENT_HOT = 6;
//我们只要一个方法，就是得到我们需要的fragment
static SparseArrayCompat sparseArrayCompat = new SparseArrayCompat();
public static BaseFragment getFragment(int position) {
BaseFragment fragment = null;
//为了优化性能，我们还可以创建一个缓存，类似于luCache,这个叫做sparsearray稀疏数组
fragment= sparseArrayCompat.get(position);
if(fragment!=null){
return fragment;
}
switch (position) {
case FRAGMENT_HOME:// 主页
fragment = new HomeFragment();
break;
case FRAGMENT_APP:// 应用
fragment = new AppFragment();
break;
case FRAGMENT_GAME:// 游戏
fragment = new GameFragment();
break;
case FRAGMENT_SUBJECT:// 专题
fragment = new SubjectFragment();
break;
case FRAGMENT_RECOMMEND:// 推荐
fragment = new RecommendFragment();
break;
case FRAGMENT_CATEGORY:// 分类
fragment = new CategoryFragment();
break;
case FRAGMENT_HOT:// 排行
fragment = new HotFragment();
break;
default:
break;
}
sparseArrayCompat.put(position, fragment);
return fragment;
}
} public class ListViewFactory {
public static ListView createListView() {
ListView mlistView = new ListView(UIUtils.getContext());
// 简单的设置
mlistView.setCacheColorHint(Color.TRANSPARENT);
mlistView.setFastScrollEnabled(true);
mlistView.setSelector(new ColorDrawable(Color.TRANSPARENT));
return mlistView;
}
}
public class ThreadPoolFactory {
static ThreadPoolProxy normalProxy;
static ThreadPoolProxy downloadProxy;
public static ThreadPoolProxy getNormalProxy() {
if(normalProxy==null){
synchronized (ThreadPoolProxy.class) {
if(normalProxy==null){
normalProxy = new ThreadPoolProxy(5, 5, 3000);
}
}
}
return normalProxy;
}
public static ThreadPoolProxy getdownloadProxy() {
if(downloadProxy==null){
synchronized (ThreadPoolProxy.class) {
if(downloadProxy==null){
downloadProxy = new ThreadPoolProxy(3, 3, 3000);
}
}
}
return downloadProxy;
}
}
学习参考：
http://blog.csdn.net/zxt0601/article/details/52798423 百度百科感谢各位前辈文章的借鉴，我只是在前人的基础上融合了一下，我们看的更远是因为站在巨人的肩膀上