工厂方法（Factory mothod Pattern

工厂方法（Factory mothod Pattern）


工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

代码：
Product.java产品抽象类

package org.factoryMethod;
public abstract class Product {
//	公用的方法
	public void menthod1(){
		
	}
//	抽象方法
	public abstract void menthod2();
}

ConcreteProduct1.java具体产品类1

package org.factoryMethod;

public class ConcreteProduct1 extends Product {

	// 具体的业务逻辑
	@Override
	public void menthod2() {
		System.out.println("我是产品1");
	}
}

ConcreteProduct2.java具体产品类2

package org.factoryMethod;

public class ConcreteProduct2 extends Product {

	// 具体的业务逻辑
	@Override
	public void menthod2() {
		System.out.println("我是产品2");
	}
}

Creator.java定义一个工厂方法的接口
注意：采用泛型，通过泛型concreteCreator对输入参数产生两层限制:
1. 必须是Class类型；
2. 必须是Product的实现类。
减少对象间的转换，约束其输入参数的类型。

package org.factoryMethod;

public abstract class Creator {
	public abstract <T extends Product> T creatoProduct(Class<T> c);
}

ConcreteCreator.java工厂方法的实现

package org.factoryMethod;

public class ConcreteCreator extends Creator {

	@Override
	public <T extends Product> T creatoProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return (T) product;
	}
}

Client.java调试

package org.factoryMethod;

public class Client {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConcreteCreator concreteCreator = new ConcreteCreator();
		Product product = null;
		product = concreteCreator.creatoProduct(ConcreteProduct1.class);
		product.menthod2();
		product = concreteCreator.creatoProduct(ConcreteProduct2.class);
		product.menthod2();
	}
}

输出结果：
我是产品1
我是产品2

注意：采用泛型，通过泛型concreteCreator对输入参数产生两层限制:
3. 必须是Class类型；
4. 必须是Product的实现类。
减少对象间的转换，约束其输入参数的类型。

工厂方法模式的应用
优点：
1. 良好封装性，代码结构清晰。
2. 扩展优秀。
3. 屏蔽产品类
4. 是典型的解耦框架。

工厂方法模式的扩展：
1. 简化的工厂方法：去除掉抽象的接口。将具体实现的方法改成静态static,客户端Client.java调用直接

product = ConcreteCreator.creatoProduct(ConcreteProduct1.class);

ConcreteCreator.java

package org.factoryMethod;

public class ConcreteCreator{
	public static <T extends Product> T creatoProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return (T) product;
	}
}

2. 升级为多个工厂类。即产品1，有一个其自己的工厂类，产品2也有其自己的工厂类。每个工厂类中可以直接使用new去创造其对象。

3. 替代单例模式：使用Java的反射机制

package org.factoryMethod.singletone;

public class Singletone {
	// 单例模式，该类参数私有化
	private Singletone() {
	}

	public void method1() {
		System.out.println("具体的逻辑业务");
	}
}

package org.factoryMethod.singletone;

import java.lang.reflect.Constructor;

public class SingletoneFactory {
	private static Singletone singletone;
	static {
		try {
			// 获取一个类的标识
			Class singletoneClass = Class.forName(Singletone.class.getName());
			// 获取该类的无参构造函数
			Constructor constructor = singletoneClass.getDeclaredConstructor();
			// 更改其访问权限，使其可以被访问
			constructor.setAccessible(true);
			// 实例化
			singletone = (Singletone) constructor.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Singletone getSingletone() {
		return singletone;
	}
}

4. 延迟的初始化：一个对象被完毕后，并不立刻释放，工厂类保持其初始化状态，等待再次被使用。

package org.factoryMethod.lazy;

import java.util.HashMap;

public class ProductFactory{
	private static final HashMap<String, Product> pool = new HashMap<String, Product>();
	private static synchronized Product createProduct(String key){
		Product product = null;
//		如果Map中已有对象
		if(pool.containsKey(key)){
			product = pool.get(key);
		}
		else{
			if(key.equals("ConcreteProduct1")){
				product = new ConcreteProduct1();
			}
			else{
				product = new ConcreteProduct2();
			}
			pool.put(key, product);
		}
		return product;
	}
}