本章的主题是创建和销毁对象:何时以及如何创建对象,何时以及如何避免创建对象,如何确保它们能够适时地销毁,以及如何管理对象销毁之前必须进行的各种清理动作。
[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页最后一段的描述如下:
框起来的部分为本段标题:在构造过程中 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 更加安全。