什么是建造者模式

builder模式是可以实现将不同的方法按不同顺序执行而得到不同的复杂实例的设计模式。

应用场景

在我们某些开发中，需要的参数可能会很多，比如生成一篇文章时，你需要传入参数有标题、内容、结尾。那么如果一个文章的构建方法里有三个参数，你必须将参数按顺序传入，如果捣乱了顺序，就算编译过程不出错但在生成的结果可能会出乎我们所料。

那么，我们该怎么使用Builer模式进行设计呢。

1）表示分离

将需要生成的各部分表示分离开，在展示的时候将参数放入后以不同的顺序堆叠。

下例中，生成文档中含有一个标记，几个项目，项目中有几个项。

类名	作用
Builder	定义了文档结构的方法的抽象类
TextBuilder	继承并重写了文档结构的方法
Director	监工者，安排了编写文档的顺序
Builder_main	测试程序

在程序中，Builder类定义了具体需要的哪几种方法，创建标题，项目，项目中的项。监工类决定了方法的执行顺序。

public abstract class Builder {
    public abstract void makeTitle(String title);
    public abstract void makeString(String str);
    public abstract void makeItems(String []items);
    public abstract void close();
}

public class TextBuilder extends Builder {
    private StringBuilder buffer = new StringBuilder();
    @Override
    public void makeTitle(String title) {
        buffer.append("================================\n");
        buffer.append("[" + title + "]");
        buffer.append("\n");
    }
    @Override
    public void makeString(String str) {
        buffer.append('·' +str + "\n");
        buffer.append("\n");
    }
    @Override
    public void makeItems(String[] items) {
        for (int i = 0; i < items.length; i++) {
            buffer.append("     -" + items[i] + "\n");
        }
        buffer.append("\n");
    }
    @Override
    public void close() {
        buffer.append("================================\n");
    }
    public String getResult(){
        return buffer.toString();
    }
}

public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public void construct(){
        builder.makeTitle("Greeting");
        builder.makeString("从早上到下午 ");
        builder.makeItems(new String[]{
                "早上好。",
                "下午好。",
        });
        builder.makeString("晚上");
        builder.makeItems(new String[]{
                "晚上好。",
                "晚安。",
                "再见。",
        });
        builder.close();
    }
}

public class Builder_main {
    public static void main(String [] args){
            TextBuilder textBuilder = new TextBuilder();
            Director director = new Director(textBuilder);
            director.construct();
            String result = textBuilder.getResult();
            System.out.println(result);
    }
}

运行结果

2）构造分离

将构造方法分离，如果你需要很多的参数引入，那么你可以使用链式的构造参数

下例中，统计某个人的姓名，年龄，性别，爱好。

public class People {
    private String name;
    private int age;
    private String sex;
    private String [] hobby;
    public People name(String name){
        this.name = name;
        return this;
    }
    public People age(int age){
        this.age = age;
        return this;
    }
    public People sex(String sex){
        this.sex = sex;
        return this;
    }
    public People hobby(String []hobby) {
        this.hobby = hobby;
        return this;
    }
    @Override
    public String toString() {
        String str =  "名字：" + name +
                "\n性别：" + sex +
                "\n年龄：" + age +
                "\n爱好：";
        for (String s : hobby) {
            str += s + " ";
        }
        return str;
    }
}

public class Builder_main2 {
    public static void main(String []args){
        People builder2 = new People()
                .name("汤姆")
                .age(18)
                .sex("男")
                .hobby(new String[]{"唱","跳","rap"});
        System.out.println(builder2.toString());
    }
}

上程序就使用了Builder设计模式，使传入的参数可以按链式不严格按照传入顺序来创建实例。