工厂方法模式（Factory Method）：定义一个用于创建对象的接口IFactory，在具体的ConcreteFactory子类中根据传进的参数即具体子类ConcreteProduct决定实例化哪一个IProduct产品，该模式使得一个类（即IProduct）的实例化延迟到其子类（即ConcreteProduct）。
通用类图如下：
代码实现如下：
// 产品接口，定义一系列产品应该实现的服务，即产品的共性
interface IProduct {
public void method01();
public void method02();
}
// 具体的产品实现类
class ConcreteProductA implements IProduct {
public void method01() {
System.out.println( "ConcreteProductA method01() ...");
}
public void method02() {
System.out.println( "ConcreteProductA method02() ...");
}
}
class ConcreteProductB implements IProduct {
public void method01() {
System.out.println( "ConcreteProductB method01() ...");
}
public void method02() {
System.out.println( "ConcreteProductB method02() ...");
}
}
// 抽象的工厂类，定义了其子类必须实现的createProduct()方法
abstract class Factory {
//运用了Java 中的泛型和反射技术
public abstract <T extends IProduct> T createProduct(Class<T> c);
}
class ConcreteFactory extends Factory {
public <T extends IProduct> T createProduct(Class<T> c) {
T product = null;
try {
product = (T) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return product;
}
}
public class Client {
public static void main(String[] args) {
//创建一个具体工厂
Factory factory = new ConcreteFactory();
//根据参数中具体产品的.class名称来决定创建的产品类型
IProduct product01 = factory.createProduct(ConcreteProductA. class);
IProduct product02 = factory.createProduct(ConcreteProductB. class);
product01.method01();
product01.method02();
product02.method01();
product02.method02();
}
}
interface IProduct {
public void method01();
public void method02();
}
// 具体的产品实现类
class ConcreteProductA implements IProduct {
public void method01() {
System.out.println( "ConcreteProductA method01() ...");
}
public void method02() {
System.out.println( "ConcreteProductA method02() ...");
}
}
class ConcreteProductB implements IProduct {
public void method01() {
System.out.println( "ConcreteProductB method01() ...");
}
public void method02() {
System.out.println( "ConcreteProductB method02() ...");
}
}
// 抽象的工厂类，定义了其子类必须实现的createProduct()方法
abstract class Factory {
//运用了Java 中的泛型和反射技术
public abstract <T extends IProduct> T createProduct(Class<T> c);
}
class ConcreteFactory extends Factory {
public <T extends IProduct> T createProduct(Class<T> c) {
T product = null;
try {
product = (T) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return product;
}
}
public class Client {
public static void main(String[] args) {
//创建一个具体工厂
Factory factory = new ConcreteFactory();
//根据参数中具体产品的.class名称来决定创建的产品类型
IProduct product01 = factory.createProduct(ConcreteProductA. class);
IProduct product02 = factory.createProduct(ConcreteProductB. class);
product01.method01();
product01.method02();
product02.method01();
product02.method02();
}
}
实际上，具体的产品子类（即ConcreteProduct）可以有多个，以上只用了两个；而且具体的工厂（即ConcreteFactory）也可以有多个，不同的工厂可以提供不同的创建产品的实现方式，即使用不同的方式来覆盖实现父类中的抽象createProduct()方法。
我们可以将工厂方法模式中的产品理解为对外的服务，而IProduct接口仅仅只是制定一个标准，即每个产品（服务）必须对外提供的接口（这个“接口”是概念上的，不是上面那种编程语言级别的关键字interface“接口”）。
我们可以对上面这个工厂方法模式进行扩展。
1、例如，当我们并不需要创建一个工厂的时候（毕竟有时候我们可能只需要不多的几个产品而已），可以省略掉抽象的Factory类，直接设计一个具体的Factory类，由其提供一个静态方法来根据传进的参数进行适当的实例化操作，此时就变成了简单工厂模式了。
2、再者，我们可以根据需要设计不同的具体工厂类（即不同的ConcreteFactory类），此时让不同的具体工厂类ConcreteFactory与不同的产品类ConcreteProductl类一一对应，用不同的工厂来生产不同的产品（或者说不同的提供商来实现对外的不同服务）。修改一下类图即可，具体类图如下：
3、最后，可以使用工厂方法来实现对象实例化的延迟，这样做的好处是不必在某个产品还未被需要之前就创建出来，可以等到真正需要时再实例化并将其装进一个容器中，以备以后的访问需要，具体类图也只是将上面类图中的抽象Factory类与IProduct接口的依赖关系改成聚合关系即可，具体的代码实现也比较简单，这里不再给出。
本文转自 xxxx66yyyy 51CTO博客，原文链接：http://blog.51cto.com/haolloyin/332576，如需转载请自行联系原作者
