【設計模式】（八）--創建型模式--建造者模式

【設計模式】（八）–創建型模式–建造者模式

建造者模式定義

Separate the construction of a complex object from its representation so that the same construction process an create different representations.

意思就是：講一個複雜對象的構建與它的表示分離，使得同樣的構造過程可以創建不同的描述。
建造者一般有以下四個角色：

• 抽象構造者（Builder） 對於實際類的組成部分進行抽象，定義各種構造邏輯
• 具體構造者 實現抽象構造者的方法，能夠返回一個構建好的實際類對象
• 實際類 一般都比較複雜，可能根據不同的構造參數及過程會有不同功能的對象
• 實際執行者 負責調用具體構造者方法的構造順序，構造出實際需要的類對象

構造者模式的優點

• 封裝性，構造者模式可以使使用者不必知道類具體實例化的細節
• 構造者具體事例過程與實際執行者無關，比較容易拓展
• 因爲封裝性，所以相關類不容易被其他模塊入侵。

構造者模式的使用場景

• 需要生成的對象具有複雜的內部結構。
• 需要生成的對象內部屬性本身相互依賴。
• 需要生成的對象需要創建實際過程要對外隔離。
• 需要生成的對象方法相同但參數不同，構建方法順序不同，實例化的對象功能不同時。

構造者模式和工廠模式區別

	工廠模式	構造者模式
關注點	構造出實際類對象	構造方式類型、構建順序 等不同產生的類的實例對象不同，着重過程

構造者模式簡單實現

類圖

實現

public class Bread {
    private String breadType;

    public String getBreadType() {
        return breadType;
    }

    public void setBreadType(String breadType) {
        this.breadType = breadType;
    }
}

public class Sandwich {
    private String sandwich;

    private int count;

    public String getSandwich() {
        return sandwich;
    }

    public void setSandwich(String sandwich) {
        this.sandwich = sandwich;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

public class Sauce {
    private String sauce;

    public String getSauce() {
        return sauce;
    }

    public void setSauce(String sauce) {
        this.sauce = sauce;
    }
}

public class Hamburger {
    private Bread bread;

    private Sauce sauce;

    private Sandwich sandwich;

    public Bread getBread() {
        return bread;
    }

    public void setBread(Bread bread) {
        this.bread = bread;
    }

    public Sauce getSauce() {
        return sauce;
    }

    public void setSauce(Sauce sauce) {
        this.sauce = sauce;
    }

    public Sandwich getSandwich() {
        return sandwich;
    }

    public void setSandwich(Sandwich sandwich) {
        this.sandwich = sandwich;
    }
}

public interface HamburgerBuilder {

    void buildBread(String bread);

    void buildSandwich(String sandwich, int count);

    void buildSauce(String sauce);

    Hamburger build();
}

public class HamburgerBuilderImpl implements HamburgerBuilder {

    private Hamburger hamburger = new Hamburger();

    @Override
    public void buildBread(String breadType) {
        Bread bread = new Bread();
        bread.setBreadType(breadType);
        hamburger.setBread(bread);
    }

    @Override
    public void buildSandwich(String sandwichName, int count) {
        Sandwich sandwich = new Sandwich();
        sandwich.setSandwich(sandwichName);
        sandwich.setCount(count);
        hamburger.setSandwich(sandwich);
    }

    @Override
    public void buildSauce(String sauceName) {
        Sauce sauce = new Sauce();
        sauce.setSauce(sauceName);
        hamburger.setSauce(sauce);
    }

    @Override
    public Hamburger build() {
        System.out.println("構建了一個："
                + hamburger.getSandwich().getCount() + "層" + hamburger.getSandwich().getSandwich()
                + hamburger.getSauce().getSauce()
                + hamburger.getBread().getBreadType()
                + "漢堡");
        return hamburger;
    }
}

public class Client {
    public static void main(String[] args) {
        HamburgerBuilder builder = new HamburgerBuilderImpl();
        builder.buildBread("燕麥");
        builder.buildSandwich("豬排", 2);
        builder.buildSauce("芝士");
        //此時就構建了一個雙層豬排芝士漢堡
        Hamburger hamburger = builder.build();
    }
}

執行結果如下，此時一個雙層豬排芝士燕麥漢堡就構建好了，只要出入不同的夾層如雞排那就是雞扒漢堡。