Java

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

先说说构造器。
其实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模式的实例的构造过程被分成了好几个过程。
我们完全有可能在属性不完整的情况下使用这个实例。
按书中原文就是:

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模式是个不错的选择。