[[431024]]

建造者模式用于將復雜對象的創建和表示分離，有些對象由很多部分組成，每個部分又可以有多種不同選擇，創建這種對象的時候往往需要考慮使用建造者模式。

舉個例子

一輛汽車由發動機，方向盤，車燈，車燈，車身顏色等組成，每輛車的顏色，車輪大小，車燈樣式可能會不一樣，但是車的組成部分不會少。

建造模式有兩種實現方式，第一種方式是有導演的方式，第二種是無導演方式。根據我的經驗日常使用無導演的方式可能會更多一些。

有導演

所謂有導演就是通過一個導演類來指揮對象創建的過程，客戶端使用導演類來獲取對象，不用關心對象具體的創建過程。

先看一下UML圖，對建造模式有個大概的了解。

看一下具體代碼，我們以建造一輛汽車舉例

public class Car { 
 
    private String wheel; 
    private String engine; 
    private String seat; 
    private String lamp; 
    private String color; 
 
   //篇幅原因，此處省略get,set方法 
 
    @Override 
    public String toString() { 
        return "Car{" + 
                "wheel='" + wheel + '\'' + 
                ", engine='" + engine + '\'' + 
                ", seat='" + seat + '\'' + 
                ", lamp='" + lamp + '\'' + 
                ", color='" + color + '\'' + 
                '}'; 
    } 
} 

抽象Builder類，指定建造復雜對象步驟

public abstract class Builder { 
     
    public abstract void buildWheel(); 
 
    public abstract void buildSeat(); 
 
    public abstract void buildLamp(); 
 
    public abstract void buildColor(); 
 
    public abstract void buildEngine(); 
 
    public abstract Car getCar(); 
 
} 

具體Builder類，實現復雜對象具體建造過程和內容

public class ConcreteBuilder extends Builder { 
 
    private Car car; 
 
    public ConcreteBuilder() { 
        car = new Car(); 
    } 
 
    @Override 
    public void buildWheel() { 
        car.setWheel("wheel"); 
    } 
 
    @Override 
    public void buildSeat() { 
        car.setSeat("seat"); 
    } 
 
    @Override 
    public void buildLamp() { 
        car.setLamp("lamp"); 
    } 
 
    @Override 
    public void buildColor() { 
        car.setColor("color"); 
    } 
 
    @Override 
    public void buildEngine() { 
        car.setEngine("engine"); 
    } 
 
    //返回構建好的汽車模型 
    @Override 
    public Car getCar() { 
        return car; 
    } 
} 

Director類，決定了復雜對象的創建過程。

public class CarDirector { 
    public Car createCar(Builder builder){ 
        builder.buildWheel(); 
        builder.buildSeat(); 
        builder.buildLamp(); 
        builder.buildColor(); 
        builder.buildEngine(); 
        return builder.getCar(); 
    } 
} 

客戶端這樣使用

public class BuilderClient { 
    public static void main(String[] args){ 
        CarDirector carDirector = new CarDirector(); 
        //通過Director創建具體對象，不關心對象的創建過程 
        Car car = carDirector.createCar(new ConcreteBuilder()); 
        System.out.println(car.toString()); 
    } 
} 

無導演

無導演模式感覺日常開發中用的比較多，但凡見到形似這樣的代碼，大概率就是建造者模式了。

Car car = concreteBuilderA.buildEngine("engine") 
                    .buildLamp("lamp") 
                    .buildSeat("seat") 
                    .buildColor("color") 
                    //.buildWheel("wheel") 
                    .build(); 

老規矩先來看一下UML圖，來個整體的認識。

同樣來看一下具體代碼實現，還是以創建汽車為例，所以Car的代碼不在重復給出。

Builder類

public abstract class BuilderA { 
    //返回builder自身 
    abstract BuilderA buildWheel(String wheel); 
    abstract BuilderA buildEngine(String engine); 
    abstract BuilderA buildLamp(String lamp); 
    abstract BuilderA buildSeat(String seat); 
    abstract BuilderA buildColor(String color); 
    abstract Car build(); 
} 

具體Builder，負責對象的具體創建工作。

public class ConcreteBuilderA extends BuilderA  { 
 
    private Car car; 
 
    public ConcreteBuilderA() { 
        car = new Car(); 
    } 
 
    @Override 
    BuilderA buildWheel(String wheel) { 
        car.setWheel(wheel); 
        return this; 
    } 
 
    @Override 
    BuilderA buildEngine(String engine) { 
        car.setEngine("engine"); 
        return this; 
    } 
 
    @Override 
    BuilderA buildLamp(String lamp) { 
        car.setLamp("lamp"); 
        return this; 
    } 
 
    @Override 
    BuilderA buildSeat(String seat) { 
        car.setSeat("seat"); 
        return this; 
    } 
 
    @Override 
    BuilderA buildColor(String color) { 
        car.setColor("color"); 
        return this; 
    } 
 
    @Override 
    Car build() { 
        return car; 
    } 
} 

客戶端這樣使用

public class BuilderAClient { 
    public static void main(String[] args){ 
        ConcreteBuilderA concreteBuilderA = new ConcreteBuilderA(); 
 
        Car car = concreteBuilderA.buildEngine("engine") 
                    .buildLamp("lamp") 
                    .buildSeat("seat") 
                    .buildColor("color") 
                    //.buildWheel("wheel") 
                    .build(); 
        System.out.println(car.toString()); 
    } 
} 

總結

建造者模式是創建型模式之一，所謂的沒有Director的模式，只不過是把建造過程留給了客戶端，讓使用者自己決定怎樣創建對象。無Director模式的實現關鍵是Builder類里面構建每個組件的方法都是返回Builder自己。