在工廠方法模式中，我們使用一個工廠建立一個產品，也就是說一個具體的工廠對應一個具體的產品。但是有時候我們需要一個工廠能夠提供多個產品物件，而不是單一的物件，這個時候我們就需要使用抽象工廠模式。

在講解抽象工廠模式之前，我們需要釐清兩個概念：

產品等級結構。產品的等級結構也就是產品的繼承結構。例如一個為空調的抽象類，它有海爾空調、格力空調、美的空調等一系列的子類，那麼這個抽象類空調和他的子類就構成了一個產品等級結構。

產品族。產品族是在抽象工廠模式中的。在抽象工廠模式中，產品族是指由同一個工廠生產的，位於不同產品等級結構中的一組產品。比如，海爾工廠生產海爾空調。海爾冰箱，那麼海爾空調則位於空調產品族中。

產品等級結構和產品族結構示意圖如下：

        一、基本定義                                                                                                                   

抽象工廠模式提供一個介面，用於建立相關或者依賴物件的家族，而不需要明確指定具體類。

抽象工廠允許客戶端使用抽象的介面來建立一組相關的產品，而不需要關係實際產出的具體產品是什麼。這樣一來，客戶就可以從具體的產品中被解耦。

        二、模式結構                                                                                                                   

抽象工廠模式的UML結構圖如下：

模式結構說明。

AbstractFactory：抽象工廠。抽象工廠定義了一個介面，所有的具體工廠都必須實現此介面，這個介面包含了一組方法用來生產產品。

ConcreteFactory：具體工廠。具體工廠是用於生產不同產品族。要建立一個產品，客戶只需要使用其中一個工廠完全不需要例項化任何產品物件。

AbstractProduct：抽象產品。這是一個產品家族，每一個具體工廠都能夠生產一整組產品。

Product：具體產品。

        三、模式實現                                                                                                                  

依然是披薩店。為了要保證每家加盟店都能夠生產高質量的披薩，防止使用劣質的原料，我們打算建造一家生產原料的工廠，並將原料運送到各家加盟店。但是加盟店都位於不同的區域，比如紐約、芝加哥。紐約使用一組原料，芝加哥使用另一種原料。在這裡我們可以這樣理解，這些不同的區域組成了原料家族，每個區域實現了一個完整的原料家族。

首先建立一個原料工廠。該工廠為抽象工廠，負責建立所有的原料。

PizzaIngredientFactory.java

public interface PizzaIngredientFactory {
	/*
	 * 在介面中，每個原料都有一個對應的方法建立該原料
	 */
	public Dough createDough();    
	
	public Sauce createSauce();
	
	public Cheese createCheese();
	
	public Veggies[] createVeggies();
	
	public Pepperoni createPepperoni();
	
	public Clams createClams();
}

原料工廠建立完成之後，需要建立具體的原料工廠。該具體工廠只需要繼承PizzaIngredientFactory，然後實現裡面的方法即可。

紐約原料工廠：NYPizzaIngredientFactory.java。

public class NYPizzaIngredientFactory implements PizzaIngredientFactory{

	@Override
	public Cheese createCheese() {
		return new ReggianoCheese();
	}

	@Override
	public Clams createClams() {
		return new FreshClams();
	}

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

	@Override
	public Pepperoni createPepperoni() {
		return new SlicedPepperoni();
	}

	@Override
	public Sauce createSauce() {
		return new MarinaraSauce();
	}

	@Override
	public Veggies[] createVeggies() {
		Veggies veggies[] =  {new Garlic(),new Onion(),new Mushroom(),new RefPepper()};
		return veggies;
	}

}

重新返回到披薩。在這個披薩類裡面，我們需要使用原料，其他方法保持不變，將prepare()方法宣告為抽象，在這個方法中，我們需要收集披薩所需要的原料。

Pizza.java

public abstract class Pizza {
	/*
	 * 每個披薩都持有一組在準備時會用到的原料
	 */
	String name;
	Dough dough;
	Sauce sauce;
	Veggies veggies[];
	Cheese cheese;
	Pepperoni pepperoni;
	Clams clams;
	
	/*
	 * prepare()方法宣告為抽象方法。在這個方法中，我們需要收集披薩所需要的原料，而這些原料都是來自原料工廠
	 */
	abstract void prepare();
	
	void bake(){
		System.out.println("Bake for 25 munites at 350");
	}
	
