设计模式——工厂方法模式

工厂方法模式同样属于类的创建模式又被称为多态工厂模式。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象的工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

这一节内容需要有：《设计模式——简单工厂 》的代码为基础

http://blog.csdn.net/dawanganban/article/details/9875873

工程结构

现在我们添加一个Pear水果（产品）

package com.meritit;

public class Pear implements Fruit{

	@Override
	public void get() {
		System.out.println("采集梨子");	
	}

}

其他各个类如下：

（1）fruit.properties 配置文件

apple = com.meritit.Apple
banana = com.meritit.Banana
pear = com.meritit.Pear

（2）Apple类

package com.meritit;

public class Apple implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集苹果");
	}
}

（3）Banana类

package com.meritit;

public class Banana implements Fruit{
	/*
	 * 采集
	 */
	public void get(){
		System.out.println("采集香蕉");
	}
}

（4）Fruit接口

package com.meritit;

public interface Fruit {

	/*
	 * 采集
	 */
	public void get();
}

（5）FruitFactory工厂

package com.meritit;

public class FruitFactory {
	
	/**
	 * get方法，获得所有产品对象
	 * @throws IllegalAccessException 
	 * @throws Exception 
	 */
	public static Fruit getFruit(String type) throws Exception{
		String fruittype = ConfigUtil.getConfig(type);
		return (Fruit)Class.forName(fruittype).newInstance();
	}
}

（6）ConfigUtil工具类

package com.meritit;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ConfigUtil {
	/**
	 * 
	 * @param key
	 * @return value
	 */
	public static String getConfig(String style){
		Properties pro = new Properties();
		InputStream inStream = ConfigUtil.class.getClassLoader()
				.getResourceAsStream("fruit.properties");
		try {
			pro.load(inStream);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return pro.getProperty(style);
	}
}

（7）MainClass类

package com.meritit;

public class MainClass {
	
	public static void main(String[] args) throws Exception {
		//得到Apple实例
		Fruit apple = FruitFactory.getFruit("apple");
		//得到Banana实例
		Fruit banana = FruitFactory.getFruit("banana");
		//得到Pear实例
		Fruit pear = FruitFactory.getFruit("pear");
		//采集
		apple.get();
		banana.get();
		pear.get();
	}	
}

输出结果：

采集苹果
采集香蕉
采集梨子

下面我们开始：

定义一个抽象的水果工厂（抽象出工厂的生产方法）

package com.meritit;

public interface FruitFactory {
	
	public Fruit getFruit();
	
}

在实现具体的工厂（苹果厂和香蕉厂）

package com.meritit;

public class AppleFactory implements FruitFactory{

	@Override
	public Fruit getFruit() {
		return new Apple();
	}

}

package com.meritit;

public class BananaFactory implements FruitFactory{

	@Override
	public Fruit getFruit() {
		return new Banana();
	}

}

MainClass中实例化：

package com.meritit;

public class MainClass {
	
	public static void main(String[] args) throws Exception {
		//获得Apple工厂
		FruitFactory af = new AppleFactory();
		//获得Banana工厂
		FruitFactory bf = new BananaFactory();
		//得到Apple实例
		Fruit apple = af.getFruit();
		//得到Banana实例
		Fruit banana = bf.getFruit();
		//得到Pear实例
		//Fruit pear = FruitFactory.getFruit("pear");
		//采集
		apple.get();
		banana.get();
		//pear.get();
	}	
}

现在要添加一个生产梨子的工厂，怎么办呢？

很简单！

package com.meritit;

public class PearFactory implements FruitFactory{

	@Override
	public Fruit getFruit() {
		return new Pear();
	}

}

这样就可以获得实例

package com.meritit;

public class MainClass {
	
	public static void main(String[] args) throws Exception {
		//获得Apple工厂
		FruitFactory af = new AppleFactory();
		//获得Banana工厂
		FruitFactory bf = new BananaFactory();
		//获得Pear工厂
		FruitFactory pf = new PearFactory();
		//得到Apple实例
		Fruit apple = af.getFruit();
		//得到Banana实例
		Fruit banana = bf.getFruit();
		//得到Pear实例
		Fruit pear = pf.getFruit();
		//采集
		apple.get();
		banana.get();
		pear.get();
	}	
}

我们可以看到要增加工厂类，不需要修改工厂方法，可以直接添加，这样更加灵活

工厂方法模式中的角色：

（1）抽象工厂角色：工厂方法模式的核心，任何工厂类都必须实现这个类。

（2）具体工厂角色：具体工厂类是抽象工厂的一个实现，负责实例化产品对象。

（3）抽象角色：工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

（4）具体产品角色：工厂方法模式所创建的具体实例对象。

源代码下载：http://download.csdn.net/detail/lxq_xsyu/5903707