摘要：工廠模式就是用來創建對象，生產對象的。而現在，其全部依賴于工廠類，通過一個工廠類，實現解耦。應用實例實際設計中，工廠模式用的也是比較多，而且這種模式也會比較好辨識，帶有。

目錄

工廠模式

為什么使用工廠模式

應用實例

工廠模式：是一種常用的對象創建型設計模式,此模式的核心精神是封裝類中不變的部分，提取其中個性化善變的部分為獨立類，通過依賴注入以達到解耦、復用和方便后期維護拓展的目的。它的核心結構有四個角色，分別是抽象工廠；具體工廠；抽象產品；具體產品

這里所提到的依賴注入，對于依賴的創建思想又引出一個概念：依賴倒置即為高層組件不再依賴底層組件，而底層組件也不再依賴高層組件，而是出現一個工廠類，高底層組建依賴于這個工廠類。下面針對具體的例子來進行講解。

工廠，生產物品的地方。工廠模式就是用來創建對象，生產對象的。一般，我們會通過new來進行對象的創建，一旦通過new，那么就一定會有具體的實例出現，也就會使得該對象和當前類出現緊耦合，產生依賴，使得我們代碼的可擴展性和靈活性都變低。繼續我們上篇文章中工廠生產機器的例子。

//機器裝配的基類
public abstract class Machine{
//機器裝配的流程，final不可被復寫，保證方裝配算法不被破壞
    final void produce(){
        createFrame();
        addHead();
        addBody();
        if(ifDressup())
            dressUp();
    }
//創建框架
    public abstract void createFrame();
//添加一個機器頭
    public abstract void addHead();
//添加一個機器的身子
    public abstract void addBody();
//為機器進行裝扮
    public abstract void dressUp();
//判斷是否為該機器進行裝扮
    public boolean ifDressup(){
        return true;
    }

}
//繼承自基類的一個子類
public class InflatableDoll extends Machine{
    public void createFrame(){
        System.out.println("This is a Frame");
    }

    public void addBody(){
        System.out.println("This is a body");
    }

    public void dressUp(){
        System.out.println("This is a beautiful cloth");
    }

}

這是我們通過模板方法創建來創建我們機器的一個例子，那么現在我們有了一個新的需求，我們要對這些所有的機器在出售的時候要進行一個包裝，根據客戶點的類型，然后對其進行相應的包裝之后，然后才可以出售。不同機器的包裝流程大致相似的，所以我們可以這樣來寫我們的前臺銷售部門。

public class Store{

    public void order(String type){
         Machine machine;
        if(type=="inflatedoll"){
            machine = new InflatableDoll();
        }else if(type==""){
            ....
        }
        machine.produce();
        machine.firstPack();
        machine.secondPack();
        machine.thirdPack();
        machine.fourthPack();
    }

}
public class InflatableDoll extends Machine{

    public void firstPack(){
        System.out.prinltn("Add first pack to protect");
    }

    public void secondPack(){
        System.out.prinltn("Add second pack to protect");
    }

    public void thirdPack(){
        System.out.prinltn("Add third pack to protect");
    }

    public void fourthPack(){
        System.out.prinltn("Add fourth pack to protect");
    }
}

但是問題來了，當我們的機器種類不斷增多，對于機器類型的判斷，然后創建會使得我們的代碼變得很繁瑣，而且靈活性很差，按照設計模式的原則，封裝變化的，我們將對與機器類型的判斷和機器的創建封裝起來，我們該這個封裝起來的類起了個名字叫做工廠類，因為這個工廠類是可以用來產生新的對象的。封裝代碼如下。

public class MachineFactory{
    public Machine create(String type){
        Machine machine;
        if(type=="inflatabledoll"){
            machine = new InflatableDoll();
        }else if(){
            do something;
        }
        machine.produce();
        return machine;
    }
}

通過這個工廠類，我們的商店出售類就可以改變了,和具體的機器實例實現解耦和。

public class Store{

    Store(){
        MachineFactory factory = new MachineFactory();
    }

    public void order(String type){
         Machine machine= factory.create(type);
        machine.firstPack();
        machine.secondPack();
        machine.thirdPack();
        machine.fourthPack();
    }
}

頓時就感覺代碼簡潔了好多，而且條理也變得很清晰了。
通過例子，再去對我們之前的概念去理解，就會變得清晰很多，抽象工廠，具體工廠，抽象產品，具體產品。依賴注入，依賴倒置。首先對于抽象工廠和具體的工廠的理解，因為我們不同的產品可能在其生產上還是存在一些差異，所以通過一個抽象工廠類作為基類，然后針對不同的地方分別建立不同的類，根據這些類，我們來創建我們相應的產品，為了實現商店類和產品的松耦合，我們定義一個抽象產品類，然后所有的產品都將從這個抽象類繼承，然后實現自己的相應的方法，然后通過一個工廠類工廠方法注入實例，實例以委托的形式，來執行相應的操作。
依賴倒置：按照我們的傳統思路，我們商店要出售商品，那么我們的商店就要依賴商品，而這里我們從底層的角度去向高層進階，我們有商品，商品的創建需要一個工廠類，而商店類，則不再依賴于產品，產品也不再依賴于商店類，我們的第一種寫法，在商店類中對于我們要創建的類進行的判斷，我們就可以將其理解為商品對于商店類的依賴。而現在，其全部依賴于工廠類，通過一個工廠類，實現解耦。同時也使得之前的依賴出現了倒置，又高層依賴底層轉為底層依賴高層。

實際設計中，工廠模式用的也是比較多，而且這種模式也會比較好辨識，帶有Factory。比如Android中的

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

下篇更新狀態模式