《Effective Java》第2条：遇到多个构造器参数时要考虑用构建器

原文地址： https://itweknow.cn/detail?id=47 , 欢迎大家访问。

我们构建一个对象的几种方式

• 构造器
• 静态工厂方法
• 构建器
  在书中提到了当我们遇到了大量的可选参数时，获取对象实例的几种方式（重叠构造方法，无参构造器配合JavaBean的setter方法，构建器），书中也分别列出了使用这几种方式的优劣之处。

重叠构造器

我们这里也以一个实际的例子入手，我们当前有一个用户类如下：

public class UserConstruct {

    /**
     * id
     */
    private Long id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 身份证号
     */
    private String idNumber;

    /**
     * 地址
     */
    private String address;

    /**
     * 信息是否完整
     * true : name,idNumber,address必须都有的情况下
     * false : 上述属性有一个或多个为空
     */
    private boolean infoIsComplete;

    public UserConstruct(Long id, String name) {
        this(id, name, null, null);
    }

    public UserConstruct(Long id, String name, String idNumber) {
        this(id, name, idNumber, null);
    }

    public UserConstruct(Long id, String name, String idNumber, String address) {
        this.id = id;
        this.name = name;
        this.idNumber = idNumber;
        this.address = address;
        if (null != id && null != name 
                && null != idNumber && null != address) {
            this.infoIsComplete = true;
        }
    }
}

例子中的UserConstruct.java类共有5个成员变量，其中id,name,infoIsComplete是必选成员变量且infoIsComplete不是通过用户设置的，而是根据对象实际的属性设值情况进行赋值的。而idNumber,address则是两个可选变量。
当我们需要创建一个拥有地址而没有身份证号码的对象时，我们会这么写：

UserConstruct user = new UserConstruct(1L, "张三", null, "上海市");

你可能会想这么看起来并没有什么问题啊，但是如果当我们的可选参数不是两个而是50个的时候，构造器的参数会多么的复杂难读，而且稍有不慎就会出现参数顺序错乱的错误进而导致整个程序运行出错。
**也就是说，在可选参数的数量多的情况下，虽然重叠构造器可行，但是会有诸如难读易出错的问题出现。**所以不建议使用。

JavaBean的方式

在此模式下，我们通常都是通过调用一个无参构造器来构建对象，然后通过调用setter方法来设置每个必要参数，以及每个相关的可选参数。我们的用户类变成了这样：

public class UserJavaBean {

    /**
     * id
     */
    private Long id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 身份证号
     */
    private String idNumber;

    /**
     * 地址
     */
    private String address;

    /**
     * 信息是否完整
     * true : name,idNumber,address必须都有的情况下
     * false : 上述属性有一个或多个为空
     */
    private boolean infoIsComplete;


    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setIdNumber(String idNumber) {
        this.idNumber = idNumber;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void setInfoIsComplete(boolean infoIsComplete) {
        this.infoIsComplete = infoIsComplete;
    }
}

那么在JavaBean模式下我们初始化一个重叠构造器中例子就变成了下面这样：

UserJavaBean user = new UserJavaBean();
user.setId(1L);
user.setName("张三");
user.setAddress("上海市");
user.setInfoIsComplete(false);

这样确实代码的可读性变强了，但是也有那么几个缺点：

• 无法保证必要参数
  这种方式我们没办法保证所有的必要参数都如我们所愿地被赋上了值，当然了这个缺点还有弥补的方案，就是我们通过调用一个包含所有必要参数的构造器来获取一个对象，而只通过setter方法来设置相关的可选参数。
• 构造过程中JavaBean可能会处于不一致的状态
  对于这一点书中的描述有点晦涩难懂，不知道是否是翻译的问题。一个例子是infoIsComplete这个字段必须在所有的属性都被赋值后才为true，这样通过JavaBean的方式我们也没有很好的方式来通过代码的方式自动为其赋值。
  还有一点就是，如果idNumber和address两个两个可选参数必须同时存在的时候，使用JavaBean也是有点力不从心了。
• JavaBean模式阻止了把类变成不可变的可能
  一旦我们使用了JavaBean模式，则表明我们会为类的每个属性都编写一个共有的setter方法，也就说明我们的类无法成为一个不可变类。

构建器

根据书中的描述，构建器既能保证像重叠构造器那样的安全性，也可以有JavaBean模式那样的可读性。

public class UserBuilder {

    /**
     * id
     */
    private Long id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 身份证号
     */
    private String idNumber;

    /**
     * 地址
     */
    private String address;

    /**
     * 信息是否完整
     * true : name,idNumber,address必须都有的情况下
     * false : 上述属性有一个或多个为空
     */
    private boolean infoIsComplete;

    /**
     * 构建器
     */
    public static class Builder {
        // 必传参数
        private Long id;
        private String name;
        // 可选参数
        private String idNumber;
        private String address;

        public Builder(Long id, String name) {
            this.id = id;
            this.name = name;
        }

        public Builder idNumber(String idNumber) {
            this.idNumber = idNumber;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

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


    private UserBuilder(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.idNumber = builder.idNumber;
        this.address = builder.address;
        // 根据参数赋值情况，给infoIsComplete赋值
        if (this.id != null && this.name!= null
                && this.idNumber!= null && this.address != null) {
            this.infoIsComplete = true;
        }
    }
}

还是上面的例子，我们就可以改写为：

UserBuilder user = new Builder(1L, "张三").address("上海市").build();

是不是同样的易读，而且我们还可以在UserBuilder的构造器中进行参数的验证，并且可以顺利的给infoIsComplete属性自动赋值。
构建器有下面几个优点：

• 可以和构造器一样对参数强加约束条件，比如idNumber和address必须同时存在。
• 可以拥有多个可变参数
• 十分灵活，可以通过单个Builder构建多个对象，也可在构建对象时对参数进行调整。

当然了，构建器也有不足的地方，为了创建一个对象，我们首先必须创建一个它的构建器对象，这可能在一定程度上会消耗我们的内存。所以在一些比较注重性能的情况下构建器就不那么好使了。但是在极大多数的情况下，建议我们在还是在***当前或者未来参数数量比较大的类中使用构建器。***