建造者模式：是將一個復雜的對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

建造者模式通常包括下面幾個角色：

1. builder：給出一個抽象接口，以規範產品對象的各個組成成分的建造。這個接口規定要實現復雜對象的哪些部分的創建，並不涉及具體的對象部件的創建。

2. ConcreteBuilder：實現Builder接口，針對不同的商業邏輯，具體化復雜對象的各部分的創建。 在建造過程完成後，提供產品的實例。

3. Director：調用具體建造者來創建復雜對象的各個部分，在指導者中不涉及具體產品的信息，只負責保證對象各部分完整創建或按某種順序創建。

4. Product：要創建的復雜對象

UML類圖：

重要：建造者模式，是要有最終的建造對象，即Product。這一點與外觀模式有最明顯的區別。

具體產品（建造對象）：

package com.sjmx.builder;

public class Entity {
    
    protected String name;
    protected String age;
    protected String sex;
    protected String height;
    protected String weight;
    
    public String getName() {
        
 
return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        
 
this.sex = sex;
    }
    public String getHeight() {
        return height;
    }
    public void setHeight(String height) {
        this.height = height;
    }
    public String getWeight() {
        return weight;
    }
    public void setWeight(String weight) {
        this.weight = weight;
    }
    
    @Override
    public String toString() {
         
        return "名字:" + this.name +",性別:" + this.sex + ",身高：" + this.height
                + ",體重:" + this.weight + ",年齡：" +  this.age;
    }
}

抽象接口：

package com.sjmx.builder;

public interface Builder {
    
    void buildName();
    void buildAge();
    void buildSex();
    void buildHeight();
    void buildWeight();
    
}

具體建造者1：

package com.sjmx.builder;

public class ConBuilder1 implements Builder {
    
    Entity entity = new Entity();
    
    @Override
    public void buildName() {
        entity.setName("cook");
    }

    @Override
    public void buildAge() {
         entity.setAge("10");
    }

    @Override
    public void buildSex() {
         entity.setSex("boy");
    }

    @Override
    public void buildHeight() {
        entity.setHeight("165cm");
    }

    @Override
    public void buildWeight() {
        entity.setWeight("54kg");
    }

    public Entity getResult(){
        return entity;
    }
}

具體建造者2（也可以僅有一個建造者）：

package com.sjmx.builder;

public class ConBuilder2 implements Builder {
    
    Entity entity = new Entity();
    
    @Override
    public void buildName() {
        entity.setName("jack");
    }

    @Override
    public void buildAge() {
         entity.setAge("10");
    }

    @Override
    public void buildSex() {
         entity.setSex("girl");
    }

    @Override
    public void buildHeight() {
        entity.setHeight("175cm");
    }

    @Override
    public void buildWeight() {
        entity.setWeight("54kg");
    }
    
    public Entity getResult(){
        return entity;
    }
    
}

指揮者（此處我使用靜態方法實現，方便客戶端直接調用；實戰中可以不使用靜態方法）：

package com.sjmx.builder;

public class Director {
    
     static void build(Builder b){
         b.buildHeight();
         b.buildWeight();
         b.buildSex();
         b.buildAge();
         b.buildName();
    }
    
}

客戶端：

package com.sjmx.builder;

public class Client {
    
    public static void main(String[] args) {
        
        ConBuilder1 c1 = new ConBuilder1();
        ConBuilder2 c2 = new ConBuilder2();
        
        Director.build(c1);
        Director.build(c2);
        
        Entity t1 =    c1.getResult();
        Entity t2 =    c2.getResult();
        
        System.out.println(t1.toString());
        System.out.println(t2.toString());
    }
}

運行結果：

使用建造者模式的好處：

1.使用建造者模式可以使客戶端不必知道產品內部組成的細節。

2.具體的建造者類之間是相互獨立的，對系統的擴展非常有利。

3.由於具體的建造者是獨立的，因此可以對建造過程逐步細化，而不對其他的模塊產生任何影響。

使用建造模式的場合：

1.創建一些復雜的對象時，這些對象的內部組成構件間的建造順序是穩定的，但是對象的內部組成構件面臨著復雜的變化。

2.要創建的復雜對象的算法，獨立於該對象的組成部分，也獨立於組成部分的裝配方法時。

個人總結：

1、建造者模式更像是一套工作車間，它負責產品各個部件的組裝，客戶端無須知道具體的建造過程，只需要拿到相應的產品即可，大大簡化了代碼的耦合度；

2、說白了，建造者模式側重的是一個建造者類的內部邏輯，而外觀模式側重的是各個子類之間的邏輯，區別很大

3、建造者類是要有具體的建造對象生成的，即產品；外觀模式沒有這一點要求

《大話設計模式》——讀後感 （8）好菜每回味不同——建造者模式之基礎案例（1）