Builder 模式

Builder模式

1、定义：

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

我的理解：就是将一个复杂的对象，拆分成一个个零件，由零件来拼凑出这个对象。即：建造者模式。

2、Builder模式的简单实现：

/**
 * 把电脑当做一个复杂对象，将它的组成部分分离。
 * 
 * 所以 电脑是一个抽象的对象，不能具体实现  由子类具体实现
 *
 */
public abstract class Computer {

    protected String mBoard;    //主板
    protected String mDisplay;  //内存
    protected String mOs;       //系统

    protected Computer(){}

    //设置CPU核心数
    public void setBoard(String board){
        mBoard = board;
    }

    //设置内存
    public void setDisplay(String display){
        mDisplay = display;
    }


    //设置操作系统
    public abstract void setOs();

    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOs='" + mOs + '\'' +
                '}';
    }
}

/**
 * 电脑的子类Macbook，可以具体实现一个电脑对象
 * 
 */
public class Macbook extends Computer {

    protected Macbook(){}

    @Override
    public void setOs() {
        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();

    //创建Computer
    public abstract Computer create();


    //构造对象
    public Builder construct(String board, String display){
        buildBoard(board);
        buildDisplay(display);
        buildOS();
        return this;
    }
}

/**
 * Builder类的实现
 * 将电脑的各部分信息具体实现出来
 */
public class MacbookBuilder extends Builder {

    //将对象具体实例化(多态)
    private Computer mComputer = new Macbook();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }

    @Override
    public void buildOS() {
        mComputer.setOs();
    }

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

    @Override
    public Builder construct(String board, String display) {
        return super.construct(board, display);
    }
}

//负责构造Computer
public class Director {

    Builder mBuilder = null;

    public Director(Builder builder){
        mBuilder = builder;
    }

    //构造对象
    public void construct(String board, String display){
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

//测试代码
public class Test {
    public static void main(String[] args){
        //构造器
        Builder builder = new MacbookBuilder();
        //Director
        Director pcDirector = new Director(builder);
        //封装构建过程
        pcDirector.construct("英特尔主板","Retina显示器");
        //构建计算机，输出相关信息
        System.out.print("Computer Info : " + builder.create().toString());
    }
}

---

以下是个人理解，模仿实现：

• 电脑的构造类，里面有一个builder静态内部类，私有化ComputerBuilder 的构造方法，使得外部只能通过builder来拿到
• ComputerBuilder 对象。 builder与ComputerBuilder 具有相同属性，并且builder每次return的都是this。
• 将拿到的属性赋值给ComputerBuilder ，实现ComputerBuilder构造。

/**
 * 电脑的建造类
 *
 */
public class ComputerBuilder {

    protected String mBoard;
    protected String mDisplay;

    private ComputerBuilder(){}


    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                '}';
    }



    public static final class Builder {
        private String mBoard;
        private String mDisplay;

        private void applyConfig(ComputerBuilder computerBuilder){
            computerBuilder.mBoard = this.mBoard;
            computerBuilder.mDisplay = this.mDisplay;
        }


        //设置主机
        public Builder setBuildBoard(String board){
            mBoard = board;
            return this;
        }

        //设置显示器
        public Builder buildDisplay(String display){
            mDisplay = display;
            return this;
        }


        //创建Computer
        public ComputerBuilder create(){
            ComputerBuilder computerBuilder = new ComputerBuilder();
            applyConfig(computerBuilder);
            return computerBuilder;
        }
    }

}

public class Test {
    public static void main(String[] args){
        ComputerBuilder computerBuilder = new ComputerBuilder
                .Builder()
                .setBuildBoard("aaa")
                .buildDisplay("bbb")
                .create();
        System.out.print("Computer Info : " + computerBuilder.toString());
    }
}