java設計模式--工廠模式，java設計模式--

java設計模式--工廠模式，java設計模式--

   所謂工廠，就是要造產品，比如一個小型磚瓦廠，只有一個窯，既能造磚又能造瓦，這種叫簡單工廠模式。規模稍大一點呢，我多個窯，有的窯專門造磚，有的窯專門造瓦，想造別的，比如瓷磚，我再用個專門的窯，這種成了工廠方法模式。但若是我開個汽車裝配廠，我既要輪胎，又要發動機，又要車架等等組合型的，那就要抽象工程模式。所以，我們的工廠模式分為三種：簡單工廠模式，工廠方法模式，抽象工廠模式。

   首先，簡單工廠：

   所謂簡單工廠，就是你告訴我，你想要什麼產品，我能產這種產品，就給你生產。簡單工廠模式又叫靜態工廠模式，因為這個工廠產出的產品是開始就定死的，就能造那幾種，多了沒辦法。而設計原則是新增產品不要修改原有的代碼，就好比你一個磚瓦窯想要生產瓷器，即便不砸了重來，也得內部整改很多東西。    以下的代碼示例是一個簡單工廠類，該工廠類可以生產手機， 且只能生產IPhone和Samsung兩款手機。倘若你想生產小米手機，不好意思，目前生產不了，RuntimeException，你非要生產呢，繼續加判斷，就等於改掉了目前的工廠類。    代碼：     

public class SimplePhoneFactory {
    
	public static Cellphone getCellphone(String type){
		if("iPhone".equals(type)){
			return new IPhone();
		}else if("Samsung".equals(type)) {
			return new Samsung();
		}else {
			throw new RuntimeException("沒有正確的手機類型創建");
		}
	}
}

　　

    工廠方法：

    工廠方法是在簡單工廠的基礎上，可以擴展的工廠，從設計的思路上，更加清晰的去管理工廠的生產。將每個產品的工廠實現細分出來。這種模式實現上面的手機工廠的話，就是一個廣義的工廠（接口），然後具體的實現每個產品的工廠實現。如果要新增產品的話，直接加一個該新產品的實現工廠即可，不用改動原有代碼。     代碼：  

 /*
  工廠方法接口 
 */
public interface PhoneFactory {
   public Cellphone getPhone(); 
}

　

/* 
 * @Description: iPhone 工廠
 */
public class IPhoneFactory implements PhoneFactory{

	@Override
	public Cellphone getPhone() {
		// TODO Auto-generated method stub
		return new IPhone();
	}

}

/* 
 * @Description:samsung工廠
 */
public class SamsungPhoneFactory  implements PhoneFactory{

	@Override
	public Cellphone getPhone() {
		// TODO Auto-generated method stub
		return new Samsung();
	}

}

　以上代碼可以看出，每個產品都需要自己的實現工廠，這時如果我們需要新增加新產品，比如小米手機，只需要新增一個MIPhoneFactory來實現PhoneFactory即可。

   抽象工廠：

    開頭也說了，針對於組合型產品，我們使用抽象工廠。也就是說，這種工廠相對其他兩種，復雜的多。而實際上，我們沒辦法拿抽象工廠和簡單工廠已經工廠方法比較，因為他們不是用來解決同一類問題的，基本上沒有什麼可比性。抽象工廠用來針對的是產品族，而簡單工廠和工廠方法都是針對單一產品的，如果真讓抽象工廠去對單個產品進行管理，反倒無能為力。    這裡我們還以手機為例，我們要生產手機，需要很多配件，比如CPU，比如相機，比如內存等等，我們暫且只認為決定一款手機好壞只有這三個組件。使用抽象工廠來實現。    首先，我們定義CPU的接口，已經能生產的一些列CPU，這裡以GoodCPU和BadCPU為例：    

public interface CPU {
   void run();
   void start();
}
//高端CPU
class GoodCUP implements CPU{

