EJ-2 Consider a Builder When Faced with Many Constructor Parameters

Ref: Effective Java by Joshua Bloch

Traditionally, programmers have used the telescoping constructor pattern, in which you provide a constructor with only required parameters, another with a single optional parameters, a third with two optional parameters, and so on...

	// Telescoping constructor pattern - does not scale well!
	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;
	}
	}

view raw TelescopingConstructorPattern.java hosted with ❤ by GitHub

Telescoping constructor pattern works, but it is hard to write client code when there are many parameters, harder still to read it.

An alternative way is to use JavaBeans patterns, creating instance with a parameterless constructor than calling setter method of each required parameters.  Unfortunately, the JavaBeans patterns has a serious disadvantages of its own, because construction is split across multiple calls, a JavaBean may be in an inconsistent state partway through its construction.

Better to use Builder Pattern, client calls setter-like methods on the builder object to set each optional parameter of interest and then calls parameterless build method to generate the object which is immutable.

	// Builder Pattern
	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();
	}
	}

view raw BuilderPattern.java hosted with ❤ by GitHub

In summary, the Builder pattern is a good choice when designing classes whose constructors or static factories would have more than a handful of parameters, especially if most of those parameters are optional. Client code is much easier to read and write with builders than with the traditional telescoping constructor pattern, and builders are much safer than JavaBeans. 

Ref: http://www.informit.com/articles/article.aspx?p=1216151&seqNum=2