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

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

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

二、使用場景

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

三、常用的使用方式

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

（1）普通的工廠方法

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

程式碼實現如下：

定義Usb介面

public interface Usb {

    void store();

    void takeAlong();
}

public class Phone implements Usb {

    @Override
    public void store() {

        System.out.println("this is Phone usb!");
    }

    @Override
    public void takeAlong() {
        // TODO Auto-generated method stub

    }

    public void call() {
        //TODO
    }

    public void sms() {
        //TODO
    }

}
 

public class Camera implements Usb {

    @Override
    public void store() {
        System.out.println("this is Camera usb!");
    }

    @Override
    public void takeAlong() {
        // TODO Auto-generated method stub

    }

    public void takePhotos() {
        //TODO
    }

}

/**
 * 普通工廠方法
 * 引數傳遞的字串會出錯
 * ：正確建立物件
 * 
 * @author xuzhaohu
 * 
 */
public class UsbFactory1 {

    public Usb produce(String type) {
        if ("phone".equals(type)) {
            return new Phone();
        } else if ("camera".equals(type)) {
            return new Camera();
        } else {
            System.out.println("請輸入正確的型別!");
            return null;
        }
    }
}
 

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

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

（2）工廠多方法

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

根據設計修改工廠類

**
 * 多個工廠類方法
 * 
 * @author xuzhaohu
 * 
 */
public class UsbFactory2 {

    public Usb producePhone() {
        return new Phone();
    }

    public Usb produceCamera() {
        return new Camera();
    }

}

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

輸出：this is Phone usb!

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

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

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

/**
 * 靜態工廠方法
 * ：不需要例項
 * 
 * @author xuzhaohu
 * 
 */
public class UsbFactory3 {

    public static Phone producePhone() {
        return new Phone();
    }

    public static Camera produceCamera() {
        return new Camera();
    }
}

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

輸出：this is Phone usb!

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

（3）抽象的工廠方法

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

生產介面Provider

/**
 * 將工廠生產的行為寫成介面獨立
 * 
 * @author xuzhaohu
 * 
 */
public interface Provider {

    Usb produce();
}

PhoneFactory工廠

public class PhoneFactory implements Provider {

    @Override
    public Usb produce() {
        // TODO Auto-generated method stub
        return new Phone();
    }

}

public class CameraFactory implements Provider {

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

}

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

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