设计模式 Build 模式

Builder模式介绍

Builder模式是一步一步创建一个复杂对象的创建性模式，他允许用户在不知道内部构建细节的情况下，可以更加准确的控制对象的构造流程，该模式是为了将构建复杂对象过程和他的部件解耦使得构建过程和部件的表示隔离开来

Builder 模式的定义

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

Builder 模式的使用场景

(1）相同的方法，不同的执行顺序，产生不同事件结果时

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

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

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

根据上面图片，写一个简单代码

product角色
public abstract class ComPuter {

    private String mBoard;
    private String mDisplay;
    public String mOS;

    protected ComPuter() {

    }

    //主机
    public void setBoard(String board) {
        this.mBoard = board;
    }

    //显示器
    public void setDisplay(String display) {
        this.mDisplay = display;
    }

    //操作系统
    public abstract void setOS();

    @Override
    public String toString() {
        return "mboard=" + mBoard + "display=" + mDisplay + "OS=" + mOS;
    }
}

具体的product
public class MacBook extends ComPuter {

    public MacBook() {

    }

    @Override
    public void setOS() {
        mOS = "Mac OS";
    }
}

抽象Builder类
public abstract class Builder {

    //设置主机
    public abstract Builder buildBoard(String board);

    //设置显示器
    public abstract Builder buildDisplay(String display);

    //设置操作系统
    public abstract Builder buildOS();

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

}

具体builder类
public class MacBookBuilder extends Builder {
    private ComPuter mComPuter = new MacBook();

    @Override
    public Builder buildBoard(String board) {
        mComPuter.setBoard(board);
           return this;
    }

    @Override
    public Builder buildDisplay(String display) {
        mComPuter.setDisplay(display);
           return this;
    }

    @Override
    public Builder buildOS() {
        mComPuter.setOS();
           return this;
    }

    @Override
    public ComPuter create() {
        return mComPuter;
    }
}

具体构造类，负责构造Computer
public class Director {

    private 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 BuildActivity extends BaseActivity {

    @Override
    public int setMainView() {
        return R.layout.activity_build;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setToobarTitle("Build 模式");
        MacBookBuilder macBookBuilder = new MacBookBuilder();
        Director director = new Director(macBookBuilder);
        director.construct("因特尔主机", "三星显示屏");
        TextView textView = (TextView) findViewById(R.id.build_text);
        textView.setText(macBookBuilder.create().toString());
    }
}

最后屏幕打印出
mboard=因特尔主机display=三星显示屏OS=Mac OS

上述实例中，通过具体的MacbookBuilder来构建Macbook对象，而Director封装了构建复杂产品对象的过程，对外隐藏了构建细节。Builder与Director一起将一个复杂对象的构建与他的表示分离这样使得同样的构建过程可以构建不同的对象

值得注意的是，显示开发过程中，Director角色经常会被省略，而直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，他的关键点是每个setter方法都返回自身，也会是return this； 这样就使得setter方法可以链式调用，代码如下

public class BuildActivity extends BaseActivity {

    @Override
    public int setMainView() {
        return R.layout.activity_build;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setToobarTitle("Build 模式");
        //显示开发一般省去Director，用Builder进行链式调用

        ComPuter comPuter = new MacBookBuilder().buildOS()
                .buildDisplay("三星显示屏")
                .buildBoard("没有主机")
                .create();
        textView.setText(comPuter.toString());
    }
}

是不是很眼熟，对的系统的dialog创建设置也是这样做的。