轉載地址：http://blog.csdn.net/beyond0525/article/details/22806393

在android中用到了很多的工廠類，如ThreadFactory建立抽象Runnable 。下面通過簡單的例子來學習工廠模式。

一、作用

工廠模式(Factory Method)：定義一個用於建立物件的介面，讓子類決定將哪一個類例項化。從而使一個類的例項化延遲到其子類。

抽象工廠模式(Abstract Factory)：提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。

二、使用場景

1. 對同一個介面的實現類進行管理和例項化建立

三、常用的使用方式

講例子之前，先假設要做這樣的一個設計。設計一個Usb功能的介面，具有store（儲存）和takeAlong(攜帶方便)兩個行為。然後要設計兩個產品，一個是 Phone(手機)，另一個是Camera(照相機)，很顯然，它們都可以是 Usb的實現類。為了便於統一管理和建立，我們很容易就能設計出一個簡單的工廠模式。

（1）普通的工廠方法

首先，我們可以畫出相關的設計圖：

程式碼實現如下：

定義Usb介面

1. publicinterface Usb {  
2.     void store();  
3.     void takeAlong();  
4. }  

Phone類

1. publicclass Phone implements Usb {  
2.     @Override
3.     publicvoid store() {  
4.         System.out.println("this is Phone usb!");  
5.     }  
6.     @Override
7.     publicvoid takeAlong() {  
8.         // TODO Auto-generated method stub
9.     }  
10.     publicvoid call() {  
11.         //TODO
12.     }  
13.     publicvoid sms() {  
14.         //TODO
15.     }  
16. }  

Camera類

1. publicclass Camera implements Usb {  
2.     @Override
3.     publicvoid store() {  
4.         System.out.println("this is Camera usb!");  
5.     }  
6.     @Override
7.     public
   void takeAlong() {  
8.         // TODO Auto-generated method stub
9.     }  
10.     publicvoid takePhotos() {  
11.         //TODO
12.     }  
13. }  

建立一個簡單的工廠類UsbFactory1，負責生產

1. /** 
2.  * 普通工廠方法 
3.  * 引數傳遞的字串會出錯 
4.  * ：正確建立物件 
5.  *  
6.  * @author xuzhaohu 
7.  *  
8.  */
9. publicclass UsbFactory1 {  
10.     public Usb produce(String type) {  
11.         if ("phone".equals(type)) {  
12.             returnnew Phone();  
13.         } elseif ("camera".equals(type)) {  
14.             returnnew Camera();  
15.         } else {  
16.             System.out.println("請輸入正確的型別!");  
17.             returnnull;  
18.         }  
19.     }  
20. }  

子類例項化通過工廠類去建立，如要建立camera,

1. /*普通工廠方法**/
2. UsbFactory1 factory1 = new UsbFactory1();  
3. Usb usb1 = factory1.produce("camera");//+phone
4. usb1.store();  

輸出：this is Camera usb!

總結：實現了工廠模式的基本功能，但是需要傳參去控制，會出現很多不確定的問題，可以在工廠類中定義不同產品的生產，就是如下介紹的工廠多方法生產。

（2）工廠多方法

只要在UsbFactory中再定製一下就行，業務更加分明

根據設計修改工廠類

1. **  
2.  * 多個工廠類方法  
3.  *   
4.  * @author xuzhaohu  
5.  *   
6.  */  
7. publicclass UsbFactory2 {  
8.     public Usb producePhone() {  
9.         returnnew Phone();  
10.     }  
11.     public Usb produceCamera() {  
12.         returnnew Camera();  
13.     }  
14. }  

同樣，要例項化某個子類物件，則可以這樣去呼叫：

1. /*多個工廠方法模式**/
2.         UsbFactory2 factory2 = new UsbFactory2();  
3.         Usb usb2 = factory2.producePhone();//+camera
4.         usb2.store();  

輸出：this is Phone usb!

這樣是不是讓業務邏輯更加清晰了一些呢！

但是如果在多處都要呼叫生產的話，不能每次都通過例項化工廠類然後去生產吧，這時候可以怎麼樣呢？

對，可以通過類訪問，在工廠類中加上static方法。

1. /** 
2.  * 靜態工廠方法 
3.  * ：不需要例項 
4.  *  
5.  * @author xuzhaohu 
6.  *  
7.  */
8. publicclass UsbFactory3 {  
9.     publicstatic Phone producePhone() {  
10.         returnnew Phone();  
11.     }  
12.     publicstatic Camera produceCamera() {  
13.         returnnew Camera();  
14.     }  
15. }  

那麼這時候可以直接不用例項化工廠類去訪問了

1. /*靜態工廠方法模式**/
2. Usb usb3 = UsbFactory3.producePhone();//+camera
3. usb3.store();  

輸出：this is Phone usb!

這樣就更加方便了一些。一般情況下，這樣就基本能滿足需求了，但是如果現在需求又要增加生產另外一個實現類產品Phone1，這時候肯定需要修改工廠類，在工廠類中增加一個新型別的生產Phone1方法。從設計的角度上講，可能違背了 閉包（對擴充套件要開放對修改要關閉） 的設計原則，為了不違背這個原則，可以抽象工廠方法去設計，下面將講到。

（3）抽象的工廠方法

為了不修改工廠中方法，我們可以對每個產品都建立相應工廠類去實現生產。這時候可以通過一個介面 Provider 去定義生產(produce)這個行為，然後讓每個產品的工廠類都實現這個介面。這樣如果有新的產品要生產的話只需要先實現一個工廠類就行。如下設計

生產介面Provider

1. /** 
2.  * 將工廠生產的行為寫成介面獨立 
3.  *  
4.  * @author xuzhaohu 
5.  *  
6.  */
7. publicinterface Provider {  
8.     Usb produce();  
9. }  

每個產品都有自己的工廠

PhoneFactory工廠

1. publicclass PhoneFactory implements Provider {  
2.     @Override
3.     public Usb produce() {  
4.         // TODO Auto-generated method stub
5.         returnnew Phone();  
6.     }  
7. }  

CameraFactory工廠

1. publicclass CameraFactory implements Provider {  
2.     @Override
3.     public Usb produce() {  
4.         // TODO Auto-generated method stub
5.         returnnew Camera();  
6.     }  
7. }  

每一個產品可以根據自己的業務來去工廠生產產品，如要生產Camera

1. /*抽象工廠方法模式**/
2.  /*1.擴充套件性好，不用修改原始碼 
3.   *2.新增一個實現USB介面的類+一個對應的實現Provider的工廠類**/
4.  Provider provider = new CameraFactory();  
5.  Usb usb4 = provider.produce();  
6.  usb4.store();  

輸出：this is Camera usb!

總結：抽象工廠模式從軟體設計模式的原則上講還是值得去推薦的。