抽象工厂模式

如今比萨店成功的关键在于新鲜、高质量的原料，而且通过导入新的框架，加盟点将遵循你的流程，但是有一些加盟店，使用低价原来来增加利润。你必须采用一些手段，以免长此以往毁了品牌

确保原料一致，你打算建造一家生产原料的工厂，并将原料运送到各家加盟店。那么问题来了，加盟店坐落于不同的区域，纽约的红酱料和芝加哥的红酱料是不一样的。所以对于纽约和芝加哥你需要准备两组不同的原料。

芝加哥比萨菜单：

芝士披萨：番茄酱料，意大利白干酪，Parmesan干酪，比萨草。

素食披萨：番茄酱料，意大利白干酪，Parmesan干酪，茄子，菠菜，黑橄榄。

…..

纽约比萨菜单：

芝士披萨：大蒜番茄酱料，Reggiano干酪，大蒜。

素食披萨：大蒜番茄酱料，Reggiano干酪，蘑菇，洋葱，红辣椒。

…..

这表明我们有相同的产品家族：面团，意式腊肠，酱料，芝士，蔬菜，肉。但是制作方式根据区域不同而有差异。

纽约使用一组原料，而芝加哥使用另一组原料。可能不久之后加州就有了加盟店，到时候又需要运送另外一组区域的原料，接着呢？西雅图吗？

想要行得通，必须先清楚如何处理原料家族。

一、首先建造原料工厂

/**
 * 建造一个原料工厂，它是一个接口
 * 这个工厂将负责创建原料家族中的每一种原料。
 * @author Administrator
 *
 */
public interface PizzaIngredientFactory {
	public Dough createDough();
	public Sauce createSauce();
	public Cheese createCheese();
	public Veggies[] createVeggies();
	public Pepperoni createPepperoni();
	public Clams createClam();
	/*
	 * 如果每个工厂实例内都有某一种通用的“机制”需要实现，
	 * 就可以把这个列字改写成抽象类。
	 */
}

二、创建纽约原料工厂

/**
 * 创建纽约原料工厂
 * @author Administrator
 * 同理，参照本来可以实现ChicagoPizzaIngredientFactory
 *
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {

	@Override
	public Dough createDough() {
		return new ThinCrustDough();
	}

	@Override
	public Sauce createSauce() {
		return new MarinaraSauce();
	}
	
	//以下其他的实现原料具体类，类似做法。
	@Override
	public Cheese createCheese() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Veggies[] createVeggies() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Pepperoni createPepperoni() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Clams createClam() {
		// TODO Auto-generated method stub
		return null;
	}

}

三、重做披萨

public abstract class Pizza {
	String name;
	Dough dough;
	Sauce sauce;
	Veggies veggies[];
	Cheese cheese;
	Pepperoni pepperoni;
	Clams clam;

	abstract void prepare();

	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}

	void cut() {
		System.out.println("Cutting.....");
	}
	
	void box() {
		System.out.println("boxing...");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
	public String toString() {
		//这里是打印披萨的代码
		return null;
	}
}

四、实例化具体的披萨

/**
 * 具体的披萨--芝士披萨
 * @author Administrator
 * 同理，可实现其他具体披萨
 *
 */
public class CheesePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
	public CheesePizza (PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}
	
	@Override
	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}

}

**
 * 蛤俐披萨
 * @author Administrator
 *
 */
public class ClamPizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;

	public ClamPizza(PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}
	/**
	 * Pizza的代码利用相关的工厂生产原料，所生产的原料依赖所使用的工厂，
	 * Pizza类根本不关心这些原料，它只知道如何制作披萨
	 */
	@Override
	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}
}

五、再回到披萨店

**
 * 披萨店超类
 * @author Administrator
 *
 */
public abstract class PizzaStore {
	public Pizza orderPizza(String type) {
		Pizza pizza = null;
		pizza = createPize(type);
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}
	
	abstract Pizza createPize(String type);
}

/**
 * 具体的披萨店。
 * 当然其他的披萨店也可以参照这个来实现
 * @author Administrator
 *
 */
public class NYPizzaStore extends PizzaStore {

	@Override
	Pizza createPize(String type) {
		Pizza pizza = null;
		PizzaIngredientFactory ingredientFactory  = new NYPizzaIngredientFactory();
		if ("Cheese".equals(type)) {
			pizza = new CheesePizza(ingredientFactory);
		} else if ("Clam".equals(type)) {
			pizza = new ClamPizza(ingredientFactory);
		}
		// ....此处省略
		return pizza;
	}

}

六、原料和一些具体的原料。其他的就不贴代码了

public interface Dough {

}

public class ThinCrustDough implements Dough {

}

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

设计原则：依赖抽象，不要依赖具体类。