设计模式之建造者模式（代码使用Kotlin）

介绍

先来说一遍官话

是一种一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构件细节的情况下，更加精细地控制及对象的构造流程。
它可以将构建复杂对象的流程与它的部件分离，使构建过程与部件都可以自由扩展，降低两者间的耦合性。

再来结合实际例子

装一台电脑主机需要主板，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/直出/全日系）
机箱：一个好看的鞋盒