初试建造者模式

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

使用场景：当一个类的构造参数个数超过4个，而且这些参数有些是可选参数，考虑使用构造者模式。

以User类为例：参数为

public class User{
//这里的final是因为静态内部类访问外部类属性需要是final的
private final Integer id;
private final  String name;
private final Integer age;
private final String email;
}

1. 在User类中创建一个静态内部类Builder，将外部类的属性拿进Builder类中

public static class Builder{
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    }

2. 在外部类User中创建一个private的构造函数，参数为builder类型

private User(Builder builder){
    this.id = builder.id;
    this.name = builder.name;
    this.age = builder.age;
    this.email = builder.email;
}

3. 若外部类User有创建时必须要传进的值便可在内部类builder中创建一个构造函数，参数必须要填写的参数。

//在Builder中创建一个public的构造器，参数为外部类中的那些参数
//        public Builder(Integer id,String name,Integer age,String email){
//            this.id = id;
//            this.name = name;
//            this.age =age;
//            this.email = email;
//        }

4. 在Builder中创建那些可选参数的set方法，并对其进行赋值，返回为builder类型的实例

public Builder setId(Integer id){
    this.id = id;
    return this;
}
public Builder setName(String name){
    this.name = name;
    return this;
}
public Builder setAge(Integer age){
    this.age = age;
    return this;
}
public Builder setEmail(String email){
    this.email = email;
    return this;
}
public User build(){
    return new User(this);
}

5.在Bulider中创建build（）方法，其中构建User对象并返回

public User build(){
    return new User(this);
}

这样一个简单的构造者模式实现了，试一下。这里的链式调用可以参考StringBuffer的append（）方法

@Test
public void test1(){
    User user =new User.Builder()
            .setId(1)
            .setAge(19)
            .setName("xuqihang")
            .setEmail("2345")
            .build();
    System.out.println(user);
}