	void cut(){
		System.out.println("Cutting the pizza into diagonal slices");
	}
	
	void box(){
		System.out.println("Place pizza in official PizzaStore box");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

CheesePizza.java

public class CheesePizza extends Pizza{
	PizzaIngredientFactory ingredientFactory;
	
	/*
	 * 要製作披薩必須要有製作披薩的原料，而這些原料是從原料工廠運來的
	 */
	public CheesePizza(PizzaIngredientFactory ingredientFactory){
		this.ingredientFactory = ingredientFactory;
		prepare();
	}
	
	/**
	 * 實現prepare方法
	 * prepare 方法一步一步地建立芝士比薩，每當需要原料時，就跟工廠要
	 */
	void prepare() {
		System.out.println("Prepareing " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}

}

Pizza的程式碼利用相關的工廠生產原料。所生產的原料依賴所使用的工廠，Pizza類根本不關心這些原料，它只需要知道如何製作披薩即可。這裡，Pizza和區域原料之間被解耦。

ClamPizza.java

public class ClamPizza extends Pizza{
	PizzaIngredientFactory ingredientFactory;
	
	public ClamPizza(PizzaIngredientFactory ingredientFactory){
		this.ingredientFactory = ingredientFactory;
	}
	
	@Override
	void prepare() {
		System.out.println("Prepare " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
		clams = ingredientFactory.createClams();      
	}

}

做完披薩後，需要關注披薩店了。

在披薩店中，我們依然需要關注原料，當地的披薩店需要和本地的原料工廠關聯起來。

PizzaStore.java

public abstract class PizzaStore {
	public Pizza orderPizza(String type){
		Pizza pizza;
		pizza = createPizza(type);
			
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		
		return pizza;
	}
		
	/*
	* 建立pizza的方法交給子類去實現
	 */
	abstract Pizza createPizza(String type);
}

public class NYPizzaStore extends PizzaStore{

	@Override
	Pizza createPizza(String type) {
		Pizza pizza = null;
		//使用紐約的原料工廠
		PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();   
		if("cheese".equals(type)){
			pizza = new CheesePizza(ingredientFactory);
			pizza.setName("New York Style Cheese Pizza");
		}
		else if("veggie".equals(type)){
			pizza = new VeggiePizza(ingredientFactory);
			pizza.setName("New York Style Veggie Pizza");
		}
		else if("clam".equals(type)){
			pizza = new ClamPizza(ingredientFactory);
			pizza.setName("New York Style Clam Pizza");
		}
		else if("pepperoni".equals(type)){
			pizza = new PepperoniPizza(ingredientFactory);
			pizza.setName("New York Style Pepperoni Pizza");
		}
		return pizza;
	}	
}

其中PizzaIngredientFactory是抽象的披薩原料工廠介面，它定義瞭如何生產一個相關產品的家族。這個家族包含了所有制作披薩的原料。

NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory是兩個具體披薩工廠類，他們負責生產相應的披薩原料。

NYPizzaStore是抽象工廠的客戶端。

四、模式優缺點                                                                                                                

優點

1、  抽象工廠隔離了具體類的生成，是的客戶端不需要知道什麼被建立。所有的具體工廠都實現了抽象工廠中定義的公共介面，因此只需要改變具體工廠的例項，就可以在某種程度上改變整個軟體系統的行為。

2、  當一個產品族中的多個物件被設計成一起工作時，它能夠保證客戶端始終只使用同一個產品族中的物件。

缺點

新增新的行為時比較麻煩。如果需要新增一個新產品族物件時，需要更改介面及其下所有子類，這必然會帶來很大的麻煩。

五、模式使用場景                                                                                                          

1.  一個系統不應當依賴於產品類例項如何被建立、組合和表達的細節，這對於所有型別的工廠模式都是重要的。

2.系統中有多於一個的產品族，而每次只使用其中某一產品族。

3. 屬於同一個產品族的產品將在一起使用，這一約束必須在系統的設計中體現出來。

4. 系統提供一個產品類的庫，所有的產品以同樣的接口出現，從而使客戶端不依賴於具體實現。

六、總結                                                                                                                        

1、  抽象工廠模式中主要的優點在於具體類的隔離，是的客戶端不需要知道什麼被建立了。其缺點在於增加新的等級產品結構比較複雜，需要修改介面及其所有子類。