设计模式-工厂方法模式

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 ConcreteProduct1 extends Product {

		@Override
		public void method2() {
			// TODO Auto-generated method stub

		}

	}
	
	public abstract class Creator {

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

		@Override
		public <T extends Product> T createProduct(Class<T> c) {
			
			Product product = null;
			try {
				
				product = (Product) Class.forName(c.getName()).newInstance();
				
			} catch (Exception e) {
				
				e.printStackTrace();
			}
			
			return (T) product;
		}

	}
	

工厂方法模式的使用场景
（1）工厂方法是new 一个对象的代替品，所以在所有需要生成对象的地方都可以使用，但是需要考虑是否要增加一
个工厂类进行管理，增加代码的复杂度。
（2）需要灵活、可扩展的框架时，可以考虑采用工厂方法模式。
（3）可以用在异构项目中。
（4）测试驱动开发的框架下。

工厂方法的扩展
（1）缩小为简单工厂模式

	public class SimpleHumanFactory {

		public static <T extends Human> T createHuman(Class<T> c) {
		
			Human human = null;
			try {
				
				human = (Human) Class.forName(c.getName()).newInstance();
				
			} catch (Exception e) {
				e.printStackTrace();
			}
			
			return (T) human;
		}
	}

（2）升级为多个工厂类

	public abstract class AbstractHumansFactory {

		public abstract Human createHuman();
		
	}
	
	public class BlackHumanFactory extends AbstractHumansFactory {

		@Override
		public Human createHuman() {
			return new BlackHuman();
		}

	}

（3）替代单例模式

	public class Singleton {

		private Singleton() {}
		
		public void doSomething() {
			
		}
	}
	
	public class SingletonFactory {

		private static Singleton singleton;
		
		static {
			try {
				
				Class cl = Class.forName(Singleton.class.getName());
				// 获取无参构造函数
				Constructor constructor = cl.getDeclaredConstructor();
				// 设置无参构造是可访问的
				constructor.setAccessible(true);
				singleton = (Singleton) constructor.newInstance();
				
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		public static Singleton getSingleton() {
			return singleton;
		}
	}

（4）延迟初始化

public class LazyProductFactory {

		private static final Map<String, Product> prMap = new HashMap<String, Product>();
		
		public static synchronized Product createProduct(String type) throws Exception {
			
			Product product = null;
			
			if (prMap.containsKey(type)) {
				product = prMap.get(type);
			} else {
				if (type.equals("Product1")) {
					product = new ConcreteProduct1();
				} else {
					product = new ConcreteProduct2();
				}
				
				prMap.put(type, product);
			}
			
			return product;
		}
	}

通过定义一个Map 容器，容纳所有产生的对象，如果Map容器中已经有的对象，则直接取出返回。
如果没有，则根据需要产生对象并放入到Map 容器中。