版权声明：尊重博主原创文章，转载请注明出处哦~http://blog.csdn.net/eson_15/article/details/51223124
工厂模式使用的频率非常高，我们在开发中总能见到它们的身影。其定义为：define an interface for creating an object, but let subclasses decide which class to instantiate. factory method lets a class defer instantiation to subclasses.即定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。工厂方法模式的通用类图如下所示：
如图所示，product抽象类负责定义产品的共性，实现对事物最抽象的定义，creator为抽象工厂类，具体如何创建产品类由具体的实现工厂concretecreator来完成。我们来看一下通用的模板代码：
public abstract class product {
public void method() { //产品类的公共方法，已经实现
//实现了公共的逻辑
}
public abstract void method2(); //非公共方法，需要子类具体实现
}
具体产品类可以有多个，都继承与抽象类product，如下：
public class concreateproduct1 extends product {
@override
public void method2() {
//product1的业务逻辑
public class concreateproduct2 extends product {
//product2的业务逻辑
抽象工厂类负责定义产品对象的产生，代码如下：
public abstract class creator {
//创建一个产品对象，其输入参数类型可以自行设置
public abstract <t extends product> t createproduct(class<t> clazz);
这里用的是泛型，传入的对象必须是product抽象类的实现类。具体如何产生一个产品的对象，是由具体工厂类实现的，具体工厂类继承这个抽象工厂类：
public class concretecreator extends creator {
public <t extends product> t createproduct(class<t> clazz) {
product product = null;
try {
product = (product) class.forname(clazz.getname()).newinstance();
} catch (exception e) { //异常处理
e.printstacktrace();
}
return (t) product;
通过这样的设计，我们就可以在测试类中随意生产产品了，看下面的测试类：
public class factorytest {
public static void main(string[] args) {
creator factory = new concretecreator();
product product1 = factory.createproduct(concreteproduct1.class); //通过不同的类创建不同的产品
product product2 = factory.createproduct(concreteproduct2.class);
/*
* 下面继续其他业务处理
*/
}
下面举个女娲造人的例子阐述一下工厂模式的实际应用。
现在女娲要造人，她要造三种人：白种人、黄种人和黑种人。怎么造呢？她得有个能产生人类的工厂吧（类似于八卦炉的东西），这个工厂得让她生产出不同的人种。每个人都有两个属性：皮肤颜色和说话。那现在我们开始设计女蜗造人的程序，首先我们看一下造人的类图：
抽象接口human是人类，里面有两个方法，getcolor获得皮肤颜色，talk交谈。下面三个具体human的实现类，分别实现三个人种。根据工厂模式，应该有个抽象工厂，abstracthumanfactory就担当了这个责任，里面有个抽象方法createhuman，那humanfactory就是实现类了，实现抽象工厂里的方法。下面我们看看具体实现：
public interface human {
public void getcolor();//人有不同的颜色
public void talk(); //人会说话
接下来对human接口的不同实现：
public class blackhuman implements human {// 黑种人
public void getcolor() {
system.out.println("black");
public void talk() {
system.out.println("black man");
public class human implements human { //黄种人
system.out.println("yellow");
system.out.println("yellow man");
public class whitehuman implements human {//白种人
system.out.println("white");
system.out.println("white man");
好了，人的模子搞好了，现在女娲要开始搭建八卦炉了，于是女娲开始画八卦炉模型了：
public abstract class abstracthumanfactory{
public abstract <t extends human> t createhuman(class<t> clazz); //注意这里t必须是human的实现类才行，因为要造human嘛
然后女娲开始具体实现这个八卦炉了……
public class humanfactory extends abstracthumanfactory {
public <t extends human> t createhuman(class<t> clazz) {
human human = null;
human = (product) class.forname(clazz.getname()).newinstance();
system.out.println("人种产生错误");
return (t) human;
好，现在人种也有了，八卦炉也有了，剩下的就是采集黄土，然后命令八卦炉开始生产了：
abstracthumanfactory bagualu = new hunmanfactory();
human blackman = bagualu.createhuman(blackhuman.class); //黑人诞生了
human yellowman = bagualu.createhuman(yellohuman.class); //黄人诞生了
human whiteman = bagualu.createhuman(whitehuman.class); //白人诞生了
}
女娲就是这么把人造出来的……这就是工厂模式！
我们还用上面女娲造人的例子说明，现在女娲在思考一个问题：我现在只需要一个工厂就可以把人生产出来，我干嘛要具体的工厂对象呢？我只要使用静态方法就好了。这样一想，于是女娲就开始把abstracthumanfactory抽象类去掉了，只保留了humanfactory类，同时把createhuman方法设置成了static类型，搞定！
public class humanfactory {
public static <t extends human> t createhuman(class<t> clazz) {
然后女娲造人的时候就不用new什么八卦炉了，直接用humanfactory类调用就行了：
human blackman = humanfactory.createhuman(blackhuman.class);
这就是静态工厂模式，在实际项目中，根据需求可以设置成静态工厂类，但是缺点是扩展比较困难，如果就一个工厂，不需要扩展，可以这么设计，仍然是很常用的。
我们还以女娲造人为例，后来女娲想了想，，这人不可能就说话吧，还得有不同的属性杀的，如果在一个八卦炉里造，除了new一个人外，还得对不同的人设置不同的属性，这样的话，八卦炉有点吃不消阿……又有点乱啊……但是她想到了一个法子，每个人种弄个八卦炉，不同的八卦炉专门生产不同的人种，这样就结构清晰了，她在造人的时候自己选择与哪个八卦炉相关联就行了。示意图如下：
这样的话abstracthumanfactory抽象类我们就要改写了：
public abstract class abstracthumanfactory {
public abstract human createhuman();
注意抽象方法中已经不需要再传递相关类的参数了，因为每个具体的工厂都已经非常明确自己的职责：创建自己负责的产品类对象。所以不同的工厂实现自己的createhuman方法即可：
public class blackhumanfactory extends abstracthumanfactory {
public human createhuman() {
return new blackhuman();
public class yellowhumanfactory extends abstracthumanfactory {
return new yellowhuman();
public class whitehumanfactory extends abstracthumanfactory {
return new whitehuman();
这样三个不同的工厂就产生了，每个工厂对应只生产自己对应的人种。所以现在女娲造人就可以不用一个八卦炉了，分工协作，各不影响了！
human blackman = new blackhumanfactory().createhuman(); //黑人诞生了
human yellowman = new yellowhumanfactory().createhuman(); //黄人诞生了
human whiteman = new whitehumanfactory().createhuman(); //白人诞生了
这种工厂模式的好处是职责清晰，结构简单，但是给扩扩展性和可维护性带来了一定的影响，因为如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量是相同的，维护时也需要考虑两个对象之间的关系。但是这种模式还是很常用的。
上一章介绍了单例模式，并且指出了单例和多例的一些缺点，但是我们是不是可以采用工厂模式来实现一个单例模式的功能呢？答案是肯定的，单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象。见下面：
singleton类定义了一个private的无参构造方法，目的是不允许通过new的方式创建对象，另外，singleton类也不自己定义一个singleton对象了，因为它要通过工厂来获得。
public class singleton {
private singleton() {
public void dosomething() {
//业务处理
既然singleton不能通过正常的渠道建立一个对象，那singletonfactory如何建立一个单例对象呢？答案是通过反射方式创建：
public class singletonfactory {
private static singleton instance;
static {
try {
class clazz = class.forname(singleton.class.getname());
//获取无参构造方法
constructor constructor = clazz.getdeclaredconstructor();
//设置无参构造方法可访问
constructor.setaccessible(true);
//产生一个实例对象
instance = (singleton) constructor.newinstance();
} catch (exception e) {
//异常处理
public static singleton getinstance() {
return instance;
以上通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。
何为延迟初始化（lazy initialization）？即一个对象被使用完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。延迟初始化是工厂模式的一个扩展应用，其通用类表示如下：
productfactory负责产品类对象的创建工作，并且通过prmap变量产生一个缓存，对需要再次被重用的对象保留：
public class productfactory {
private static final map<string, product> prmap = new hashmap();
public static synchronized product createproduct(string type) throws exception {
//如果map中已经有这个对象
if(prmap.containskey(type)) {
product = prmap.get(type);
} else {
if(type.equals("product1")) {
product = new concreteproduct1();
}
else {
product = new concreteproduct2();
prmap.put(type, product);
return product;
代码比较简单，通过定义一个map容器，容纳所有产生的对象，每次在new一个对象的时候先判断map中有没有，有就不用再new了，直接取。另外，每次new过一个对象后，也将其放入map中方便下次调用。
优点：
1. 工厂模式具有良好的封装性，代码结构清晰，也有利于扩展。在增加产品类的情况下，只需要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。
2. 工厂模式可以屏蔽产品类。这一点非常重要，产品类的实现如何变化，调用者都不用关系，只需要关心产品的接口，只要接口保持不变，系统的上层模块就不需要发生变化。
3. 工厂模式是典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不用关心。
工厂模式就介绍这么多吧，如果错误之处，欢迎留言指正~
_____________________________________________________________________________________________________________________________________________________
-----乐于分享，共同进步！