EffactiveJava-遇到多个构造器时考虑用构建器

在使用静态工厂和构造器创建对象时，有一个比较大的局限：他们都不能很好的处理大量的可选参数。

举例来说，如果用一个类来表示食品包装袋上显示的营养成分标签，这些标签中有几个域是必须的，比如每份的含量和每份的卡路里，同时还有很多可选域，比如：总脂肪量、转化脂肪、胆固醇等等。大多数食品在某几个可选域中都会有非零值。

比较常见的处理方法是使用叠加构造器，即构造器复用，这种形式在JDK源代码中也屡见不鲜，下面用构造器叠加的方式来处理上述问题：

//构造器叠加
public class NutritionFacts {

    private final int servingSize;   //required
    private final int servings;      //required
    private final int calories;      //optional
    private final int fat;           //optional
    private final int sodium;        //optional 
    private final int carbohydrate;  //optional


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

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

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

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

    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;
    }

}

从上面的代码中可以看出，构造器叠加确实把问题解决了，但是仔细想一想，当可选参数足够多时，我们的类定义会被构造器充斥，同时，客户端代码会很难编写，而且不能从参数上进行语义区分，所以可读性会非常差

为了对上述代码进行改进，将各个参数在语义级别进行区分，提高代码的可读性，我们利用JavaBean的模式为每一个域提供set方法，这样在设置参数的时候就好理解多了

/JavaBean模式
public class NutritionFacts {

    private  int servingSize = -1;   //required
    private  int servings = -1;      //required
    private  int calories = 0;      //optional
    private  int fat = 0;           //optional
    private  int sodium = 0;        //optional 
    private  int carbohydrate = 0;  //optional
    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);

对于上述调用过程，如果属性多线程，就会知道，从创建对象到设置参数，这一串操作不会被cup视为一个原子操作，这样在多线程环境下就会导致JavaBean处于不一致的状态，这是必须避免的错误。

那么，还有没有其他的解决办法了呢，当然，构建器模式就可以很好的解决这个问题，既能保证语义又能保证线程安全，使Bean对象保持一致状态

//Builder 模式
public class NutritionFacts {

    private final  int servingSize;   //required
    private final  int servings;      //required
    private final  int calories;      //optional
    private final  int fat;           //optional
    private final  int sodium;        //optional 
    private final  int carbohydrate;  //optional

    public static class Builder{

        private final int ServingSize;
        private final int servings;

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

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

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

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

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

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

    public NutritionFacts(Builder builder){
        this.servingSize = builder.ServingSize;
        this.servings = builder.servings;
        this.calories = builder.calories;
        this.fat = builder.fat;
        this.sodium = builder.sodium;
        this.carbohydrate = builder.carbohydrate;
    }

}

//调用方式
NutritionFacts bean = new NutritionFacts.Builder(240,8).calories(100).sodium(35).carbohydrate(27).build();

是不是清晰很多呢！

当然，构建器模式也有一些自身的缺陷，例如，必须创建Bean的构建器，编写时代码比较冗长，而且有一定的开销负担

简而言之，当类的构造器或者静态工厂中有很多参数，并且大多数是可选参数时，使用构建器Builder是非常不错的选择