遇到多个构造器参数时要考虑用构建器

内容为总结于Effective Java中文第二版

当我们要编写一个类，并且在初始化时要为他设置很多参数，我们一般是考虑使用重叠构造器模式，在这种模式下，你提供第一个只有必要参数的构造器，第二个构造器有一个可选参数，第三个有两个可选参数，以此类推，最后一个构造器包含所有可选参数。

1、重叠构造器模式：

// Telescoping constructor pattern  重叠构造器模式
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);
}
}

一句话：重叠构造器模式可行，但是当有许多参数的时候，客服端代码会很难编写，并且仍然难以阅读。如果别人想知道那些值是什么意思，必须很仔细地数着这些参数来探个究竟。一长串类型相同的参数会导致一些微妙的错误。如果客户端不小心颠倒了其中两个参数的顺序，编译器也不会报错，但是程序在运行时会出现错误的行为。

2、JavaBeans模式

遇到许多构造器参数的时候，还有第二种替代办法，即JavaBeans模式，在这种模式下，调用一个无参构造器来创建对象，然后调用setter方法来设置每个必要的参数，以及每个相关的可选参数。

// JavaBeans Pattern  
public class NutritionFacts {
// Parameters initialized to default values (if any)
private int servingSize = -1; // Required; no default value
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);
}
}

遗憾的是，JavaBeans模式自身有着很严重的缺点。因为构造过程被分割到了几个调用中，在构造过程中JavaBeans可能处于不一致的状态。类无法仅仅通过检验构造器参数的有效性来保证一致性。试图使用处于不一致状态的对象，将会导致失败，这种失败与包含错误的代码大相径庭，因此调试起来十分困难。与此相关的另一点不足在于，JavaBeans模式阻止了把类做成不可变的可能，这就需要程序员付出额外的努力来确保它的线程安全。

3、Builder模式（推荐）

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

/**
 * 建造者模式 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;
    
    private static final int servings1 = 1;
    
    // 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)//这里生成Builder对象
            .calories(100)
            .sodium(35)
            .carbohydrate(27)//这三个方法是类似于setter的方法
            .build();//调用无参的build方法生成不可变的外部类对象
     
}
}