Java编程思想第4版[中文版](PDF格式)-第34部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！


存“漏洞”的出现。当然，free（）是一个C　和C＋＋函数，所以我们需要在　finalize（）内部的一个固有方法中　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　105　


…………………………………………………………Page　107……………………………………………………………

调用它。　　

读完上述文字后，大家或许已弄清楚了自己不必过多地使用finalize（）。这个思想是正确的；它并不是进行　

普通清除工作的理想场所。那么，普通的清除工作应在何处进行呢？　　



4。3。2　　必须执行清除　　



为清除一个对象，那个对象的用户必须在希望进行清除的地点调用一个清除方法。这听起来似乎很容易做　

到，但却与　C＋＋　“破坏器”的概念稍有抵触。在C＋＋中，所有对象都会破坏（清除）。或者换句话说，所有对　

象都“应该”破坏。若将C＋＋对象创建成一个本地对象，比如在堆栈中创建（在　Java　中是不可能的），那么　

清除或破坏工作就会在“结束花括号”所代表的、创建这个对象的作用域的末尾进行。若对象是用new　创建　

的（类似于　Java　），那么当程序员调用C＋＋的delete　命令时（Java　没有这个命令），就会调用相应的破坏　

器。若程序员忘记了，那么永远不会调用破坏器，我们最终得到的将是一个内存“漏洞”，另外还包括对象　

的其他部分永远不会得到清除。　　

相反，Java　不允许我们创建本地（局部）对象——无论如何都要使用　new。但在Java　中，没有“delete”命　

令来释放对象，因为垃圾收集器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说　

正是由于存在垃圾收集机制，所以　Java　没有破坏器。然而，随着以后学习的深入，就会知道垃圾收集器的存　

在并不能完全消除对破坏器的需要，或者说不能消除对破坏器代表的那种机制的需要（而且绝对不能直接调　

用finalize（），所以应尽量避免用它）。若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然　

必须调用Java　中的一个方法。它等价于C＋＋的破坏器，只是没后者方便。　　

finalize（）最有用处的地方之一是观察垃圾收集的过程。下面这个例子向大家展示了垃圾收集所经历的过　

程，并对前面的陈述进行了总结。　　

　　

//：　Garbage。java　　

//　Demonstration　of　the　garbage　　

//　collector　and　finalization　　

　　

class　Chair　｛　　

　　static　boolean　gcrun　=　false；　　

　　static　boolean　f　=　false；　　

　　static　int　created　=　0；　　

　　static　int　finalized　=　0；　　

　　int　i；　　

　　Chair（）　｛　　

　　　　i　=　＋＋created；　　

　　　　if（created　==　47）　　　

　　　　　　System。out。println（〃Created　47〃）；　　

　　｝　　

　　protected　void　finalize（）　｛　　

　　　　if（！gcrun）　｛　　

　　　　　　gcrun　=　true；　　

　　　　　　System。out。println（　　

　　　　　　　　〃Beginning　to　finalize　after　〃　＋　　

　　　　　　　　created　＋　〃　Chairs　have　been　created〃）；　　

　　　　｝　　

　　　　if（i　==　47）　｛　　

　　　　　　System。out。println（　　

　　　　　　　　〃Finalizing　Chair　#47；　〃　＋　　

　　　　　　　　〃Setting　flag　to　stop　Chair　creation〃）；　　

　　　　　　f　=　true；　　

　　　　｝　　

　　　　finalized＋＋；　　

　　　　if（finalized　》=　created）　　

　　　　　　System。out。println（　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　106　


…………………………………………………………Page　108……………………………………………………………

　　　　　　　　〃All　〃　＋　finalized　＋　〃　finalized〃）；　　

　　｝　　

｝　　

　　

public　class　Garbage　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　if（args。length　==　0）　｛　　

　　　　　　System。err。println（〃Usage：　n〃　＋　　

　　　　　　　　〃java　Garbage　beforen　　or：n〃　＋　　

　　　　　　　　〃java　Garbage　after〃）；　　

　　　　　　return；　　

　　　　｝　　

　　　　while　（！Chair。f）　｛　　

　　　　　　new　Chair（）；　　

　　　　　　new　String（〃To　take　up　space〃）；　　

　　　　｝　　

　　　　System。out。println（　　

　　　　　　〃After　all　Chairs　have　been　created：n〃　＋　　

　　　　　　〃total　created　=　〃　＋　Chair。created　＋　　

　　　　　　〃；　total　finalized　=　〃　＋　Chair。finalized）；　　

　　　　if（args＇0＇。equals（〃before〃））　｛　　

　　　　　　System。out。println（〃gc（）：〃）；　　

　　　　　　System。gc（）；　　

　　　　　　System。out。println（〃runFinalization（）：〃）；　　

　　　　　　System。runFinalization（）；　　

　　　　｝　　

　　　　System。out。println（〃bye！〃）；　　

　　　　if（args＇0＇。equals（〃after〃））　　

　　　　　　System。runFinalizersOnExit（true）；　　

　　｝　　

｝　///：~　　

　　

上面这个程序创建了许多Chair　对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建Chair。　

由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为gcrun　

的标记来指出垃圾收集器是否已经开始运行。利用第二个标记　f，Chair　可告诉　main（）它应停止对象的生　

成。这两个标记都是在　finalize（）内部设置的，它调用于垃圾收集期间。　　

另两个　static　变量——created　以及finalized——分别用于跟踪已创建的对象数量以及垃圾收集器已进行　

完收尾工作的对象数量。最后，每个　Chair　都有它自己的（非　static）int　i，所以能跟踪了解它具体的编　

号是多少。编号为47　的Chair　进行完收尾工作后，标记会设为true　，最终结束Chair　对象的创建过程。　　

所有这些都在main（）的内部进行——在下面这个循环里：　　

　　

while（！Chair。f）　｛　　

new　Chair（）；　　

new　String（〃To　take　up　space〃）；　　

｝　　

　　

大家可能会疑惑这个循环什么时候会停下来，因为内部没有任何改变　Chair。f　值的语句。然而，finalize（）　

进程会改变这个值，直至最终对编号　47　的对象进行收尾处理。　　

每次循环过程中创建的　String　对象只是属于额外的垃圾，用于吸引垃圾收集器——一旦垃圾收集器对可用内　

存的容量感到“紧张不安”，就会开始关注它。　　

运行这个程序的时候，提供了一个命令行自变量“before”或者“after”。其中，“before”自变量会调用　

System。gc（）方法（强制执行垃圾收集器），同时还会调用　System。runFinalization（）方法，以便进行收尾　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　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　的每个对象都会获得相同的初始化值。　

有时，这正是我们希望的结果，但有时却需要盼望更大的灵活性。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　1