Builder建造者模式——学习笔记

先上代码：

abstract class ComputerKotlin{
    protected var mBoard:String=""//核心数
    protected var mDisplay:String=""//内存
    protected var mOs:String=""//操作系统
    fun setBoard(board:String){
        this.mBoard=board
    }
    fun setDisplay(display:String){
        this.mDisplay=display
    }
    abstract fun setOs()
    override fun toString(): String {
        return "ComputerKotlin(mBoard='$mBoard', mDisplay='$mDisplay', mOs='$mOs')"
    }
}

class MacBookKotlin: ComputerKotlin() {
    override fun setOs() {
       mOs="Mac OS　X 10.10"
    }
}

abstract class BuilderKotlin{
    public abstract fun buildBoard(board:String)
    public abstract fun buildDisplay(display:String)
    public abstract fun buildOs()
    public abstract fun create(): ComputerKotlin
}

class MacBookBuilderKotlin: BuilderKotlin() {
    private var computer=MacBookKotlin()

    override fun buildBoard(board: String) {
        computer.setBoard(board)
    }

    override fun buildDisplay(display: String) {
        computer.setDisplay(display)
    }

    override fun buildOs() {
        computer.setOs()
    }

    override fun create(): ComputerKotlin {
        return computer
    }
}

最近在学习kotlin，所以代码是用kotlin编辑的，如果看不懂，看下面：

public abstract class Computer {
    protected String mBoard;//核心数
    protected String mDisplay;//内存
    protected String mOs;//操作系统

    public void setmBoard(String mBoard) {
        this.mBoard = mBoard;
    }

    public void setmDisplay(String mDisplay) {
        this.mDisplay = mDisplay;
    }

    public abstract void setmOs();
}

public class MacBook extends Computer{
    protected MacBook() {
    }
    @Override
    public void setmOs() {
        mOs="Mac OS　X 10.10";
    }
}

public abstract class Builder {
    public abstract void buildBoard(String board);
    public abstract void buildDisplay(String display);
    public abstract void buildOs();
    public abstract Computer create();
}

public class MacBookBuilder extends Builder{
    private Computer computer=new MacBook();
    @Override
    public void buildBoard(String board) {
        computer.setmBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        computer.setmDisplay(display);
    }

    @Override
    public void buildOs() {
        computer.setmOs();
    }

    @Override
    public Computer create() {
        return computer;
    }
}

看完这段代码，对所谓的建造者模式应该有了大致的看法，下面来详细学习下：

定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

使用场景

1.相同的场景，不同的执行顺序，可以产生不同的结果。

2.多个部位或零件，都可以装配到一个对象中，但是产生的运行结果又不同时；

3.产品类非常复杂，或者产品类中不同的调用顺序可以产生不同的作用，这个时候使用建造者模式非常合适；

4.当初始化一个对象非常复杂，如参数多，且很多参数都有默认值时。

总结

只看这段代码和说明，如果还不明白，就想想自己经常用到的alertDialog的使用方法，理解建造者模式就会简单很多。