介紹

先來說一遍官話

是一種一步一步建立一個複雜物件的建立型模式，它允許使用者在不知道內部構件細節的情況下，更加精細地控制及物件的構造流程。
它可以將構建複雜物件的流程與它的部件分離，使構建過程與部件都可以自由擴充套件，降低兩者間的耦合性。

再來結合實際例子

裝一臺電腦主機需要主機板，CPU，記憶體，散熱，顯示卡，電源，機箱，硬碟。我只需要把合適型號的配件買好來往主機板上裝就OK了，我並不需要知道CPU是怎麼做的，裡面的工作邏輯等等。

使用場景

使用場景

基本部件不變，組合經常變化的時候

舉個栗子

對於一臺個人電腦，其各組成部分可能不會完全一樣，每個部分都可以根據實際情況靈活選擇，但是將電腦配件組裝成個人電腦的步驟確是大同小異的
一臺主機，機箱可以是喬思伯，也可以是鞋盒；散熱可以是風扇，也可以是蘿蔔，顯示卡可以是RTX3060TI也可以是GTX690戰術核顯示卡。其組合不同卻仍可以正常點亮。

優/缺點

優點

構建過程與部件都可以自由擴充套件。
構建和表示分離，大大降低了耦合性。

缺點

產品的組成部分必須相同。
如果產品的配件發生變化，則建造者也要修改，在產品較為複雜的情況下，工作量很大。

那麼話不多說，實際操作一次吧

• 資料參考自《Android原始碼設計模式解析與實戰》，如果我理解的有問題或是有不足之處還請指出，謝謝

我們會建立以下幾個類：

• 抽象產品Computer類 抽象產品類，定義其應有的各個配件
• 具體產品MoonComputer類
• 抽象建造者Builder類 規範產品的建造，其具體實現由其子類實行
• 具體建造者MoonBuilder類 實現抽象Builder類定義的所有方法，並且返回 一個組建好的物件
• 指揮者Director類 統一組裝過程

抽象產品Computer類

package DesignPattern.builderPattern_conputer

 abstract class Computer {

    protected var mCpu: String? = null
    protected var mRadiator: String? = null
    protected var mMainBoard: String? = null
    protected var mMemory: String? = null
    protected var mGraphicsCard: String? = null
    protected var mPower: String? = null
    protected var mDisk: String? = null
    protected var mCase: String? = null

    abstract fun setCpu(string: String)
    abstract fun setRadiator(string: String)
    abstract fun setMainBoard(string: String)
    abstract fun setMemory(string: String)
    abstract fun setGraphicsCard(string: String)
    abstract fun setPower(string: String)
    abstract fun setDisk(string: String)
    abstract fun setCase(string: String)


}
 

抽象產品Computer類

package DesignPattern.builderPattern_conputer

class MoonConputer : Computer() {
    override fun setRadiator(string: String) {
        mRadiator = string
    }
    override fun setMainBoard(string: String) {
        mMainBoard = string
    }
    override fun setMemory(string: String) {
        mMemory = string
    }
    override fun setGraphicsCard(string: String) {
        mGraphicsCard = string
    }
    override fun setPower(string: String) {
        mPower = string
    }
    override fun setDisk(string: String) {
        mDisk = string
    }
    override fun setCase(string: String) {
        mCase = string
    }
    override fun setCpu(string: String) {
        mCpu = string
    }
    override fun toString(): String {
        return "MoonComputer:\n處理器：$mCpu\n主機板：$mMainBoard\n記憶體：$mMemory\n硬碟：$mDisk\n散熱：$mRadiator\n顯示卡：$mGraphicsCard\n電源：$mPower\n機箱：$mCase"
    }
}

抽象建造者Builder類

package DesignPattern.builderPattern_conputer

abstract class Builder {
    abstract fun buildCpu(str:String):Builder
    abstract fun buildRadiator(str:String):Builder
    abstract fun buildMainBoard(str:String):Builder
    abstract fun buildMemory(str:String):Builder
    abstract fun buildGraphicsCard(str:String):Builder
    abstract fun buildPower(str:String):Builder
    abstract fun buildDisk(str:String):Builder
    abstract fun buildCase(str:String):Builder
    abstract fun create():Computer
}

具體建造者MoonBuilder類

package DesignPattern.builderPattern_conputer

class MoonBuilder : Builder() {
    private var mMoonConputer = MoonConputer()
    override fun buildCpu(str: String):MoonBuilder {
        mMoonConputer.setCpu(str)
        return this
    }
    override fun buildRadiator(str: String):MoonBuilder {
        mMoonConputer.setRadiator(str)
        return this
    }
    override fun buildMainBoard(str: String):MoonBuilder {
        mMoonConputer.setMainBoard(str)
        return this
    }
    override fun buildMemory(str: String):MoonBuilder {
        mMoonConputer.setMemory(str)
        return this
    }
    override fun buildGraphicsCard(str: String):MoonBuilder {
        mMoonConputer.setGraphicsCard(str)
        return this
    }
    override fun buildPower(str: String):MoonBuilder {
        mMoonConputer.setPower(str)
        return this
    }
    override fun buildDisk(str: String):MoonBuilder {
        mMoonConputer.setDisk(str)
        return this
    }
    override fun buildCase(str: String):MoonBuilder {
        mMoonConputer.setCase(str)
        return this
    }
    override fun create(): Computer {
        return mMoonConputer
    }
}

指揮者Director類

package DesignPattern.builderPattern_conputer

class Director constructor(builder: Builder) {
    var mBulder: Builder? = null
    init {
        mBulder = builder
    }
    fun construct(cpu: String,radiator:String,mainBoard:String,
                  memory: String,graphicsCard:String,power:String,
                  disk: String,case:String) {
        val computer = mBulder
                ?.buildCpu(cpu)
                ?.buildRadiator(radiator)
                ?.buildMainBoard(mainBoard)
                ?.buildMemory(memory)
                ?.buildGraphicsCard(graphicsCard)
                ?.buildPower(power)
                ?.buildDisk(disk)
                ?.buildCase(case)
    }
}

Main

在實際工作中，Director一般被忽略掉，直接使用Builder來進行物件的建造

package DesignPattern.builderPattern_conputer

fun main() {
    val moonBuilder = MoonBuilder()
    val mDirector = Director(moonBuilder)
    mDirector.construct(
            "i5-10400F",
            "雅浚 Basic3 A-RGB",
            "微星 B460M PRO",
            "金泰克 驍帥 長鑫 DDR4 2666 8G*2",
            "電競叛客 GTX1660Super 6G",
            "酷冷至尊 GX650（額定650W/直出/全日系）",
            "長江儲備 致鈦 PC005 500G M.2 NVME",
            "一個好看的鞋盒"
            )
    println(moonBuilder.create().toString())
}

控制檯輸出

MoonComputer:
處理器：i5-10400F
主機板：微星 B460M PRO
記憶體：金泰克 驍帥 長鑫 DDR4 2666 8G*2
硬碟：長江儲備 致鈦 PC005 500G M.2 NVME
散熱：雅浚 Basic3 A-RGB
顯示卡：電競叛客 GTX1660Super 6G
電源：酷冷至尊 GX650（額定650W/直出/全日系）
機箱：一個好看的鞋盒