抽象工廠模式

如今比薩店成功的關鍵在於新鮮、高質量的原料，而且通過導入新的框架，加盟點將遵循你的流程，但是有一些加盟店，使用低價原來來增加利潤。你必須採用一些手段，以免長此以往毀了品牌

確保原料一致，你打算建造一家生產原料的工廠，並將原料運送到各家加盟店。那麼問題來了，加盟店坐落於不同的區域，紐約的紅醬料和芝加哥的紅醬料是不一樣的。所以對於紐約和芝加哥你需要準備兩組不同的原料。

芝加哥比薩菜單：

芝士披薩：番茄醬料，意大利白乾酪，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 {

}

總結：工廠模式----定義了一個創建對象的接口，但由子類決定要實例化的類是哪一個。工廠方法讓類把實例化推遲到子類。

設計原則：依賴抽象，不要依賴具體類。