Java设计模式之工厂方法模式（Factory Pattern）
介绍
工厂模式属于创建类设计模式中非常基础的一种，对于它的定义是这样的：
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
这么说的可能太官方，通俗地讲，工厂模式就是将创建对象的事情交给一个工厂类，客户端想要创建对象的时候，只需要调用工厂类中的方法就能实例化一个类，而不用使用 A a = new A() 的方式创建。
工厂模式一般是用来创建复杂对象采用的一种方式，因为简单对象就可以直接使用 new 的方式创建。当然，是否使用还是要视具体情况而定。
下面来介绍工厂模式及其扩展的两种模式。
工厂模式
工厂模式要实现的话，需要三步：
- 首先定义我们要创建的产品，它们共同实现一个接口。
- 然后，需要一个工厂类，这是最主要的，因为它负责对象的创建。
- 最后利用客户端调用即可。
我们来举一个例子，如果有一个工厂要生产衣服，然后利用工厂来生产各种不同的衣服（衬衫，外衣和裤子）。这样我们就可以通过工厂进行衣服的生产了。
首先我们需要创建衣服接口：
public interface Clothes {
public void introduce();
}然后定义三种衣服的实现类
衬衫：
public class Shirt implements Clothes {
@Override
public void introduce() {
System.out.println("我是衬衫!!! ");
}
}外衣：
public class Outerwear implements Clothes {
@Override
public void introduce() {
System.out.println("我是外衣!!! ");
}
}裤子：
public class Pants implements Clothes {
@Override
public void introduce() {
System.out.println("我是裤子!!! ");
}
}好了，产品已经定义好了，接下来就是如何进行创建了，这里我们不直接使用 new 的方式，而是通过工厂间接进行创建。
抽象工厂类：
public abstract class Producer {
public abstract T produceClothes(Class c);
} 具体工厂类：
public class ConcreteProducer extends Producer {
@Override
public T produceClothes(Class c) {
Clothes clothes = null;
try {
clothes = (Clothes) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
System.out.println("生产衣服失败!!! ");
}
return (T)clothes;
}
} 产品有了，工厂也有了，客户端就可以这样调用：
Producer producer = new ConcreteProducer();
//生产衬衫。
Clothes shirts = producer.produceClothes(Shirt.class);
shirts.introduce();
//生产外衣。
Clothes outerwear = producer.produceClothes(Outerwear.class);
outerwear.introduce();
//生产裤子。
Clothes pants = producer.produceClothes(Pants.class);
pants.introduce();可以查看输出：
我是衬衫!!!
我是外衣!!!
我是裤子!!!
这样，我们就将创建对象的过程移到客户端代码外了。客户端只需要输入要创建对象的信息即可（信息可以是String、Enum、Class 等，这里使用了 Class ）。
静态工厂模式（简单工厂模式）
静态工厂是工厂模式的一种简化版本，它直接工厂类进行改造，去掉了抽象工厂类，将工厂中的创建函数设为全局模式（ static ）。
还是上面的代码，产品不变，工厂类变为一个，函数设为全局：
public class ConcreteProducer {
public static T produceClothes(Class c) {
Clothes clothes = null;
try {
clothes = (Clothes) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
System.out.println("生产衣服失败!!! ");
}
return (T)clothes;
}
} 然后客户端就可以直接利用 ConcreteProducer 进行创建，而不用再去 new 一个工厂类了：
Clothes shirts = ConcreteProducer.produceClothes(Shirt.class);
shirts.introduce();
//生产外衣。
Clothes outerwear = ConcreteProducer.produceClothes(Outerwear.class);
outerwear.introduce();
//生产裤子。
Clothes pants = ConcreteProducer.produceClothes(Pants.class);
pants.introduce();输出结果为：
我是衬衫!!!
我是外衣!!!
我是裤子!!!
这就是静态工厂模式——简化版的工厂模式。
多工厂模式
多工厂模式要求我们，有多少实现类就创建多少工厂，客户端调用的时候，就可以直接使用具体的实现类的工厂创建了，而不是传入类型参数。
还是上面的三种衣服，在这种模式中，我们就需要创建三种具体工厂：
抽象工厂接口：
public abstract class Producer2 {
public abstract Clothes produceClothes();
}衬衫：
public class ShirtProducer extends Producer2 {
@Override
public Clothes produceClothes() {
return new Shirt();
}
}外衣：
public class OuterwearProducer extends Producer2 {
@Override
public Clothes produceClothes() {
return new Outerwear();
}
}裤子：
public class OuterwearProducer extends Producer2 {
@Override
public Clothes produceClothes() {
return new Outerwear();
}
}这样，客户端就可以使用具体的工厂方法创建对象了：
Clothes shirts = (new ShirtProducer()).produceClothes();
shirts.introduce();
//生产外衣。
Clothes outerwear = (new OuterwearProducer()).produceClothes();
outerwear.introduce();
//生产裤子。
Clothes pants = (new PantsProducer()).produceClothes();
pants.introduce();我是衬衫!!!
我是外衣!!!
我是裤子!!!
这样我们就可以直接使用具体的工厂来进行创建了，由于不只有一个工厂，有多少实现类就有多少具体工厂，因此成为多工厂模式。然而该模式最大的缺陷之处也正是在这，太多的工厂类会造成项目特别臃肿，降低可维护性。
总结
工厂模式是一种简单的创建类设计模式，易于理解，而且对于创建复杂对象十分有效，因此在很多项目中都能看到它的身影。