建造者模式

• 建造者模式也屬於建立模式，它提供了一種建立物件的最佳方式。
• 定義：將一個複雜的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示。
• 主要作用：在使用者不知道物件的建造過程和細節的情況下就可以直接建立複雜的物件。
• 使用者只需要給出指定複雜物件的型別和內容，建造者模式負責按順序建立複雜物件（把內部的建造過程和細節隱藏起來）
• 例子：
  • 工廠（建造者模式）：負責製造汽車（組裝過>程和細節在工廠內）
  • 汽車購買者（使用者）：你只要說出你需要的型號（物件的型別和內容），然後直接購買就可以使用了（不需要知道汽車是怎麼組成的（車輪、車門、發動機 、方向盤 ））等
    

比如建一個房子（地基，鋼筋工程，鋪墊線，粉刷等來實現）包工頭首先建一個抽象類（Bulider），把產品的圖紙（Product）給了工人，工人（worker）按照包工頭的圖紙去建造，然後老闆（director）去指揮它們去實現。

Builder(一個整體的產品需要什麼)

package com.my.factory.builder;
//抽象的建造者：方法
public  abstract  class Builder {
    abstract void  builderaA();//地基
    abstract void  builderaB();//鋼筋工程
    abstract void  builderaC();//鋪墊線
    abstract void  builderaD();//粉刷
    //完工：得到產品
    abstract Product getProduct();
}

Product

package com.my.factory.builder;
//產品：房子
public class Product {
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}
 

worker

package com.my.factory.builder;
//具體的建造者：工人
public class Worker extends Builder {
    private Product product;
    public Worker(){
        product = new Product();
    }


    @Override
    void builderaA() {
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void builderaB() {
        product.setBuildA("鋼筋");
        System.out.println("鋼筋");
    }

    @Override
    void builderaC() {
        product.setBuildA("鋪墊線");
        System.out.println("鋪墊線");
    }

    @Override
    void builderaD() {
        product.setBuildA("粉刷牆面");
        System.out.println("粉刷牆面");
    }

    @Override
    Product getProduct() {
        return product;
    }
}
 

Directory

package com.my.factory.builder;
//指揮：核心負責構建一個工程，工程如何構建，由它決定
public class Director {
    //指揮工人按順序建房子
    public  Product build(Builder builder){
        builder.builderaA();
        builder.builderaB();
        builder.builderaC();
        builder.builderaD();
        return builder.getProduct();
    }
}

交工（測試）

package com.my.factory.builder;

public class Test {
    public static void main(String[] args) {
        //指揮
        Director director = new Director();
        //指揮具體的工人完成 產品
        Product build = director.build(new Worker());
        String s = build.toString();
        System.out.println(s);
    }
}

總結

上面例項是Builder模式的常規方法，導演類Director在Builder模式中具有很重要的作用，它用於指導具有如何構建產品，控制呼叫先後次序，並向呼叫這返回完整的產品類，但是有些情況下需要簡化系統結構，可以把Director和抽象建造者進行結合。

另一種案列見建造者模式之鏈式程式設計