builder模式

package test1;

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

}

 这种模式既能保证像重叠构造器模式那样的安全性，也能保证像javabean模式那么好的可读性。这就是Builder模式的一种形式。不直接生成想要的对象，而是让客户端在builder对象上调用类似于setter的方法，来设置每个相关的可选参数。最后，客户端调用无参的build方法来生成不可变的对象。这个builder是它构建的类的静态成员类

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

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

 这样的客户端代码很容易编写，更重要的是，易于阅读。builder模式模拟了具名的可选参数，就像Ada和Python中的一样。

builder像个构造器一样，可以对其参数加强约束条件。build方法可以检验这些约束条件。将参数从builder拷贝到对象中之后，并在对象域而不是builder域中对它们进行检验，这一点很重要。如果违反了任何约束条件，build方法就应该抛出IllegalStateException。异常的详细信息应该显示出违反了哪个约束条件。

对多个参数强加约束条件的另一种方法是，用多个setter方法对某个约束条件必须持有的所有参数进行检查。如果该约束条件没有得到满足，setter方法就会抛出IllegalStateException。有个好处，就是一旦传递了无效的参数，立即就会发现约束条件失败，而不是等着调用build方法。

与构造器相比，builder的微略优势在于，builder可以有多个可变参数。构造器就像方法一样，只能有一个可变参数。因为builder利用单独的方法来设置每个参数，你想要多少个可变参数，它们就可以有多少个，知道每个setter方法都有一个可变参数。

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

设置了参数的builder生成了一个很好的抽象工厂。换句话说，客户端可以将这样一个builder传给方法，使该方法能够为客户端创建一个或多个对象。

设置了参数的builder生成了一个很好的抽象工厂。换句话说，客户端可以将这样一个builder传给方法，使该方法能够为客户端创建一个或者多个对象。要使用这种方法，需要有个类型来表示builder。如果使用的是1.5版本或者更新的版本，只要一个泛型就能满足所有的builder，无论它们在构建哪种类型的对象：

public interface Builders<T> {

	public T builder();

}

 注意，可以声明NutritionFacts.Builder类来实现Builders<NutritionFacts>。

public static class Builder implements Builders<NutritionFacts>

 Builder模式的确也有它的不足，为了创建对象，必须先创建它的构建器。虽然创建构建器的开销在实践中可能不那么明显，但是在某些十分注重性能的情况下，可能就成问题了。

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

 

Builder模式还比重叠构造器模式更加冗长，因此它只在有很多参数的时候才使用，比如4个或更多参数。但是记住，将来你可能需要添加参数。如果一开始就使用构造器或者静态工厂，等到类需要多个参数时才添加构建器，就会无法控制，那些过时的构造器或者静态工厂显得十分不协调。因此，通常最好一开始就使用构建器。

简而言之，如果类的构造器或静态工厂中具有多个参数，设计这周类时，Builder模式就是种不错的选择，特别是当大多数参数都是可选的时候。与使用传统的重叠构造器模式相比，使用Builder模式的客户端代码将更易于阅读和编写，构建器也比javabean更加安全。