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

静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。

重叠构造器模式

实际开发中，一个类有多个属性，其中有几个属性是必需的，其它是可选项；可以采用重叠构造器模式。在这种模式下，提供第一个只有必要参数的构造器，第二个构造器有一个可选参数，第三个有两个可选参数，依此类推，最后一个构造器包含所有可选参数。具体实例如下：
NutritionFacts表示包装食品外面显示的营养成分标签，标签中，每份的含量、每罐的含量以及每份的卡路里都是必需的，其它的总脂肪量、转化脂肪、胆固醇、钠等等都是可选项。

public class NutritionFacts {
    //required
    private final int servingSize;
    //required
    private final int servings;
    //optional
    private final int calories;
    //optional
    private final int fat;
    //optional
    private final int sodium;
    //optional
    private final int carbohydrate;

    public NutritionFacts(int servingSize,int servings){
        this(servingSize,servingSize);
    }

    public NutritionFacts(int servingSize,int servings,int calories){
        this(servingSize,servings,calories);
    }

    public NutritionFacts(int servingSize,int servings,int calories,int fat){
        this(servingSize,servings,calories,fat);
    }

    public NutritionFacts(int servingSize,int servings,int calories,int fat,int sodium){
        this(servingSize,servings,calories,fat,sodium);
    }

    public NutritionFacts(int servingSize,int servings,int calories,int fat,int sodium,int carbohydrate){
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = carbohydrate;
    }
}

当想要创建实例的时候，可以利用参数列表最短的构造器，但该列表中包含了要设置的所有参数：

NuritionFacts cocaCola = new NutritionFacts(240,8,100,0,35,27)；

这样构造器调用通常需要许多本不想设置的参数，但还是不得不为它们传递值。

缺点：重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难编写，并且仍然较难以阅读，当使用者想知道参数值是什么意，必须很仔细的数着这些参数来谈个究竟。一长串类型相同的参数会导致一写微妙的错误。如果客户端不小心颠倒了其中两个参数的顺序，编译器也不会出错，但是程序在运行时会出现错误的行为。

JavaBeans模式

遇到许多构造器参数的时候，还有第二种替代方法，即JavaBean模式，在这种模式下调用一个无参构造器来创建对象，然后调用setter方法来设置每个必要的参数，以及每个相同的可选参数：

public class NutritionFacts {
    //Parameters initialized to default values(if any)
    private int servingSize = -1;
    
    private int servings = -1;

    private int calories = 0;

    private int fat = 0;
    
    private int sodium = 0;
    
    private int carbohydrate = 0;

    public NutritionFacts() {
    }

    //Setters
    public void setServingSize(int servingSize) {
        this.servingSize = servingSize;
    }

    public void setServings(int servings) {
        this.servings = servings;
    }

    public void setCalories(int calories) {
        this.calories = calories;
    }

    public void setFat(int fat) {
        this.fat = fat;
    }

    public void setSodium(int sodium) {
        this.sodium = sodium;
    }

    public void setCarbohydrate(int carbohydrate) {
        this.carbohydrate = carbohydrate;
    }
}

实际使用过程中的例子如下：

NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarBohydrate(27);

这种方式弥补了重叠构造器模式的不足，但这种模式自身也有很严重的缺点。

缺点：

1.构造过程被分到了几个调用中，在构造过程中JavaBean可能处于不一致的状态。类无法仅仅通过检验构造器参数的有效性来保证一致性。

2.JavaBeans模式阻止了把类做成不可变的可能，这需要付出额外的努力来确保它的线程安全。

Builder模式

既能保证重叠构造器模式那样的安全性，也能保证像JavaBeans模式那么好的可读性。

具体使用场景：

如果类的构造器或者静态工厂中具有多个参数，设计这种类的时候，Builder模式就是种不错的选择。特别是当大多数参数都是可选的时候。

与传统的重叠构造器模式相比，使用Builder模式的客户端代码将易于阅读和编写，构建器也比JavaBeans更加安全。

不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器（或者静态工厂），得到一个builder对象。然后通过在builder对象上调用类似于setter的方法，来设置每个相关的可选参数。最后，可以通过调用无参的build方法来生成不可变的对象。这个builder是它构建的类的静态成员类。

具体例子如下：

public class NutritionFacts {
    private final int servingSize;

    private final int servings;

    private final int calories;

    private final int fat;

    private final int sodium;

    private final int carbohydrate;

    public static class Builder{
        //Required parameters
        private final int servingSize;
        private final int servings;
        
        //Optional parameters - initialized to default values
        private int calories = 0;
        private int fat = 0;
        private int carbohydrate = 0;
        private int sodium = 0;
        
        public Builder(int servingSize,int servings){
            this.servingSize = servingSize;
            this.servings = servings;
        }
        
        public Builder calories(int val){
            calories = val;
            return this;
        }
        public Builder fat(int val){
            fat = val;
            return this;
        }
        public Builder carBohydrate(int val){
            carbohydrate = val;
            return this;
        }
        public Builder sodium(int val){
            sodium = val;
            return this;
        }
        public NutritionFacts build(){
            return new NutritionFacts(this);
        }
    }
    
    private NutritionFacts(Builder builder){
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

NutritionFacts 是不可变的，所有的默认参数值都单独放在一个地方。builder的setter方法返回builder本身，以便把调用链接起来。具体使用代码如下：

NutritionFacts cocaCola = new NutritionFacts.Builder(240,8).
calories(100).sodium(35).carbohydrate(27).build();

优点：

1.builder像个构造器一样，可以对其参数强加约束条件。build方法可以检验这些约束条件。

2.builder可以有多个可变参数。构造器就像方法一样，只能有一个可变参数。因为builder利用单独的方法来设置每个参数，想要多少可变参数，它们就可以有多少个，直到每个setter方法都有一个可变参数。

3.builder模式十分灵活，可以利用单个builder构建多个对象。builder的参数可以在创建对象期间进行调整，也可以随着不同的对象而改变。builder可以自动填充某些域，例如每次创建对象时自动增加序列号。

缺点不足：

为了创建对象，必须先创建它的构建器。虽然创建构建器的开销在实践中可能不那么明显，但是在某些十分注重性能的情况下，可能就成问题了，Builder模式还比重叠构建器模式更加爱冗长，因此它只有在很多参数的时候才是用，比如4个参数或者更多个参数。