建造者模式

一） 重叠构造器模式的问题
不知道大家在编程时有没有遇到过这样一个问题。我们的构造函数需要传入很多参数，有些参数是必需的，有些参数是可选的。于是为了满足各种情况下的构造，我们可能会采用重叠构造器模式的方法。就像下面这个例子：

public class NutritionFacts{
    private final int servingSize; //(ml)             required
    private final int servings;    //(per container)  required
    private final int calories;    //                 optional
    private final int fat;         //(g)              optional
    private final int sodium;      //(mg)             optional
    private final int carbohydrate;//(g)              optional

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

    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){
        this(servingSize, servings, calories, fat, 0);
    }

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

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

如果需要传入的参数更多，那么NutritionFacts的构造函数也将更多更复杂。而且另外一点不足是它使用起来的可读性也非常差。比如这样：

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

这还是“仅仅”只有6个参数的情况噢！

二） 建造者模式的威力
既然重叠构造器对于过多参数传入的情况有这样那样的不足，那么我们有没有一个更好的解决方案呢？答案是有。那就是建造者模式！我们来看看上面的例子建造者模式是如何处理的：

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 sodium = 0;
        private int carbohydrate = 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 sodium(int val){
            sodium = val;
            return this;
        }
        public Builder carbohydrate(int val){
            carbohydrate = 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;
    }
}

内部类Builder大大提供了构造NutritionFacts的灵活性和可读性。某些情况下Builder类内的属性甚至可以不与NutritionFacts类的一一对应。至于说可读性，看下面个例子马上就能体会到了：

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