	@Override
	public void run() {
		System.out.println("高端CPU運轉方法。。。");
		
	}

	@Override
	public void start() {
		System.out.println("高端CPU開始方法。。。");
		
	}
	
}

//低端CPU
class  BadCPU implements CPU{

	@Override
	public void run() {
		System.out.println("低端CPU運轉方法。。。");
		
	}

	@Override
	public void start() {
		System.out.println("低端CPU開始方法。。。");
		
	}
	
}

　　然後是相機接口，以及相關的相機生產類型，其中的方法是隨便寫的。

    

public interface Camera {
   public void take();
 
}

class GoodCamera implements Camera{

	@Override
	public void take() {
		System.out.println("高端相機拍照。。。");
		
	}
	
}

class BadCamera implements Camera{

	@Override
	public void take() {
		System.out.println("低端相機拍照。。。");
		
	}
	
}

　　最後一個內存的接口已經一系列類型：

  

public interface Memory {
    
	void work();
}

class GoodMemory implements Memory{

	@Override
	public void work() {
		System.out.println("高性能內存工作");
		
	}
	
}
class BadMemory implements Memory{

	@Override
	public void work() {
		System.out.println("低性能內存工作");
		
	}
	
}

　　

   我們前面說了，抽象工廠就是利用一些列組件組合產品的工廠，上面我們寫的CPU，相機，內存都是我們要組件手機的組件。現在，我們開始寫我們的抽象工廠。當然為了方便，肯定要有工廠接口：

  

public interface AbPhoneFactory {
   CPU getCPU();
   Camera getCamera();
   Memory getMemory();
}

　　然後，我們根據自己的需要，隨機組合幾種組件，即可得到我們的產品，當然這是一組（產品）組合出來的最終產品。

     比如我們用好的CPU，好的內存，好的相機組合成一個好的手機：

public class GoodsPhoneFactory  implements AbPhoneFactory{

	@Override
	public CPU getCPU() {
		// TODO Auto-generated method stub
		return new GoodCUP();
	}

	@Override
	public Camera getCamera() {
		// TODO Auto-generated method stub
		return new GoodCamera();
	}

	@Override
	public Memory getMemory() {
		// TODO Auto-generated method stub
		return new GoodMemory();
	}

	

}

　　也可以用差的CPU，差的內存，差的相機組合成比較差勁的手機：

 

public class BadPhoneFactory implements AbPhoneFactory{

	@Override
	public CPU getCPU() {
		// TODO Auto-generated method stub
		return new BadCPU();
	}

	@Override
	public Camera getCamera() {
		// TODO Auto-generated method stub
		return new BadCamera();
	}

	@Override
	public Memory getMemory() {
		// TODO Auto-generated method stub
		return new BadMemory();
	}

}

　當然你也可以亂組合成中等的，這都是隨你便了，只要加一個工廠實現即可。

 

最後，我們來總結一下吧：

    對於單一產品，簡單工廠更簡單，但是新增產品時卻很乏力，或者說不符合設計原則，而工廠方法是不修改原有類的前提下，新增工廠類實現，更符合設計原則。是不是我們在單一產品的時候就該選擇工廠方法了呢？下面給出這麼一個對比：

    -- 結構復雜度 簡單工廠更加簡單 簡單工廠優於工廠方法

   -- 代碼復雜度 工廠方法復雜度較高 簡單工廠優於工廠方法
    -- 客戶端編程難度 工廠方法客戶端需要了解更多的實現工廠 簡單工廠優於工廠方法
   -- 管理難度 工廠方法由於實現工廠類較多，管理更難 簡單工廠優於工廠方法

   結合以上四點，我們說簡單工廠比工廠方法更加易用。這也就是開發時候簡單工廠比工廠方法使用的更多的原因。

   對於產品族，如果使用工廠模式，唯一的選擇--抽象工廠。

   OK，更多詳細代碼和本次測試代碼請參考github：https://github.com/LiuJishuai/designPatterns。