工厂模式

factory模式的两个最重要的功能：

1）定义创建对象的接口，封装了对象的创建；
2）使得具体化类的工作延迟到了子类中。

Factory模式也带来至少以下两个问题：

1）如果为每一个具体的ConcreteProduct类的实例化提供一个函数体，那么我们可能不得不在系统中添加了一个方法来处理这个新建的ConcreteProduct，这样Factory的接口永远就不肯能封闭（Close）

2）可以通过创建一个Factory的子类来通过多态实现这一点，但是这也是以新建一个类作为代价的。

解决方法：通过参数化的工厂方法

Factory模式仅仅局限于一类类（就是说Product是一类，有一个共同的基类）

Example code：

InterfaceFactory：

package com.designpatten.factory;

public interface Factory {

	Product createProduct(String productName) ;
	
}

ConcreteFactory:

public class ConcreteFactory implements Factory {

	@Override
	public Product createProduct(String productName) {
		Product product = null ;
		try {
			product = (Product)(Class.forName(productName).newInstance()) ;
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return product;
	}

}

Interface Product：

public interface Product {
	void operation() ;
}

ConcreteProduct1:

public class ConcreteProduct1 implements Product {

	@Override
	public void operation() {
		System.out.println("ConcreteProduct1 -> operation");
	}

}

ConcreteProduct3:

public class ConcreteProduct3 implements Product {

	@Override
	public void operation() {
		System.out.println("ConcreteProduct3 -> operation");
	}

}

FactoryTest:

public class FactoryTest {
	public static void main(String[] args) {
		Factory fac =new ConcreteFactory() ;
		Product p1 = fac.createProduct("com.designpatten.factory.ConcreteProduct1") ;
		p1.operation() ;  //print:ConcreteProduct1 -> operation
		Product p3 = fac.createProduct("com.designpatten.factory.ConcreteProduct3") ;
		p3.operation() ;  //print:ConcreteProduct3 -> operation
	}
}