设计模式 - 工厂方法模式

1.工厂方法模式介绍

工厂方法模式是创建型模式之一，是一种结构简单的模式。是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

2.工厂方法模式介绍

2.1 定义一个用于创建对象的接口，让子类决定实例化哪个类。
2.2 一个抽象产品类，可以派生出多个具体产品类。 　　
        2.3 一个抽象工厂类，可以派生出多个具体工厂类。 
　　2.4 每个具体工厂类只能创建一个具体产品类的实例。 

3.应用场景

3.1 当一个类不知道它所必须创建的对象的类的时候。
3.2 当一个类希望由它的子类来指定它所创建的对象的时候。
3.3 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

4.UML类图

5.实现

5.1.简单工厂模式

一个抽象产品类仅有一个具体产品类，一个抽象工厂仅有一个具体工厂实现类
5.1.1 抽象工厂

	/**
	 * 抽象工厂类
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public abstract class Factory {


		/**
		 * 抽象工厂方法
		 * 具体生产什么产品由子类去实现
		 */


		/**
		 * 生产车
		 * Created By
		 * on 2016/3/15
		 */
		public abstract Car createCar();
	}

5.1.2 具体实现工厂

	/**
	 * 具体工厂BWMCar
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class BMWFactory extends Factory {
		@Override
		public Car createCar() {
			return new BMWCar();
		}
	}

5.1.3 抽象产品类

	/**
	 * 抽象产品类 - 车
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public abstract class Car {


		/**
		 * 抽象工厂方法
		 * 具体实现由具体产品类实现
		 */


		/**
		 * 开启
		 * Created By Teaphy
		 * on 2016/3/15
		 */
		public abstract void start();




		/**
		 * 停止
		 * Created By Teaphy
		 * on 2016/3/15
		 */
		public abstract void end();
	}

5.1.4 具体实现类

	/**
	 * 具体产品类 - 宝马
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class BMWCar extends Car {


		/**
		 * 开启
		 * Created By  Teaphy
		 * on 2016/3/15
		 */
		public void start() {
			System.out.println("BMWCar start");
		}


		/**
		 * 停止
		 * Created By  Teaphy
		 * on 2016/3/15
		 */
		public void end() {
			System.out.println("BMWCar end");
		}
	}

5.1.5 输出结果

	BMWCar start
	BMWCar end

依据上述代码，一个工厂抽象类只有一个具体实现类，那么我们是否可以简化掉工厂抽象类呢?
如果我们将对应的工厂方法修改为静态方法是否可以实现呢，不妨试一下：

5.1.6 静态工厂

	/**
	 * 静态工厂模式
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class SingleFactory {
		public static Car createCar() {
			return new BMWCar();
		}
	}

5.1.7 输出结果

    BMWCar start
    BMWCar end

对比输出结果，1.5 和 1.7的输出结果是一致的。像这样把对应的工厂方法用静态方法实现的方式，称为简单工厂模式或者静态工厂模式.

5.2 多工厂方法模式

5.2.1 具体实现工厂 - 1

	/**
	 * 具体工厂 BuickCar
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class BuickFactory extends Factory {


		public Car createCar() {
			return new BuickCar();
		}
	}

5.2.2 具体实现产品 - 1

	/**
	 * 具体产品类 - 别克
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class BuickCar extends Car {


		/**
		 * 开启
		 * Created By  Teaphy
		 * on 2016/3/15
		 */
		public void start() {
			System.out.println("BuickCar start");
		}


		/**
		 * 停止
		 * Created By  Teaphy
		 * on 2016/3/15
		 */
		public void end() {
			System.out.println("BuickCar end");
		}
	}

5.2.3 测试类 - 1

	/**
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class TestFactory {
		public static void main(String[] args) {
			Factory factoryBMW = new BMWFactory();
			Car carBMW = factoryBMW.createCar();


			carBMW.start();
			carBMW.end();


			Factory factoryBuick = new BuickFactory();
			Car carBuick = factoryBuick.createCar();


			carBuick.start();
			carBuick.end();


		}
	}

5.2.4 输出结果

	BMWCar start
	BMWCar end
	BuickCar start
	BuickCar end

上述代码中，在Client类中构造了一个工厂对象，并通过其生产了一个产品对象。如果想得到产品对象是BMWCar，只需构造具体工厂BMWFactory实例，同之毅然。像这种方式比较常用，需要哪个产品就生产哪一个产品。有时候我们可以利用反射的方式来更简洁地生产具体的产品对象，此时，需要在工厂方法的参数列表中，传入一个Class类来决定是哪一个产品类.

5.2.5 反射机制 - 抽象工厂

/**
	 * 反射机制 - 抽象工厂
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public abstract class ReflectionFactory {


		public abstract <T extends Car>T createCar(Class<T> clz);
	}

5.2.6 反射机制 - 具体工厂类

	/**
	 * 反射机制 - 具体工厂类
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class ConcreteReflectionFactory extends ReflectionFactory {
		@Override
		public <T extends Car> T createCar(Class<T> clz) {
			Car car = null;


			try{
				car = (Car) Class.forName(clz.getName()).newInstance();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}


			return (T) car;
		}
	}

5.2.7 测试类 - 2

	/**
	 * Created by Teaphy
	 * 2016/3/15.
	 */
	public class TestFactory {
		public static void main(String[] args) {
			ReflectionFactory reflectionFactory = new ConcreteReflectionFactory();
			Car carBMW = reflectionFactory.createCar(BMWCar.class);
			Car carBuick = reflectionFactory.createCar(BuickCar.class);


			carBMW.start();
			carBMW.end();


			carBuick.start();
			carBuick.end();


		}
	}

5.2.8 输出结果 - 2

	BMWCar start
	BMWCar end
	BuickCar start
	BuickCar end

参考资料

1.Android源码 设计模式解析与实战

2.设计模式系列——三个工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）