使用Builder模式代替来创建实例

引入：

考虑有这样一个类的设计，它用来表示包装食品外面的营养标签，包含以下内容：

每罐的含量(servingSize)

营养品的种类(servings)

卡路里(calories)

脂肪含量(fat)

钠含量(sodium)

糖含量(carbohydrate)。

其中前两个是必须的，后面几项是可选的。

对于这样的类，应该用哪种构造方法或者静态方法来编写呢？一种常用的方法是采用重叠构造器(telescoping constructor)。例如：

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

    这种方法可行，但是当有许多参数时，客户端代码会很难编写，并且较难阅读。如果读者想明白这些值是什么意思，需要仔细的数着参数来探个究竟。一长串类型相似的参数会导致一些微妙的错误，如果客户端不小心颠倒了其中两个参数的顺序，编译器不会报错，但在程序运行时会出现错误的行为。

方案二

调用一个无参的构造方法来创建对象，然后调用setter方法来设置每个必要的参数，以及每个必要的参数。

public class NutritionFacts {
    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 val) {servingSize = val;}
    public void setServings(int val){servings = val;}
    public void setCalories(int val){calories = val;}
    pubic void setSodium(int val) {sodium = val;}
    public void setCarbohydrate(int val){carbohydrate = val;}
}

这种模式弥补了重叠构造器模式的不足。就是创建实例容易，这样产生的代码也容易阅读。

NutritionFacts cocaCola = new NutritionFacts();

cocaCola.setServingSize(240);

cocaCola.setServings(8);

cocaCola.setCalories(100);

cocaCola.setSodium(35);

cocaCola.setcarbohydrate(27);

优缺点：

因为构造过程被分到了几个调用中，类的对象可能处于不一致的状态。类无法通过检验构造器参数的有效性来保证一致性。试图使用处于不一致状态的对象，将会导致失败，而且，这种模式阻止了把类做成不可变的可能。

方案三（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;

    pubic static class Builder{
        private final int servingSize;
        private final int servings;
    
        private int calories = 0;
        private int fat = 0;
        private int carbohydrate = 0;
        private int sodium = 0;

        pubic Builder(int servingSize, int servings) {
            this.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 carbohydrate(int val) {
            this.carbohydrate = val;
            return this;
       }	
       public Builder sodium(int val) {
            this.sodium = val;
            return this;
       }
       public NutritionFacts build() {
           return new NutritionFacts(this);
       }
    }
    //私有Constructor表明创建NutritionFacts对象时，只能通过Builder对象的build()方法。
    private NutritionFacts(Builder builder) {
	serviceSize = builder.serviceSize;
	servings = builder.servings;
		
	calories = builder.calories;
	fat = builder.fat;
	sodium = builder.sodium;
	carbohydrate = builder.carbohydrate;
    }
    //test case.
    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts.Builder(240,8).calories(100).sodium(35)
                .carbohydrate(27).build();
    }
}

Builder模式可以有多个可变参数，使用单独的方法来设置每个参数。简言之，如果类的Constructor或静态工厂方法中有多个参数，就可以考虑使用Builder模式。