十五、建造者模式Builder（创建型模式）

通过一个例子来引出Builder模式。假设有一个Person类，我们通过该Person类来构建一大批人，这个Person类里有很多 属性，最常见的比如name，age，weight，height等等，并且我们允许这些值不被设置，也就是允许为null，该类的定义如下。面是代码：

public class Person {
 private String name;
 private int age;
 private double height;
 private double weight;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public double getHeight() {
  return height;
 }
 public void setHeight(double height) {
  this.height = height;
 }
 public double getWeight() {
  return weight;
 }
 public void setWeight(double weight) {
  this.weight = weight;
 }
}

然后我们为了方便可能会定义一个构造方法。

public Person(String name, int age, double height, double weight) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

或许为了方便new对象，你还会定义一个空的构造方法:

public Person() {}

甚至有时候你很懒，只想传部分参数，你还会定义如下类似的构造方法。

public Person(String name) {
 this.name = name;
}
public Person(String name, int age) {
 this.name = name;
 this.age = age;
}
public Person(String name, int age, double height) {
 this.name = name;
 this.age = age;
 this.height = height;
}

于是你就可以这样创建各个需要的对象

Person p1=new Person();
Person p2=new Person("张三");
Person p3=new Person("李四",18);
Person p4=new Person("王五",21,180);
Person p5=new Person("赵六",17,170,65.4);

可以想象一下这样创建的坏处，最直观的就是四个参数的构造函数的最后面的两个参数到底是什么意思，可读性不怎么好，如果不点击看源码，鬼知道哪个是weight哪个是height。还有一个问题就是当有很多参数时，编写这个构造函数就会显得异常麻烦，这时候如果换一个角度，试试Builder模式，你会发现代码的可读性一下子就上去了。

我们给Person增加一个静态内部类Builder类，并修改Person类的构造函数，代码如下。

public class Person {
 private String name;
 private int age;
 private double height;
 private double weight;
 private Person(Builder builder){
  this.name=builder.name;
  this.age=builder.age;
  this.height=builder.height;
  this.weight=builder.weight;
 } 
public String getName(){
  return name;
 } 
public void setName(String name){
  this.name = name; 
} 
public int getAge(){
  return age;
 } 
public void setAge(int age){
  this.age = age;
 }
public double getHeight(){
  return height;
 } 
public void setHeight(double height){
  this.height = height;
 } 
public double getWeight() {
  return weight;
 } 
public void setWeight(double weight){
  this.weight = weight;
 } 
 
static class Builder{
  private String name;
  private int age;
  private double height;
  private double weight;
  public Builder name(String name){
   this.name=name;
   return this;
  }
  public Builder age(int age){
   this.age=age;
   return this;
  }
  public Builder height(double height){
   this.height=height;
   return this;
  }
  public Builder weight(double weight){
   this.weight=weight;
   return this;
  }
  public Person build(){
   return new Person(this);
  }
 }
}

从上面的代码中我们可以看到，我们在Builder类里定义了一份与Person类一模一样的变量，通过一系列的成员函数进行设置属性值，但是返回值都是this，也就是都是Builder对象，最后提供了一个build函数用于创建Person对象，返回的是Person对象，对应的构造函数在Person类中进行定义，也就是构造函数的入参是Builder对象，然后依次对自己的成员变量进行赋值，对应的值都是Builder对象中的值。此外Builder类中的成员函数返回Builder对象自身的另一个作用就是让它支持链式调用，使代码可读性大大增强。

于是我们就可以这样创建Person类。

Person.Builder builder=new Person.Builder();
Person person=builder
 .name("张三")
 .age(18)
 .height(178.5)
 .weight(67.4)
 .build();

有没有觉得创建过程一下子就变得那么清晰了。对应的值是什么属性一目了然，可读性大大增强。

最后总结一下

• 定义一个静态内部类Builder，内部的成员变量和外部类一样

• Builder类通过一系列的方法用于成员变量的赋值，并返回当前对象本身（this）

• Builder类提供一个build方法或者create方法用于创建对应的外部类，该方法内部调用了外部类的一个私有构造函数，该构造函数的参数就是内部类Builder

• 外部类提供一个私有构造函数供内部类调用，在该构造函数中完成成员变量的赋值，取值为Builder对象中对应的值

Builder模式和Factory模式之间区别：Builder和Factory之间的区别就是组装和生产之间的区别，Builder着重将组装和构件的生产分离，Factory着重于优化生产的过程。本文的代码实际上还可以进行重构，例如，在buildGlass()函数里面，用到了new这个关键字，实际上可以将这个new换成工厂类，让工厂类来生产Glass。换一种说法，就是Factory不进行组装，Builder进行组装，当Factory进行组装的时候，它就变成Builder了。