1.工厂方法模式的定义
工厂方法模式使用的频率非常高， 在我们日常的开发中总能见到它的身影。 其定义为：
Define an interface for creating an object,but let subclasses decide which class to
instantiate.Factory Method lets a class defer instantiation to subclasses.（ 定义一个用于创建对象的
接口， 让子类决定实例化哪一个类。 工厂方法使一个类的实例化延迟到其子类。 ）
2.工厂方法模式的通用代码
抽象产品类
public abstract class Product {
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}
具体的产品类可以有多个， 都继承于抽象产品类， 其源代码如代码清单8-9所示。
具体产品类
public class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
public class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}
抽象工厂类负责定义产品对象的产生， 源代码如代码清单8-10所示。
抽象工厂类
public abstract class Creator {
/*
* 创建一个产品对象， 其输入参数类型可以自行设置
* 通常为String、 Enum、 Class等， 当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
具体如何产生一个产品的对象， 是由具体的工厂类实现的，
具体工厂类
public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c){
Product product=null;
try {
product = (Product)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常处理
}
return (T)product;
}
}
场景类
public class Client {
public static void main(String[] args) {
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
/*
* 继续业务处理
*/
}
}
3.工厂方法模式实例
package ch08;
public interface Human {
// 人都有肤色
public void getColor();
// 人都分语言
public void getTalk();
}
package ch08;
public class BlackHuman implements Human {
public void getColor() {
// TODO Auto-generated method stub
System.out.println("黑人肤色为黑色");
}
public void getTalk() {
// TODO Auto-generated method stub
System.out.println("黑人说话一般听不懂");
}
}
package ch08;
public class WhiteHuman implements Human{
public void getColor() {
// TODO Auto-generated method stub
System.out.println("白人肤色为白");
}
public void getTalk() {
// TODO Auto-generated method stub
System.out.println("白人一般说英语");
}
}
package ch08;
public class YellowHuman implements Human{
public void getColor() {
// TODO Auto-generated method stub
System.out.println("黄色人种肤色为黄色");
}
public void getTalk() {
// TODO Auto-generated method stub
System.out.println("黄色人种一般说汉语");
}
}
package ch08;
public abstract class AbstractHumanFactory {
//泛型 通过定义泛型对creatHuman的输入参数产生两层限制： 必须是Class类型；必须是Human的实现类。
public abstract <T extends Human> T createHuman(Class<T> c);
// 泛型类可看作普通类的工厂
/**
*
* @author
* 泛型方法,定义一个带有类型参数的简单方法
* 这个方法是在普通类中定义的，而不是在泛型类中定义的。然而，这是一个泛型方法，可
以从尖括号和类型变量看出这一点。注意，类型变量放在修饰符（这里是public static）的后面，
返回类型的前面。
*/
/*class ArrayAlg
{
public static <T> T getMiddle(T... a)
{
return a[a.length / 2];
}
}*/
}
package ch08;
public class HumanFactory extends AbstractHumanFactory{
public <T extends Human> T createHuman(Class<T> c) {
// TODO Auto-generated method stub
//定义一个生产的人种;
Human human = null;
try {
/* 产生一个人种， 通过Class.forName(c.getName()).newInstance()实例化一个
c对象然后再把c对象强制转化为Human或T类型的对象*/
/*Class.forName(xxx.xx.xx) 返回的是一个类, .newInstance() 后才创建一个对象*/
// human = (T) Class.forName(c.getName()).newInstance();//也对
human = (Human) Class.forName(c.getName()).newInstance();
} 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 (T)human;
}
}
package ch08;
//女娲类
public class NvWa {
public static void main(String[] args) {
//声明一个造人的阴阳八卦炉
AbstractHumanFactory YingYangLu = new HumanFactory();
//女娲第一次造人，火候不足，于是白人产生了
System.out.println("--造出的第一批人是白色人种--");
// 现在， Class类是泛型的。 WhiteHuman.class实际上是一个Class<WhiteHuman>(应该是Class<Human>类的对象
// （事实上，是惟一的对象）。
Human whiteHuman = YingYangLu.createHuman(WhiteHuman.class);
whiteHuman.getColor();
whiteHuman.getTalk();
System.out.println("--造出的第二批人是黑色人种--");
Human blackHuman = YingYangLu.createHuman(BlackHuman.class);
blackHuman.getColor();
blackHuman.getTalk();
//第三次造人，火候刚刚好，于是黄色人种产生了
System.out.println("--造出的第三批人是黄色人种--");
Human yellowHuman = YingYangLu.createHuman(YellowHuman.class);
yellowHuman.getColor();
yellowHuman.getTalk();
}
}
4.工厂方法模式的优点
首先， 良好的封装性， 代码结构清晰。 一个对象创建是有条件约束的， 如一个调用者需
要一个具体的产品对象， 只要知道这个产品的类名（ 或约束字符串） 就可以了， 不用知道创
建对象的艰辛过程， 降低模块间的耦合。
其次， 工厂方法模式的扩展性非常优秀。 在增加产品类的情况下， 只要适当地修改具体
的工厂类或扩展一个工厂类， 就可以完成“拥抱变化”。 例如在我们的例子中， 需要增加一个
棕色人种， 则只需要增加一个BrownHuman类， 工厂类不用任何修改就可完成系统扩展。
再次， 屏蔽产品类。 这一特点非常重要， 产品类的实现如何变化， 调用者都不需要关
心， 它只需要关心产品的接口， 只要接口保持不变， 系统中的上层模块就不要发生变化。 因
为产品类的实例化工作是由工厂类负责的， 一个产品对象具体由哪一个产品生成是由工厂类
决定的。 在数据库开发中， 大家应该能够深刻体会到工厂方法模式的好处： 如果使用JDBC
连接数据库， 数据库从MySQL切换到Oracle， 需要改动的地方就是切换一下驱动名称（ 前提
条件是SQL语句是标准语句） ， 其他的都不需要修改， 这是工厂方法模式灵活性的一个直接
案例。