工厂模式（Factory Pattern）之简单工厂，工厂方法模式（Factory Method Pattern），抽象工厂模式（Abstract Factory Pattern）

《Head First》介绍了工厂模式的3个内容：

一、简单工厂

简单工厂并非一个模式，反而像是一个编程习惯，其本质是抽出了对象复杂多变的实例化过程到另外一个单独的类，以保证其他代码的不变。

通常是实例化的对象是拥有多类型的情况：

案例：可以用实例化水果派的例子

public class PatternDemo {
	
	public static void main(String[] args) {
		SimplePieFactory factory = new SimplePieFactory();
		
		Pie pie = factory.createPie(SimplePieFactory.TYPE_APPLE);
		System.out.println("Pie: " + pie.getName());
		
		pie = factory.createPie(SimplePieFactory.TYPE_BANANA);
		System.out.println("Pie: " + pie.getName());
		
		pie = factory.createPie(SimplePieFactory.TYPE_PINEAPPLE);
		System.out.println("Pie: " + pie.getName());
	}
}

public class SimplePieFactory {
	
	public static final int TYPE_APPLE = 0;
	public static final int TYPE_BANANA = 1;
	public static final int TYPE_PINEAPPLE = 2;
	
	public SimplePieFactory() {
		
	}
	
	public Pie createPie(int type) {
		Pie pie = null;
		if (type == TYPE_APPLE) {
			pie = new ApplePie();
		} else if (type == TYPE_BANANA) {
			pie = new BananaPie();
		} else if (type == TYPE_PINEAPPLE) {
			pie = new PineapplePie();
		} 
		return pie;
	}
}

public abstract class Pie {

	public Pie() {}

	public abstract String getName();
}

public class ApplePie extends Pie {

	@Override
	public String getName() {
		return "Apple Pie";
	}
}

另外两个类似。

二、工厂方法模式

工厂方法模式：定义了一个创建对象的接口， 但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类

其本质是虚基类中存在统一的操作或者处理对象实例的方法，但是实例化生成对象实例的方法是抽象方法，需要子类通过继承后实现

为的是满足不同的需求下的实例化对象不同的情况

案例：同样是水果派，但是A店改进工艺后有了AStyle的Pie，同样的B店也有了BStyle的，但是制作过程是一样的，只是馅料会有A和B自己的不同

因此只要让AB两家各自实现抽象基类里的createPie方法就可以有他们各自的特色，然后再用抽象基类里面统一的制作过程

代码：

public class PatternDemo {
	
	public static void main(String[] args) {
		AStore aStore = new AStore();
		aStore.cooking();
		
		BStore bStore = new BStore();
		bStore.cooking();
	}
}

public abstract class Store {

	public void cooking() {
		System.out.println("cooking......");
		Pie pie = null;
		pie = createPie();
		System.out.println("Pie: " + pie.getName());
		System.out.println("cooked......");
	}
	
	protected abstract Pie createPie();
}

public class AStore extends Store {

	@Override
	protected Pie createPie() {
		return new AStylePie();
	}

}

public class AStylePie extends Pie {

	@Override
	public String getName() {
		return "A StyleP ie";
	}

}

B的代码类似

设计原理6：要依赖抽象，不要依赖具体类（其作用是为了实现“依赖倒置原则”）

如何理解呢？

1、如果不用工厂方法模式，那么我们就用不到Pie的抽象类，然后我们会分别去根据要求用很多if-else去实例化各种各样的Pie，这个时候可以理解为Store是依赖于各种各样具体的Pie的。

2、有了抽象Pie类后，Store会依赖于抽象的Pie，而这个时候所有的具体Pie会依赖于抽象的Pie，这样就可以理解为倒置了

如何遵循“依赖倒置原则”，只是尽了遵循，因为绝对是不可能的

1、变量不可以持有具体类的引用

2、不要让类派生自具体类

3、不要覆盖基类（主要是抽象的基类）中已实现的方法

三、抽象工厂模式

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类

可以提现这个的案例就是水果派的原料上，

A的代码：

public interface PieIngredientFactory {

	public Ingredient createIngredient();
}

public class APieIngredientFactory implements PieIngredientFactory {

	@Override
	public Ingredient createIngredient() {
		return new AIngredient();
	}
}

public class AStylePie extends Pie {
	
	private PieIngredientFactory factory;
	
	public AStylePie(PieIngredientFactory factory) {
		this.factory = factory;
		prepare();
	}

	@Override
	public String getName() {
		return "A StyleP Pie with " + getIngredient().getIngredientName();
	}

	@Override
	public void prepare() {
		setIngredient(factory.createIngredient());
	}
}

关键在于prepare()方法中，无论是什么工厂，都是可以轻易重用的， 而Pie根本不用管是什么工厂