按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
107
…………………………………………………………Page 109……………………………………………………………
工作。这些方法都可在 Java 1。0 中使用，但通过使用“after”自变量而调用的runFinalizersOnExit（）方
法却只有Java 1。1 及后续版本提供了对它的支持（注释③）。注意可在程序执行的任何时候调用这个方法，
而且收尾程序的执行与垃圾收集器是否运行是无关的。
③：不幸的是，Java 1。0 采用的垃圾收集器方案永远不能正确地调用finalize（）。因此，finalize（）方法
（特别是那些用于关闭文件的）事实上经常都不会得到调用。现在有些文章声称所有收尾模块都会在程序退
出的时候得到调用——即使到程序中止的时候，垃圾收集器仍未针对那些对象采取行动。这并不是真实的情
况，所以我们根本不能指望finalize（）能为所有对象而调用。特别地，finalize（）在Java 1。0 里几乎毫无
用处。
前面的程序向我们揭示出：在 Java 1。1 中，收尾模块肯定会运行这一许诺已成为现实——但前提是我们明确
地强制它采取这一操作。若使用一个不是“before”或“after”的自变量（如“none ”），那么两个收尾工
作都不会进行，而且我们会得到象下面这样的输出：
Created 47
Beginning to finalize after 8694 Chairs have been created
Finalizing Chair #47； Setting flag to stop Chair creation
After all Chairs have been created：
total created = 9834； total finalized = 108
bye！
因此，到程序结束的时候，并非所有收尾模块都会得到调用（注释④）。为强制进行收尾工作，可先调用
System。gc（），再调用System。runFinalization（）。这样可清除到目前为止没有使用的所有对象。这样做一
个稍显奇怪的地方是在调用runFinalization（）之前调用gc（），这看起来似乎与 Sun 公司的文档说明有些抵
触，它宣称首先运行收尾模块，再释放存储空间。然而，若在这里首先调用runFinalization（），再调用
gc（），收尾模块根本不会执行。
④：到你读到本书时，有些Java 虚拟机（JVM）可能已开始表现出不同的行为。
针对所有对象，Java 1。1 有时之所以会默认为跳过收尾工作，是由于它认为这样做的开销太大。不管用哪种
方法强制进行垃圾收集，都可能注意到比没有额外收尾工作时较长的时间延迟。
4。4 成员初始化
Java 尽自己的全力保证所有变量都能在使用前得到正确的初始化。若被定义成相对于一个方法的“局部”变
量，这一保证就通过编译期的出错提示表现出来。因此，如果使用下述代码：
void f（） ｛
int i；
i＋＋；
｝
就会收到一条出错提示消息，告诉你 i 可能尚未初始化。当然，编译器也可为 i 赋予一个默认值，但它看起
来更象一个程序员的失误，此时默认值反而会“帮倒忙”。若强迫程序员提供一个初始值，就往往能够帮他
／她纠出程序里的“臭虫”。
然而，若将基本类型（主类型）设为一个类的数据成员，情况就会变得稍微有些不同。由于任何方法都可以
初始化或使用那个数据，所以在正式使用数据前，若还是强迫程序员将其初始化成一个适当的值，就可能不
是一种实际的做法。然而，若为其赋予一个垃圾值，同样是非常不安全的。因此，一个类的所有基本类型数
据成员都会保证获得一个初始值。可用下面这段小程序看到这些值：
//： InitialValues。java
// Shows default initial values
class Measurement ｛
108
…………………………………………………………Page 110……………………………………………………………
boolean t；
char c；
byte b；
short s；
int i；
long l；
float f；
double d；
void print（） ｛
System。out。println（
〃Data type Inital valuen〃 ＋
〃boolean 〃 ＋ t ＋ 〃 n〃 ＋
〃char 〃 ＋ c ＋ 〃 n〃 ＋
〃byte 〃 ＋ b ＋ 〃 n〃 ＋
〃short 〃 ＋ s ＋ 〃n〃 ＋
〃int 〃 ＋ i ＋ 〃 n〃 ＋
〃long 〃 ＋ l ＋ 〃 n〃 ＋
〃float 〃 ＋ f ＋ 〃 n〃 ＋
〃double 〃 ＋ d）；
｝
｝
public class InitialValues ｛
public static void main（String＇＇ args） ｛
Measurement d = new Measurement（）；
d。print（）；
/* In this case you could also say：
new Measurement（）。print（）；
*/
｝
｝ ///：~
输入结果如下：
Data type Inital value
boolean false
char
byte 0
short 0
int 0
long 0
float 0。0
double 0。0
其中，Char 值为空（NULL ），没有数据打印出来。
稍后大家就会看到：在一个类的内部定义一个对象句柄时，如果不将其初始化成新对象，那个句柄就会获得
一个空值。
4。4。1 规定初始化
如果想自己为变量赋予一个初始值，又会发生什么情况呢？为达到这个目的，一个最直接的做法是在类内部
定义变量的同时也为其赋值（注意在C＋＋里不能这样做，尽管C＋＋的新手们总“想”这样做）。在下面，
Measurement 类内部的字段定义已发生了变化，提供了初始值：
109
…………………………………………………………Page 111……………………………………………………………
class Measurement ｛
boolean b = true；
char c = 'x'；
byte B = 47；
short s = 0xff；
int i = 999；
long l = 1；
float f = 3。14f；
double d = 3。14159；
//。 。 。
亦可用相同的方法初始化非基本（主）类型的对象。若Depth 是一个类，那么可象下面这样插入一个变量并
进行初始化：
class Measurement ｛
Depth o = new Depth（）；
boolean b = true；
// 。 。 。
若尚未为o 指定一个初始值，同时不顾一切地提前试用它，就会得到一条运行期错误提示，告诉你产生了名
为“违例”（Exception）的一个错误（在第9 章详述）。
甚至可通过调用一个方法来提供初始值：
class CInit ｛
int i = f（）；
//。。。
｝
当然，这个方法亦可使用自变量，但那些自变量不可是尚未初始化的其他类成员。因此，下面这样做是合法
的：
class CInit ｛
int i = f（）；
int j = g（i）；
//。。。
｝
但下面这样做是非法的：
class CInit ｛
int j = g（i）；
int i = f（）；
//。。。
｝
这正是编译器对“向前引用”感到不适应的一个地方，因为它与初始化的顺序有关，而不是与程序的编译方
式有关。
这种初始化方法非常简单和直观。它的一个限制是类型Measurement 的每个对象都会获得相同的初始化值。
有时，这正是我们希望的结果，但有时却需要盼望更大的灵活性。
110
…………………………………………………………Page 112……………………………………………………………
4。4。2 构建器初始化
可考虑用构建器执行初始化进程。这样便可在编程时获得更大的灵活程度，因为我们可以在运行期调用方法
和采取行动，从而“现场”决定初始化值。但要注意这样一件事情：不可妨碍自动初始化的进行，它在构建
器进入之前就会发生。因此，假如使用下述代码：
class Counter ｛
int i；
Counter（） ｛ i = 7； ｝
// 。 。 。
那么 i 首先会初始化成零，然后变成 7。对于所有基本类型以及对象句柄，这种情况都是成立的，其中包括
在定义时已进行了明确初始化的那些一些。考虑到这个原因，编译器不会试着强迫我们在构建器任何特定的
场所对元素进行初始化，或者在它们使用之前——初始化早已得到了保证（注释⑤）。
⑤：相反，C＋＋有自己的“构建器初始模块列表”，能在进入构建器主体之前进行初始化，而且它对于对象来
说是强制进行的。参见《Thinking in C＋＋》。
1。 初始化顺序
在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，
那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。例如：
//： OrderOfInitialization。java
// Demonstrates initialization order。
// When the constructor is called； to create a
// Tag object； you'll see a message：
class Tag ｛
Tag（int marker） ｛
System。out。println（〃Tag（〃 ＋ marker ＋ 〃）〃）；
｝
｝
class Card ｛
Tag t1 = new Tag（1）； // Before constructor
Card（） ｛
// Indicate we're in the constructor：
System。out。println（〃Card（）〃）；
t3 = new Tag（33）； // Re…initialize t3
｝
Tag t2 = new Tag（2）； // After constructor
void f（） ｛
System。out。println（〃f（）〃）；
｝
Tag t3 = new Tag（3）； // At end
｝
public class OrderOfInitialization ｛
public static void main（String＇＇ args） ｛
Card t = new Card（）；
t。f（）； // Shows that construction is done
｝
111
………………………………………