工厂方法模式
定义：Define an interface for creating an object, but let subclasses decide which class to instantiate.Factory method lets a class defer instantiation to subclasses.
定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
工场方法模式最适合于在创建对象、扩展的时候使用了
下面的这个框架是工场方法比较通用的，便于扩展。（当然，在定义接口来代替抽象产品类）
抽象产品类
public abstract class Product
{
//产品类公共方法
public void method1()
{
}
//抽象方法
public abstract void method2();
}
具体产品类
可以有多个具体产品类，都是继承自抽象产品类
public class Productone extends Product
{
//必须实现抽象方法
public void method2()
{
}
}
public class Producttwo extends Product
{
//必须实现抽象方法
public void method2()
{
}
}
抽象工厂类
定义产品时使用
public abstract void Maker
{
/*
* 创建一个产品对象后，输入参数类型可以自行设置
* 这里使用到泛型，makeProduct里的参数必须是Class类型且是Product的实现类
*/
public abstract <T extends Product> T makeProduct(Class<T> c);
}
具体工厂类
具体工厂类才是如何生产一个产品的类，实现抽象工厂类
public class ReadMaker extends Maker
{
public <T extends Product> T makeProduct(Class<T> c)
{
Product product = null;
try
{
product = (Product)Class.forName(c.getName()).newInstance();
}catch(Exception e)
{
//deal with exception
}
return (T)product;
}
}
场景类
public class Client
{
public static void main(String args[])
{
Maker maker = new ReadMaker();
Product product = maker.makeProduct(Product1.class);
}
}
下面是一个具体的例子，很直观
定义一个抽象产品手机类
package com.loulijun.chapter8;
//手机类，包括很多
public abstract class Phone {
//打电话
public void call(){};
//音乐
public void music(){};
//上网
public void via_internet(){};
}
实现产品类1：实现一个iphone
package com.loulijun.chapter8;
public class iPhone extends Phone {
@Override
public void call() {
System.out.println("用iphone打电话");
}
@Override
public void music() {
System.out.println("用iphone听音乐");
}
@Override
public void via_internet() {
System.out.println("用iphone上网");
}
}
实现产品类2：Android手机
package com.loulijun.chapter8;
public class AndroidPhone extends Phone {
@Override
public void call() {
System.out.println("用Android手机打电话");
}
@Override
public void music() {
System.out.println("用Android手机听音乐");
}
@Override
public void via_internet() {
System.out.println("用Android手机上网");
}
}
实现产品类3：Windows Phone，云集当前三大流行机型
package com.loulijun.chapter8;
public class WindowsPhone extends Phone {
@Override
public void call() {
System.out.println("用windows phone手机打电话");
}
@Override
public void music() {
System.out.println("用windows phone手机听音乐");
}
@Override
public void via_internet() {
System.out.println("用windows phone手机上网");
}
}
抽象一个富士康（富士康是代工厂嘛）
package com.loulijun.chapter8;
//抽象类，抽象富士康
public abstract class AbstractFoxconn {
/**
* 这里采用泛型对createPhone的输入参数产生显示
* 1、输入参数必须是Class类型
* 2、输入参数必须是Phone的实现类
*/
public abstract <T extends Phone> T createPhone(Class<T> c);
}
实现抽象类
package com.loulijun.chapter8;
//实现类，富士康工厂
public class Foxconn extends AbstractFoxconn {
@Override
public <T extends Phone> T createPhone(Class<T> c) {
//定义一个手机
Phone phone = null;
try
{
//生产一个手机
phone = (Phone)Class.forName(c.getName()).newInstance();
}catch(Exception e)
{
e.printStackTrace();
}
return (T)phone;
}
}
场景类，深圳
package com.loulijun.chapter8;
//场景类，深圳的富士康代工生产各种系统的手机
public class Shenzhen {
public static void main(String args[])
{
//富士康
AbstractFoxconn foxconn = new Foxconn();
//生产iphone
System.out.println("----------生产一部iphone----------");
Phone iphone = foxconn.createPhone(iPhone.class);
iphone.call();
iphone.music();
iphone.via_internet();
//生产AndroidPhone
System.out.println("----------生产一部AndroidPhone，如htc的----------");
Phone androidphone = foxconn.createPhone(AndroidPhone.class);
androidphone.call();
androidphone.music();
androidphone.via_internet();
}
}
运行结果：
----------生产一部iphone----------
用iphone打电话
用iphone听音乐
用iphone上网
----------生产一部AndroidPhone，如htc的----------
用Android手机打电话
用Android手机听音乐
用Android手机上网
这样一个完成的工场方法模式就结束了，当然具体怎么用，怎么扩展就要根据实际项目来操作了
工场方法模式的优缺点可以参考：http://blog.csdn.net/beyondhaven/article/details/6948067
工场方法模式可以有很多中变换，可以是简单工场方法模式，可以是多工场方法模式，可以替换单例模式等等
简单工场方法模式：
不需要抽象工场类，并且createPhone方法时static (静态)的
多工场方法模式：
通过继承基抽象工场细分不同产品所对应的抽象工场，例如生产iphone、AndoridPhone、WindowsPhone所继承的工场分别是三个不同的继承自AbstractFoxconn的不同抽象工场，然后在场景类中根据具体需求选择需要使用的抽象工场