工厂方法模式（Factory Method Pattern），是简单工厂模式的扩展，其英文原话是"Define an interface for creating an object,but let the subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses"，翻译是：定义一个创建对象的借口，但是让子类来觉得该实例化那个类。工厂方法让一个类推迟实例化至它的子类中。工厂方法模式有四个角色：
抽象工厂（Creator）角色：这是工厂方法模式的核心，定义了创建产品的方法。与应用系统无关。具体工厂角色必须实现这个接口才能创建对象。
具体工厂（Concrete Creator）角色：实现了抽象工厂角色的接口，含有与应用密切相关的逻辑，并且接受应用程序的调用以创建产品对象。
抽象产品（Product）角色：定义了产品的共性，实现对产品最抽象的定义。
具体产品（Concrete Product）角色：实现抽象产品角色的接口。工厂方法所创建的对象就是该角色的实例。
工厂方法模其类图如下：
抽象工厂的代码模式：
public interface Creator{
//这就是工厂方法，提供具体产品的类对象即可创建产品；
public <T extends Product> T factory(Class<T> c);
}
抽象产品的代码模式：
public interface Product{
//产品的公共方法
public void method1();
public void method2();
}
具体工厂的代码模式：
public class ConcreteCreator implements Creator{
//具体工厂生产的具体产品
Product product = null;
@Override
public <T extends Product> T factory(Class<T> c) {
// TODO Auto-generated method stub
//生产出产品
product = (Product) Class.forName(c.getName()).newInstance();
//或这样
//product = c.newInstance();
return (T)product;
}
}
具体产品的代码模式：
public class ConcreteProduct implements Product{
@Override
public void method1() {
//do somthing
}
@Override
public void method2() {
//do something
}
}
下面通过一个demo，来展示下工厂方法模式的应用；该例子是工厂生产水果的例子，首先需要一个抽象工厂Factory和抽象水果Fruit，Factory定义了生产水果的方法，Fruit定义了水果的共性；然后再由具体的工厂生产具体的水果，如AppleFactory（implements Factory）生产Apple（implements Fruit）；GrapeFactory（implements Factory）生产Grape（implements Fruit），下面上代码。
Factory类：
//抽象工厂，定义了生产产品的接口；
public interface Factory {
/**
* @param c 具体产品的Class对象；
* @return 返回产品的父类，具体工厂调用得到产品时需要转型；
*/
public Fruit factory(Class c);
}
Fruit类：
//抽象产品，定义了产品的共性；
public interface Fruit {
public void plant();
public void grow();
public void harvest();
}
AppleFactory类：
//具体工厂，生产具体的产品，AppleFactory生产Apple
public class AppleFactory implements Factory {
@Override
public Apple factory(Class c) {
// TODO Auto-generated method stub
try {
//生产苹果
Apple apple = (Apple)Class.forName(c.getName()).newInstance();
//或这样 Apple apple = (Apple) c.newInstance();
apple.setTreeAge(0);
return apple;
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
GrapeFactory类：
public class GrapeFactory implements Factory {
@Override
public Grape factory(Class c) {
// TODO Auto-generated method stub
try {
Grape grape = (Grape)Class.forName(c.getName()).newInstance();
//或这样 Grape grape = (Grape) c.newInstance();
grape.setSeedless(true);
grape.setTreeAge(0);
return grape;
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
Apple类：
//具体产品
public class Apple implements Fruit {
private int treeAge;
@Override
public void plant() {
// TODO Auto-generated method stub
System.out.println("Apple Tree is planted");
}
@Override
public void grow() {
// TODO Auto-generated method stub
System.out.println("Apple Tree is growing");
}
@Override
public void harvest() {
// TODO Auto-generated method stub
System.out.println("Apple Tree is harvesting");
}
/**
* @return the treeAge
*/
public int getTreeAge() {
return treeAge;
}
/**
* @param treeAge the treeAge to set
*/
public void setTreeAge(int treeAge) {
this.treeAge = treeAge;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Apple [treeAge=" + treeAge + "]";
}
}
Grape类：
//具体产品
public class Grape implements Fruit {
boolean seedless;
private int treeAge;
@Override
public void plant() {
// TODO Auto-generated method stub
System.out.println("Grape is palnted");
}
@Override
public void grow() {
// TODO Auto-generated method stub
System.out.println("Grape is growing");
}
@Override
public void harvest() {
// TODO Auto-generated method stub
System.out.println("Grape is harvesting");
}
/**
* @return the seedless
*/
public boolean isSeedless() {
return seedless;
}
/**
* @return the treeAge
*/
public int getTreeAge() {
return treeAge;
}
/**
* @param seedless the seedless to set
*/
public void setSeedless(boolean seedless) {
this.seedless = seedless;
}
/**
* @param treeAge the treeAge to set
*/
public void setTreeAge(int treeAge) {
this.treeAge = treeAge;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Grape [seedless=" + seedless + ", treeAge=" + treeAge + "]";
}
}
主方法入口类FactoryMethodTest：
public class FactoryMethodTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//生产产品的工厂，以父类引用标示；或者也可以分别定义GrapeFactory和AppleFactory，这样fac.factory()这句就不用转型了；
Factory fac ;
//具体产品
Apple apple;
Grape grape;
fac = new AppleFactory();
//Apple的Class对象传给factory方法；
apple = (Apple) fac.factory(Apple.class);
System.out.println(apple);
apple.plant();
apple.grow();
apple.harvest();
fac = new GrapeFactory();
grape = (Grape)fac.factory(Grape.class);
System.out.println(grape);
grape.plant();
grape.grow();
grape.harvest();
}
}
运行结果：
Apple [treeAge=0]
Apple Tree is planted
Apple Tree is growing
Apple Tree is harvesting
Grape [seedless=true, treeAge=0]
Grape is palnted
Grape is growing
Grape is harvesting
总结：
工厂方法模式就是由具体的工厂生产具体的产品，当增加新产品时，只需增加一个新工厂即可。