設計模式筆記——抽象工廠

上一篇說到了工廠模式，那麼學習了工廠模式，抽象工廠也得學習一下。實際上，抽象工廠模式實際上就是在工廠模式的基礎上再嵌套一層工廠模式而已，通過父工廠製造子工廠。只是，也並不完全是嵌套一層，各個工廠會被抽象成一個集多個工廠共同點的抽象類。通過工廠製造器，創建出該抽象工廠的子類。

好比如說，一個博客頁面有個換膚系統。那麼假如有兩套風格，黑和白。那麼，我選擇了黑色風格的，實際這步就相當通過換膚系統這個工廠製造器，創建出一個黑色主題的工廠，該黑色主題的工廠內可以生產各種黑色風格的產品，比如黑色頭像掛飾，黑色背景，黑色的xxx等，然後通過這些黑色主題產品完成了整個換膚操作。白色主題也如此。

好吧，上次以水果工廠作爲一個類，那麼這次要創建一個蔬菜工廠，水果和蔬菜這兩類都屬於種植物，那麼我們就可以根據這一共同點抽象出一個種植物抽象類，即種植物工廠。

首先，創建產品類，包括上次的水果，和現在的蔬菜，他們都實現了水果類接口和蔬菜類接口：

水果系列：

public interface Fruit {
	void printInfo();
}

public class Apple implements Fruit{

	@Override
	public void printInfo() {
		// TODO Auto-generated method stub
		System.out.println("蘋果");
	}

}

public class Banana implements Fruit{

	@Override
	public void printInfo() {
		// TODO Auto-generated method stub
		System.out.println("香蕉");
	}
		
}

public class Orange implements Fruit{

	@Override
	public void printInfo() {
		// TODO Auto-generated method stub
		System.out.println("橙子");
	}

}

接着是蔬菜系列：

public interface Vegetable {
	public void printInfo();
}

public class Tomato implements Vegetable{

	@Override
	public void printInfo() {
		// TODO Auto-generated method stub
		System.out.println("西紅柿");
	}

}

public class Cabbage implements Vegetable{

	@Override
	public void printInfo() {
		// TODO Auto-generated method stub
		System.out.println("白菜");
	}
	
}

public class Eggplant implements Vegetable{

	@Override
	public void printInfo() {
		// TODO Auto-generated method stub
		System.out.println("茄子");
	}
	
}

然後，是它們各自的工廠類：

水果工廠：

public class FruitFactory extends PlantFactory{
	
	public static final int APPLE=1;
	public static final int BANANA=2;
	public static final int ORANGE=3;
	
	@Override
	public Fruit getFruit(int fruitType){
		
		if(fruitType==APPLE){
			return new Apple();
		}
		if(fruitType==BANANA){
			return new Banana();
		}
		if(fruitType==ORANGE){
			return new Orange();
		}
		return null;
	}

	@Override
	Vegetable getVegetable(int vegetableType) {
		// TODO Auto-generated method stub
		return null;
	}

}

蔬菜工廠：

public class VegetableFactory extends PlantFactory {

	public static final int CABBAGE=1;
	public static final int TOMATO=2;
	public static final int EGGPLANT=3;
	
	@Override
	Fruit getFruit(int fruitType) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Vegetable getVegetable(int vegetableType) {
		// TODO Auto-generated method stub
		if(vegetableType==CABBAGE){
			return new Cabbage();
		}
		if(vegetableType==TOMATO){
			return new Tomato();
		}
		if(vegetableType==EGGPLANT){
			return new Eggplant();
		}		
		return null;
	}

}

可以看到，它們都是屬於種植物這一類，所以都是繼承了種植工廠類

public abstract class PlantFactory {
	abstract Fruit getFruit(int fruitType);
	abstract Vegetable getVegetable(int vegetableType);
}

最後，提供一個工廠生產器，即生產工廠的工廠：

public class Plantation {

	public static final int FRUIT=1;
	public static final int VEGETABLE=2;
	
	public static PlantFactory getFactory(int factoryType){
		if(factoryType==FRUIT){
			return new FruitFactory();
		}
		if(factoryType==VEGETABLE){
			return new VegetableFactory();
		}
		return null;
	}
}

好吧，寫個main測試下：

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		FruitFactory fruitFactory=(FruitFactory)Plantation.getFactory(Plantation.FRUIT);		
		Apple apple=(Apple) fruitFactory.getFruit(FruitFactory.APPLE);
		apple.printInfo();
		
		VegetableFactory vegetableFactory=(VegetableFactory)Plantation.getFactory(Plantation.VEGETABLE);
		Tomato tomato=(Tomato) vegetableFactory.getVegetable(VegetableFactory.TOMATO);
		tomato.printInfo();
	}

結果：

雖然工廠設計模式在獲取產品類時很方便，但實際上產品的需求越嚴格，那麼內部系統則越發龐大複雜，對於生產一些小產品來說，使用這麼複雜龐大的系統反而浪費資源。