本章的主题是创建和销毁对象：何时以及如何创建对象，何时以及如何避免创建对象，如何确保它们能够适时地销毁，以及如何管理对象销毁之前必须进行的各种清理动作。
[toc]
静态工厂 和 构造器 有个共同的局限性：它们都不能很好地扩展到大量的可选参数。
书中例子为：编写一个类标识包装食品外面显示的营养成份标签。类似这个营养成分表：
方法一：程序员一向习惯采用重叠构造器（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; // 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;
}
}
调用方式如下：
NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
重叠构造器模式可行，但是当有许多参数的时候，客户端代码会变得很难写，并且仍然较难以阅读。
方法二： JavaBeans 模式：调用一个无参构造器来创建对象，然后调用 setter 方法来设置每个必要的参数，以及每个相关的可选参数。
// JavaBeans Pattern - allows inconsistency, mandates mutability
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; }
}
调用方式如下：
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);
这种模式弥补了重叠构造器模式的不足，可读性也好，但也存在严重的缺点：
-
在构造过程中 JavaBean 可能处于不一致的状态。
因为构造过程被分到了几个调用中，有可能在构造完成之前使用它，导致当时使用的信息 与完成的信息不符，从而在使用时导致失败。可以通过手工冻结/解冻的方式弥补此不足，不允许对象构造完成前使用，但是显得十分笨拙，甚至导致运行时错误，因为编译器无法确保程序员会在使用之前先在对象上调用 freeze 方法。
不一致状态
这里值得注意的是，英文版中对于中文版 第10页最后一段的描述如下：
英文版第二版 第13页
框起来的部分为本段标题：在构造过程中 JavaBean 可能处于 不一致的状态。
如果读者对于不一致的状态不理解，英文版中使用了 inconsistent 这个单词，将其翻译为"前后矛盾的状态"可能会更好理解。
-
与第一点相关的另一点不足：JavaBeans 模式阻止了把类做成不可变的可能（见第15条）
这需要程序员付出额外的努力来确保它的线程安全
方法三：Builder 模式
不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器（或者静态工厂），得到一个 builder 对象。然后客户端在 builder 对象上调用类似与 setter 的方法，来设置每个相关的可选数。最后，客户端调用无参的 build 方法来生成不可变的对象。这个 builder 是它构造的类的静态成员类（见第22条）。
// 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;
}
}
调用方式如下：
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8). calories(100).sodium(35).carbohydrate(27).build();
客户端代码很容易编写，更重要的是，易于阅读，builder 模式模拟了具名的可选参数，就像 Ada 和 Python 中的一样
具名的可选参数
英文原文为：
named optional parameters 书中翻译为 具名的可选参数【google 为 ： 命名可选参数】
因为本人没有学过 Ada 和 Python ，所以通过 google 找来了 Python 的例子，有感兴趣的可以看看Fun With Python Function Parameters
本人也用自己的理解简单的说一下【以下的图片内容通过 Chrome 的翻译所得】
个人理解：你既可以只传入必须值，也可以更改默认的一些可选参数，获得所需内容（实例）。
总结：
builder 像个构造器一样，可以对其参数强加约束条件。
build 方法可以检测这些约束条件。将参数从 builder 拷贝到 对象 中之后，并在对象域而不是builder 域（见第39条）中对它们进行检验，这点很重要。如果违法了任何约束，build方法应该抛出异常（IllegalArgumentException），并显示详细信息（违反哪个约束）。对多个参数加强条件的另一种方法是，用多个 setter 方法 对某个条件必须持有的参数进行检查，如果约束条件没有满足就抛出 IllegalArgumentException 异常。此方法可以在传递了无效参数时立即报错，不用等到 build 方法调用。
与构造器相比，builder 的略微优势：
builder可以有多个可变（varargs）参数。构造器就像方法一样，只能有一个。
请对比 重叠构造器模式 和 builder模式 观察其中的 可变参数（非 final）Builder模式 十分灵活，可以利用单个builder构建多个对象；
Builder 参数也可以在创建对象期间进行调整，也可以随着不同的对象而改变；
Builder 也可以自动填充都写域，例如每次穿件对象时自动增加序号；
Class.newInstance 破坏了编译时的异常检查。而 Builder接口弥补了这些不足；
设置了参数的 builder 生成了一个很好的抽象工厂【 builder 接口 为形参数类型】；
Builder模式 的不足：
- 为了创建对象，必须先创建它的构造器。
性能问题（十分重性能的情况下） - 比重叠构造器模式更加冗长，因此只有在很多参数时才使用。
参数 >= 4
但是记住，未来你可能还需要添加参数，如果一开就使用构造器或者静态工厂，等到类需要多个参数时才添加构造器，就会无法控制，那些果实的构造器或者静态工厂显得十分不协调。因此，通常最好一开始就使用构造器
如果类的构造器或者静态工厂中具有多个参数，设计这种类时， Builder 模式就是种不错的选择，特别是当大多数参数都是可选的时候。与使用传统的重叠构造器模式相比，使用 Builder 模式的客户端代码将更易于阅读和编写，构造器也比 JavaBeans 更加安全。
