在构建一些结构复杂的物体，比如建造一个大楼，没法一气呵成，只能先打牢地基，搭建框架，然后一层一层地盖；因此需要先构建组成这个物体的各个部分，然后分阶段给组装起来
如果需要将一个复杂对象的构建和表示分离，使得同样的构建过程可以创建不同的表示的意图时，可以使用Builder构建模式，也叫生成器模式；用Builder模式，用户只需要指定需要构建的类型就可以得到它们，而具体构建的过程和细节就不需要知道了
来一个示例，通过Builder模式编写一个文档，包括一个文档标题，字符串，和若干条目
定义的类如下
Builder：定义了决定文档结构的方法的抽象类
Director：编写一个文档类，用Builder的方法编写一个具体的类
TextBuilder：使用纯文本，字符串来编写文档
HTMLBuilder：使用HTML编写文档
Main：main，测试类
Builder抽象类，不做任何实际处理，由子类实现具体处理
首先是Builder类，声明编写文档的抽象类，定义makeTitle，makeString，makeTimes抽象方法编写标题，字符串和条目，close方法最终完成文档编写
package builder;
/**
* Copyright (C), 2014-2018, maoxiaomeng.com
* FileName: Builder
* Author: lihui
* Date: 2018/5/3 16:14
*/
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();
}
接着是Director类，主要是用Builder抽象类里声明的方法来编写文档
Director类的构造函数的参数传入的是Builder类型，但是肯定不是Builder类的实例，因为Builder是抽象类无法实例化，传入的是Builder类的子类的实例，而这些Builder类的子类决定了编写出的文档的形式
construct方法是编写文档的方法；调用该方法就会编写文档；该方法会用到Builder类中声明的方法阿莱构建
package builder;
/**
* Copyright (C), 2014-2018, maoxiaomeng.com
* FileName: Director
* Author: lihui
* Date: 2018/5/3 16:37
*/
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();
}
}
接着是TextBuilder类，继承了Builder类，功能是使用纯文本编写文档，以String返回结果
package builder;
/**
* Copyright (C), 2014-2018, maoxiaomeng.com
* FileName: TextBuilder
* Author: lihui
* Date: 2018/5/3 16:19
*/
public class TextBuilder extends Builder {
private StringBuilder buffer = new StringBuilder();
public void makeTitle(String title) {
buffer.append("======================================\n");
buffer.append("<<" + title + ">>\n");
buffer.append("\n");
}
public void makeString(String str) {
buffer.append('#' + str + '\n');
buffer.append("\n");
}
public void makeItems(String[] items) {
for (int i = 0; i < items.length; i++) {
buffer.append(" *" + items[i] + "\n");
}
buffer.append("\n");
}
public void close() {
buffer.append("======================================\n");
}
public String getResult() {
return buffer.toString();
}
}
还有一个HTMLBuilder类，也是Builder类的子类，功能是使用HTML编写文档，返回HTML文件的名字
package builder;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* Copyright (C), 2014-2018, maoxiaomeng.com
* FileName: HTMLBuilder
* Author: lihui
* Date: 2018/5/3 16:26
*/
public class HTMLBuilder extends Builder {
private String filename;
private PrintWriter writer;
public void makeTitle(String title) {
filename = title + ".html";
try {
writer = new PrintWriter(new FileWriter(filename));
} catch (IOException e) {
e.printStackTrace();
}
writer.println("<html><head><title>" + title + "</title></head><body>");
writer.println("<h1>" + title + "</h1>");
}
public void makeString(String str) {
writer.println("<p>" + str + "</p>");
}
public void makeItems(String[] items) {
writer.println("<ul>");
for (int i = 0; i < items.length; i++) {
writer.println("<li>" + items[i] + "</li>");
}
writer.println("</ul>");
}
public void close() {
writer.println("</body></html>");
writer.close();
}
public String getResult() {
return filename;
}
}
最后是main
当命令行参数传入plain时，会将TextBuilder类的实例作为参数传递到Director类的构造函数中；如果是html就穿HTMLBuilder类的实例
因此必须在Builder中声明足够多的方法，以实现编写文档的功能，但并不包括TextBuilder和HTMLBuilder中特有的方法
package builder;
/**
* Copyright (C), 2014-2018, maoxiaomeng.com
* FileName: Main
* Author: lihui
* Date: 2018/5/3 16:31
*/
public class Main {
public static void main(String[] args) {
if (args.length != 1) {
usage();
System.exit(0);
}
if (args[0].equals("plain")) {
TextBuilder textBuilder = new TextBuilder();
Director director = new Director(textBuilder);
director.construct();
String result = textBuilder.getResult();
System.out.println(result);
} else if (args[0].equals("html")) {
HTMLBuilder htmlBuilder = new HTMLBuilder();
Director director = new Director(htmlBuilder);
director.construct();
String filename = htmlBuilder.getResult();
System.out.println(filename + " 文件编写完成 ");
} else {
usage();
System.exit(0);
}
}
public static void usage() {
System.out.println("Usage: java Main plain 编写纯文本文档");
System.out.println("Usage: java Main html 编写HTML文档");
}
}
Builder模式的角色：
Builder：构造者，例子中的Builder类；负责定义用于生成实例的接口API方法
ConcreteBuilder：具体的构造者，例子中的TextBuilder类和HTMLBuilder类；负责实现Builder角色的接口的类
Director：监工，例子中的Director类；负责使用Builder角色的接口来生成实例，并不依赖ConcreteCreator角色；为了确保不论ConcreteCreator角色是如何被定义的，Director角色都能正常工作，它只调用在Builder角色中被定义的方法
Client：调用者，例子中的Main类；
流程思考：
整个Main里最关键的两行代码，一个是将子类对象传参到Director的构造函数里，赋给超类的引用；另一个就是调用construct方法，由于多态，而超类Builder正好是一个抽象类，必须被子类重写，因此调用的方法其实就是传入的子类对应的方法
下面内容重点理解：
这里Main类并不知道Builder类，也没有直接调用，它只是调用了Director类的construct方法，这样Director类就会开始工作完成文档的编写；而Director类是知道Builder类的，它调用Builder类的方法完成文档的编写，但是它并不知道它真正使用的是哪个Builder的子类，不过也没必要知道，因为Director类只使用了Builder类的方法，而Builder类的子类都已经实现了这些方法
Director类不知道自己使用的究竟是Builder类的哪个子类，这样也好，因为只有不知道子类才能替换，不论将TextBuilder的实例传递给Director，还是将HTMLBuilder类的实例传递给Director，它都可以正常工作，原因正是Director类不知道Builder类的具体子类
正是因为不知道才看可以替换，正是因为可以替换，组件才具有高价值，作为设计人员，时刻需要关注这种可替换性
