Effective Item 2 - 遇到多个构造器参数时考虑使用Builder

静态工厂和够构造器有一个共同的局限性：遇到大量的参数时无法很好的扩展。

先说说构造器。

其实field不多时重叠构造器(telescoping constructor)是个不错的方法，易于编写也易于调用，这种方式在参数数量较少时也很常见。

但问题是参数很多(可能越来越多)时，比如(现在已经很难找到对多个参数进行重叠构造的代码了，于是在这里直接引用一下书中的代码)：

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

我想创建实例的时候，代码会变成这个样子：

public static void main(String[] args) {
	NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
}

虽然很难看，但这个可以有!

不过换个立场想一想，整个类里获得实例的方式就这么一个破构造器让你调用，你会是什么感觉?

为了让创建实例的过程变得更加清晰，于是我们有另一中选择——JavaBean模式。

这个再熟悉不过了，如下：

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 val) {
		servingSize = val;
	}

	public void setServings(int val) {
		servings = val;
	}

	public void setCalories(int val) {
		calories = val;
	}

	public void setFat(int val) {
		fat = val;
	}

	public void setSodium(int val) {
		sodium = val;
	}

	public void setCarbohydrate(int val) {
		carbohydrate = val;
	}
}

用起来虽然比只有一行的构造器多几个步骤，但非常清晰：

public static void main(String[] args) {
	NutritionFacts cocaCola = new NutritionFacts();
	cocaCola.setServingSize(240);
	cocaCola.setServings(8);
	cocaCola.setCalories(100);
	cocaCola.setSodium(35);
	cocaCola.setCarbohydrate(27);
}

现在我们想想JavaBean模式比起构造器重叠又有什么缺点?

相比只通过一个构造器创建实例，JavaBean模式的实例的构造过程被分成了好几个过程。

我们完全有可能在属性不完整的情况下使用这个实例。

(按书中原文就是<A JavaBean may be in a inconsistent state partway through its construction.>)

当然，我们也可以做一些操作使其在未完成的情况下无法使用，但我不想因此让一个类变得越来越复杂。

另外，我根本无法用JavaBean模式完全排除了将类设计成不可变(Immutable)的可能性。

此时，我们选择使用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;
	}
}

调用起来非常清晰(模拟了具名参数)，而且非常简单：

public static void main(String[] args) {
		NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
				.calories(100).sodium(35).carbohydrate(27).build();
	}

当然，Builder也有缺点。

缺点1.创建实例前都要创建一个Builder实例。

缺点2.Builder模式编写起来较为冗长。

但是，当构建一个实例需要很多步骤(或者很多让人混淆的参数)的时候，Builder模式是个不错的选择。

Effective Item 2 - 遇到多个构造器参数时考虑使用Builder