第2条 遇到过个构造器参数时要考虑使用构造器

当一个类的域很多的时候，一般会采用以下的方法创建类

1. 重叠构造器方式
一般创建构造器会使用重叠构造器的方式，即首先创建一个只有必要参数的构造器，然后第二个构造器有一个可选参数，第三个构造器有两个可选参数，依此类推，最后一个构造器包含所有的可选参数。

public class Person { 
    private final String name; 
    private final int age; 
     
    private final String address; 
    private final String phone; 
     
    public Person(String name, int age) { 
        this(name,age,null); 
    } 
     
 
    public Person(String name, int age, String address) { 
        this(name,age,address,null); 
    } 
 
    public Person(String name, int age, String address, String phone) { 
        super(); 
        this.name = name; 
        this.age = age; 
        this.address = address; 
        this.phone = phone; 
    } 
     
    @Override 
    public String toString() { 
        return "name:"+name+" age:"+age+" address:"+address+" phone:"+phone; 
    } 
     
} 

这种方法虽然可行，但是客户端代码编写起来十分麻烦，因为需要十分小心的辨别每个参数。

2. JavaBeans方式
这种模式下，调用一个无参的构造器来创建对象，然后用setter方法去设置每个必要的参数，以及每个相关的可选参数。

public class Person { 
    private String name; 
    private int age; 
     
    private String address; 
    private String phone; 
     
    public void setName(String name) { 
        this.name = name; 
    } 
    public void setAge(int age) { 
        this.age = age; 
    } 
    public void setAddress(String address) { 
        this.address = address; 
    } 
    public void setPhone(String phone) { 
        this.phone = phone; 
    } 
     
    @Override 
    public String toString() { 
        return "name:"+name+" age:"+age+" address:"+address+" phone:"+phone; 
    } 
     
} 

这种方式比重叠构造器方式创建实例更加容易，可读性也更高
但是缺点就在于因为构造过程被分到了几个调用中，所以无法保证一致性，阻止了把类做成不可变的可能，需要程序员付出额外的努力来确保线程安全。

3. Builder方式
如何既能做到像重叠构造器方式保证数据的一致性，又能有JavaBeans方式的可读性呢，第三种替代方式：Builder方式可以做到

不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器，得到一个Builder对象。
然后客户端在Builder对象上调用setter方法，来设置每个相关的可选参数。
最后调用Builder无参的build方法来生成不可变的对象。

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int fat;
    private final int sodium;

    public static class Builder {
        //Required parameters
        private final int servingSize;
        private final int servings;
        //Optional parameters
        private int fat = 0;
        private int sodium = 0;

        public Builder (int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder fat(int fat) {
            this.fat = fat;
            return this;
        }

        public Builder sodium(int sodium) {
            this.sodium = sodium;
            return this;
        }

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

    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        fat = builder.fat;
        sodium = builder.sodium;
    }
}

客户端可以这样调用：

public static void main(String[] args) {
        NutritionFacts nutritionFacts = new NutritionFacts.Builder(230, 9)
                .fat(100)
                .sodium(35)
                .build();
    }

这样的客户端代码很容易编写，易于阅读。

builder就像一个构造器一样，但是更胜于构造器，因为builder可以有多个可变参数，builder可以利用独立的方法来设置每个参数，所以想要多少个参数，就可以设置多少个参数
但是Builder模式也有他的不足，比如性能以及代码的复杂程度，所以在有很多个参数时，特别是可选参数很多的情况下才使用较好