构造者模式（Builder Pattern）主要用于复杂对象的构建，将一个复杂对象的构造过程和它的表现层分离开来。
直接撸个盖房子的例子。
这里三个类：
构建者例子用到的三个类
BuildingDesign：房屋设计图，包括一些房屋的属性，比如宽、高、颜色。
House：最后要创建出实例的类。
HouseBuilder：房屋构建者，可以理解为一个公司，或一群工人等等，总之用户通过这个类去构建House，而不是直接自己去创建House。
贴一下各类的实现：
/**
* 房屋设计图
*/
public class BuildingDesign {
private double width;
private int height;
private String color;
public BuildingDesign() {
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
/**
* 大House
*/
public class House {
private double width;
private int height;
private String color;
public House(BuildingDesign design) {
this.width = design.getWidth();
this.height = design.getHeight();
this.color = design.getColor();
}
@Override
public String toString() {
return "House{" +
"width=" + width +
", height=" + height +
", color='" + color + '\'' +
'}';
}
}
/**
* 构建者
*/
public class HouseBuilder {
private BuildingDesign buildingDesign;
public HouseBuilder() {
buildingDesign = new BuildingDesign();
}
public void setWidth(double width) {
this.buildingDesign.setWidth(width);
}
public void setHeight(int height) {
this.buildingDesign.setHeight(10);
}
public void setColor(String color) {
this.buildingDesign.setColor(color);
}
public House build() {
if (buildingDesign == null){
return null;
}else {
return new House(buildingDesign);
}
}
}
使用：
public class Main {
public static void main(String[] args) {
HouseBuilder builder = new HouseBuilder();
builder.setWidth(130.00);
builder.setHeight(3);
builder.setColor("红色");
House house = builder.build();
System.out.println(house);
}
}
运行结果：
House{width=130.0, height=10, color='红色'}
这样就完成了构建者模式，这里的好处：
- 在调用
builder.build();之前，随便房屋属性并不会造成资源浪费，因为都是在new对象之前。 - 屏蔽了房屋创建的复杂过程，这一点代码里没体现出来，房屋的构造过程可能是很复杂的，但用户只提供了宽、高、颜色，又或者是用户根本没有要求颜色，所以设计图里，也就是
BuildingDesign里要提供默认值，所以代码修改这样：
/**
* 房屋设计图
*/
public class BuildingDesign {
private double width = 2;
private int height = 100;
private String color = "白色";
...
}
这样即使使用者不指定某些属性，也会用默认的创建出来，比如一些复杂的属性，用户可能大多数不需要设置，但是用户想设置的时候必须可以设置。
为什么跟看到的一些构建者不一样？比如OkHttp里的OkHttpClient和Request的创建。
那些只是使用了链式的表达方式，这里简单数一下链式的思想，按上面的代码：
HouseBuilder builder = new HouseBuilder();
builder.setWidth(130.00);
builder.setHeight(3);
builder.setColor("红色");
builder.build();
比如builder是个包工头，对应上面5行代码描述起来是这样的：
1.“包工头，过来一下”
2.“包工头，我的房子要宽130”
3.“包工头，我的房子要高3层”
4.“包工头，我的房子要红色”
5.“包工头，开始盖吧”
链式的书写方式是这样的：
new HouseBuilder().setWidth(130.00).setHeight(3).setColor("红色").build();
这意思就行，你把包工头喊过来之后，他回说：“在你交代完成之前，我一直在，你不需要喊我，直接说你的需求”，描述起来：
“包工头，过来一下，我的房子要宽130，高3层，红色，开始盖吧”
实现这种书写方式也很简单，设置完属性把自己返回回去就好了，修改HouseBuilder的setter方法:
/**
* 构建者
*/
public class HouseBuilder {
...
public HouseBuilder setWidth(double width) {
this.buildingDesign.setWidth(width);
return this;
}
public HouseBuilder setHeight(int height) {
this.buildingDesign.setHeight(10);
return this;
}
public HouseBuilder setColor(String color) {
this.buildingDesign.setColor(color);
return this;
}
...
}
代码完成，一般还会把Builder设置成内部类，都一个意思，随便怎么搞。
非常的丝滑：
System.out.println( new HouseBuilder().setWidth(130.00).setHeight(3).setColor("红色").build());
System.out.println( new HouseBuilder().setHeight(3).setColor("红色").build());
System.out.println( new HouseBuilder().setColor("红色").build());
System.out.println( new HouseBuilder().build());
House{width=130.0, height=10, color='红色'}
House{width=2.0, height=10, color='红色'}
House{width=2.0, height=100, color='红色'}
House{width=2.0, height=100, color='白色'}
随便设置什么属性，或者不设置，盖住来的房子都可以住。
