Effective Java 第三版读书笔记——条款2：当构造器参数太多时考虑使用 builder 模式

静态工厂方法和构造器都有一个限制：不能很好地支持可选参数(optional parameters)很多的类。考虑一个代表包装食品上营养成分标签的类：这些标签有几个必需的属性（每份建议摄入量、每个包装所含的份数、每份的卡路里）和超过二十个可选的属性（总脂肪、饱和脂肪、反式脂肪、钠等等）。应该为这样的类编写什么样的构造方法或静态工厂呢？有没有其他的方法解决这个问题？

Telescoping constructor 模式

提供一个只有必需参数的构造器，第二个构造器有一个可选参数，第三个构造器有两个可选参数……最后一个构造器有所有的可选参数。例如：

// 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; // (per serving) optional
    private final int fat; // (g/serving) optional
    private final int sodium; // (mg/serving) optional
    private final int carbohydrate; // (g/serving) 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;
    }
}

创建对象时，选择满足条件的构造器中参数最少的那一个：

NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);

显然，创建对象时你会为很多自己不感兴趣的参数赋初始值，这使得客户端代码的书写变得困难。此外，这样的代码也很难阅读，读代码的人需要了解参数的顺序并且仔细数清楚参数的个数。总之，Telescoping constructor 模式不是一种很好的解决方案。

JabaBeans 模式

在这种模式中，调用一个无参数的构造函数来创建对象，然后调用setter方法来设置每个必需参数和可选参数。例如：

// JavaBeans Pattern - allows inconsistency, mandates mutability  (pages 11-12)
public class NutritionFacts {
    // Parameters initialized to default values (if any)
    private int servingSize  = -1; // Required; no default value
    private int servings     = -1; // Required; no default value
    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; }
}

这个模式没有 telescoping constructor 模式的缺点，创建对象十分容易并且可读性也很高：

NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);

不幸的是，JavaBeans 模式有很严重的缺点：

• 在构造过程中，一个 JavaBean 可能处于不一致状态。如果在它还没有构造完全时另一个线程就调用了它，就会带来很多意想不到的 bug。
• JavaBeans 模式排除了让类不可变的可能性。因为 setter 方法的存在，JavaBean 必须是可变的，但有时我们想要创建不可变的对象。

由此可知，JavaBeans 模式也不是一种很好的解决方案。

Builder 模式

结合了 telescoping constructor 模式的安全性与 JavaBeans 模式的易读性。客户端不直接创建所需类的对象，而是调用构造方法(或静态工厂)，并使用所有必需参数来获得一个 builder 对象。然后，客户端调用 builder 对象的类似 setter 的方法来设置每个可选参数。最后，客户端调用一个无参的 build 方法来生成对象，该对象通常是不可变的。Builder 通常是它所构建的类的一个静态成员类。例如：

// Builder Pattern  (Page 13)
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 sodium        = 0;
        private int carbohydrate  = 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 sodium(int val)
        { sodium = val;        return this; }
        public Builder carbohydrate(int val)
        { carbohydrate = 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;
    }
}

NutritionFacts 类是不可变的，所有的参数默认值都在一个地方。 builder 的 setter 方法返回 builder 本身，这样调用就可以被链接起来，从而生成一个流畅的API。下面是客户端代码的示例：

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

Builder 模式非常灵活。单个 builder 可以重复使用来构建多个对象。 builder 可以在创建对象时自动填充一些属性，例如每次创建对象时增加的序列号。

Builder 模式也有缺点。为了创建对象，首先必须创建它的 builder 。虽然创建这个 builder 的成本在实际应用中不太大，但在性能关键的情况下可能会出现问题。而且，builder 模式比 telescoping constructor 模式更冗长，因此只有在有足够的参数时才值得使用它，比如四个或更多。

Builder 模式非常适合类层次结构

使用平行层次的 builder，每一个都嵌套在相应的类中。 抽象类有抽象的 builder ; 具体类有具体的 builder。 例如，考虑代表各种比萨饼的根层次结构的抽象类：

// Builder pattern for class hierarchies (Page 14)
// Note that the underlying "simulated self-type" idiom  allows for arbitrary fluid hierarchies, not just builders

public abstract class Pizza {
    public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
    final Set<Topping> toppings;

    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        abstract Pizza build();

        // Subclasses must override this method to return "this"
        protected abstract T self();
    }
    
    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone(); // See Item 50
    }
}

请注意，Pizza.Builder 是一个带有递归类型参数（ recursive type parameter)（条款30）的泛型类型。 这与抽象的 self 方法结合在一起，允许方法链在子类中正常工作，而不需要强制转换。

这里有两个具体的 Pizza 的子类，其中一个代表标准的纽约风格的披萨，另一个是半圆形烤乳酪披萨。前者有一个所需的尺寸参数，而后者则允许指定酱汁应该在里面还是外面：

public class NyPizza extends Pizza {
    public enum Size { SMALL, MEDIUM, LARGE }
    private final Size size;

    public static class Builder extends Pizza.Builder<Builder> {
        private final Size size;

        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }

        @Override public NyPizza build() {
            return new NyPizza(this);
        }

        @Override protected Builder self() { return this; }
    }

    private NyPizza(Builder builder) {
        super(builder);
        size = builder.size;
    }
}

public class Calzone extends Pizza {
    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder> {
        private boolean sauceInside = false; // Default

        public Builder sauceInside() {
            sauceInside = true;
            return this;
        }

        @Override public Calzone build() {
            return new Calzone(this);
        }

        @Override protected Builder self() { return this; }
    }

    private Calzone(Builder builder) {
        super(builder);
        sauceInside = builder.sauceInside;
    }
}

下面是一个客户端代码的样例：

import static effectivejava.chapter2.item2.hierarchicalbuilder.Pizza.Topping.*;
import static effectivejava.chapter2.item2.hierarchicalbuilder.NyPizza.Size.*;

// Using the hierarchical builder (Page 16)
public class PizzaTest {
    public static void main(String[] args) {
        NyPizza pizza = new NyPizza.Builder(SMALL)
                .addTopping(SAUSAGE).addTopping(ONION).build();
        Calzone calzone = new Calzone.Builder()
                .addTopping(HAM).sauceInside().build();
        
    }
}