Effective Java之多个构造参数考虑用构建器(二)_xmltransient 注释位于两个位置; 有一个位置就足够。-CSDN博客

本文链接：https://blog.csdn.net/qq_33394088/article/details/78781295

静态工厂方法和构造器都有一个共同的特点–>无法扩展到大量的参数。

对于大量的参数类，我们有以下方案：
1.重叠构造器。这个源码中经常可以看到，例如HashMap：

 public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }

也就是说每个HashMap调用的其实都是含有全部参数的构造器public HashMap(int initialCapacity, float loadFactor)

这种重叠构造器的方法在参数较少的时候，是一种不错的选择，可以参数多了的话呢？
参数顺序容易混淆吧？每个参数的意义容易难看懂吧？冗余的代码写得太多了吧？

于是方案二出现了
2.javaBean模式
就是把这个类声明成javabean，只需要调用他的无参构造方法，set，set，set就好了。
这样就避免了很多重叠构造器的问题

但是问题是，set，set，set的连续使用让javabean的构造过程分开来了，让javabean处于不一致的状态（状态就是javabean的属性集合，相邻两个set方法过后的javabean属性不一样，也就是状态不一致），因此，有些不小心的程序员，在set，set，set方法之间使用了javabean，因此可能会导致错误。

有没有更好的方案呢？

3.builder设计模式
以下是一个例子
public class User {

    private final String firstName;   // 必传参数
    private final String lastName;    // 必传参数
    private final int age;            // 可选参数
    private final String phone;       // 可选参数
    private final String address;     // 可选参数

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getPhone() {
        return phone;
    }

    public String getAddress() {
        return address;
    }

    public static class UserBuilder {
        private final String firstName;
        private final String lastName;
        private int age;
        private String phone;
        private String address;

        public UserBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }

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

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

*User*类的构造方法是私有的。也就是说调用者不能直接创建User对象。
*User*类的属性都是不可变的。所有的属性都添加了final修饰符，因此User是不可变的，并且在构造方法中设置了值。并且，对外只提供getters方法。
Builder模式使用了链式调用。可读性更佳。
Builder的内部类构造方法中只接收必传的参数，并且该必传的参数适用了final修饰符，可选参数没有final修饰符，因此可以用此builder修改。

调用builder构建User：

new User.UserBuilder("王", "小二")
                .age(20)
                .phone("123456789")
                .address("亚特兰蒂斯大陆")
                .build();