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

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


迫我们明确定义的原因——我们需明确表达想要转型的愿望。　　



4。2。3　　返回值过载　　



我们很易对下面这些问题感到迷惑：为什么只有类名和方法自变量列出？为什么不根据返回值对方法加以区　

分？比如对下面这两个方法来说，虽然它们有同样的名字和自变量，但其实是很容易区分的：　　

void　f（）　｛｝　　

int　f（）　｛｝　　

若编译器可根据上下文（语境）明确判断出含义，比如在　int　x=f（）中，那么这样做完全没有问题。然而，　

我们也可能调用一个方法，同时忽略返回值；我们通常把这称为“为它的副作用去调用一个方法”，因为我　

们关心的不是返回值，而是方法调用的其他效果。所以假如我们象下面这样调用方法：　　

f（）；　　

Java　怎样判断f（）的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能　

根据返回值类型来区分过载的方法。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　101　


…………………………………………………………Page　103……………………………………………………………

4。2。4　　默认构建器　　



正如早先指出的那样，默认构建器是没有自变量的。它们的作用是创建一个“空对象”。若创建一个没有构　

建器的类，则编译程序会帮我们自动创建一个默认构建器。例如：　　

　　

//：　DefaultConstructor。java　　

　　

class　Bird　｛　　

　　int　i；　　

｝　　

　　

public　class　DefaultConstructor　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Bird　nc　=　new　Bird（）；　//　default！　　

　　｝　　

｝　///：~　　

　　

对于下面这一行：　　

new　Bird（）；　　

它的作用是新建一个对象，并调用默认构建器——即使尚未明确定义一个象这样的构建器。若没有它，就没　

有方法可以调用，无法构建我们的对象。然而，如果已经定义了一个构建器（无论是否有自变量），编译程　

序都不会帮我们自动合成一个：　　

　　

class　Bush　｛　　

Bush（int　i）　｛｝　　

Bush（double　d）　｛｝　　

｝　　

　　

现在，假若使用下述代码：　　

new　Bush（）；　　

编译程序就会报告自己找不到一个相符的构建器。就好象我们没有设置任何构建器，编译程序会说：“你看　

来似乎需要一个构建器，所以让我们给你制造一个吧。”但假如我们写了一个构建器，编译程序就会说：　

　“啊，你已写了一个构建器，所以我知道你想干什么；如果你不放置一个默认的，是由于你打算省略它。”　　



4。2。5　this　关键字　　



如果有两个同类型的对象，分别叫作a　和b，那么您也许不知道如何为这两个对象同时调用一个f（）方法：　　

　　

class　Banana　｛　void　f（int　i）　｛　/*　。。。　*/　｝　｝　　

Banana　a　=　new　Banana（）；　b　=　new　Banana（）；　　

a。f（1）；　　

b。f（2）；　　

　　

若只有一个名叫f　（）的方法，它怎样才能知道自己是为　a　还是为　b　调用的呢？　　

为了能用简便的、面向对象的语法来书写代码——亦即“将消息发给对象”，编译器为我们完成了一些幕后　

工作。其中的秘密就是第一个自变量传递给方法f（），而且那个自变量是准备操作的那个对象的句柄。所以　

前述的两个方法调用就变成了下面这样的形式：　　

　　

Banana。f（a；1）；　　

Banana。f（b；2）；　　

　　

这是内部的表达形式，我们并不能这样书写表达式，并试图让编译器接受它。但是，通过它可理解幕后到底　

发生了什么事情。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　102　


…………………………………………………………Page　104……………………………………………………………

假定我们在一个方法的内部，并希望获得当前对象的句柄。由于那个句柄是由编译器“秘密”传递的，所以　

没有标识符可用。然而，针对这一目的有个专用的关键字：this。this　关键字（注意只能在方法内部使用）　

可为已调用了其方法的那个对象生成相应的句柄。可象对待其他任何对象句柄一样对待这个句柄。但要注　

意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用this。只需简单地调用那个方法　

即可。当前的this　句柄会自动应用于其他方法。所以我们能使用下面这样的代码：　　

　　

class　Apricot　｛　　

void　pick（）　｛　/*　。。。　*/　｝　　

void　pit（）　｛　pick（）；　/*　。。。　*/　｝　　

｝　　

　　

在pit（）内部，我们可以说　this。pick（），但事实上无此必要。编译器能帮我们自动完成。this　关键字只能　

用于那些特殊的类——需明确使用当前对象的句柄。例如，假若您希望将句柄返回给当前对象，那么它经常　

在return　语句中使用。　　

　　

//：　Leaf。java　　

//　Simple　use　of　the　〃this〃　keyword　　

　　

public　class　Leaf　｛　　

　　private　int　i　=　0；　　

　　Leaf　increment（）　｛　　

　　　　i＋＋；　　

　　　　return　this；　　

　　｝　　

　　void　print（）　｛　　

　　　　System。out。println（〃i　=　〃　＋　i）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Leaf　x　=　new　Leaf（）；　　

　　　　x。increment（）。increment（）。increment（）。print（）；　　

　　｝　　

｝　///：~　　

　　

由于increment（）通过　this　关键字返回当前对象的句柄，所以可以方便地对同一个对象执行多项操作。　　

　　

1。　在构建器里调用构建器　　

若为一个类写了多个构建器，那么经常都需要在一个构建器里调用另一个构建器，以避免写重复的代码。可　

用　this　关键字做到这一点。　　

通常，当我们说this　的时候，都是指“这个对象”或者“当前对象”。而且它本身会产生当前对象的一个句　

柄。在一个构建器中，若为其赋予一个自变量列表，那么　this　关键字会具有不同的含义：它会对与那个自变　

量列表相符的构建器进行明确的调用。这样一来，我们就可通过一条直接的途径来调用其他构建器。如下所　

示：　　

　　

//：　Flower。java　　

//　Calling　constructors　with　〃this〃　　

　　

public　class　Flower　｛　　

　　private　int　petalCount　=　0；　　

　　private　String　s　=　new　String（〃null〃）；　　

　　Flower（int　petals）　｛　　

　　　　petalCount　=　petals；　　

　　　　System。out。println（　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　103　


…………………………………………………………Page　105……………………………………………………………

　　　　　　〃Constructor　w/　int　arg　only；　petalCount=　〃　　

　　　　　　＋　petalCount）；　　

　　｝　　

　　Flower（String　ss）　｛　　

　　　　System。out。println（　　

　　　　　　〃Constructor　w/　String　arg　only；　s=〃　＋　ss）；　　

　　　　s　=　ss；　　

　　｝　　

　　Flower（String　s；　int　petals）　｛　　

　　　　this（petals）；　　

//！　　　　this（s）；　//　Can't　call　two！　　

　　　　this。s　=　s；　//　Another　use　of　〃this〃　　

　　　　System。out。println（〃String　&　int　args〃）；　　

　　｝　　

　　Flower（）　｛　　

　　　　this（〃hi〃；　47）；　　

　　　　System。out。println（　　

　　　　　　〃default　constructor　（no　args）〃）；　　

　　｝　　

　　void　print（）　｛　　

//！　　　　this（11）；　//　Not　inside　non…constructor！　　

　　　　System。out。println（　　

　　　　　　〃petalCount　=　〃　＋　petalCount　＋　〃　s　=　〃＋　s）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Flower　x　=　new　Flower（）；　　

　　　　x。print（）；　　

　　｝　　

｝　///：~　　

　　

其中，构建器Flower（String　s；int　petals）　向我们揭示出这样一个问题：尽管可用this　调用一个构建器，　

但不可调用两个。除此以外，构建器调用必须是我们做的第一件事情，否则会收到编译程序的报错信息。　　

这个例子也向大家展示了this　的另一项用途。由于自变量s　的名字以及成员数据s　的名字是相同的，所以会　

出现混淆。为解决这个问题，可用　this。s来引用成员数据。经常都会在　Java　代码里看到这种形式的应用，　

本书的大量地方也采用了这种做法。　　

在print（）中，我们发现编译器不让我们从除了一个构建器之外的其他任何方法内部调用一个构建器。　　

　　

2。　static　的含义　　

理解了　this　关键字后，我们可更完整地理解　static　（静态）方法的含义。它意味着一个特定的方法没有　

this。我们不可从一个　static方法内部发出对非　static方法的调用（注释②），尽管反过来说是可以的。　

而且在没有任何对象的前提下，我们可针对类本身发出对一个　static方法的调用。事实上，那正是　static　

方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C　语言中）。除了全局函数不允许在　Java　

中使用以外，若将一个　static方法置入一个类的内部，它就可以访问其他static　方法以及　static　字段。　　

　　

②：有可能发出这类调用的一种情况是我们将一个对象句柄传到　static　方法内部。随后，通过句柄（此时实　

际是this），我们可调用非　static方法，并访问非　static　字段。但一般地，如果真的想要这样做，只要制　

作一个普通的、非　static　方法即可。　　

　　

有些人抱怨　static方法并不是“面向对象”的，因为它们具有全局函数的某些特点；利用　static方法，我　

们不必向对象发送一条消息，因为不存在　this。这可能是一个清楚的自变量，若您发现自己使用了大量静态　

方法，就应重新思考自己的策略。然而，static　的概念是非常实用的，许多时候都需要用到它。所以至于它　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　104　


…………………………………………………………Page　106……………………………………………………………

们是否真的“面向对象”，应该留给理论家去讨论。事实上，即使Smalltalk　在自己的“类方法”里也有类　

似于　static　的东西。　　



4。3　清除：收尾和垃圾收集　　



程序员都知道“初始化”的重要性，但通常忘记清除的重要性。毕竟，谁需要来清除一个　int　呢？但是对于　

库来说，用完后简单地“释放”一个对象并非总是安全的。当然，Java　可用垃圾收集器回收由不再使用的对　

象占据的内存。现在考虑一种非常特殊且不多见的情况。假定我们的对象分配了一个“特殊”内存区域，没　

有使用　new。垃圾收集器只知道释放那些由new　分配的内存，所以不知道如何释放对象的“特殊”内存。为　

解决这个问题，Java　提供了一个名为finalize（）的方法，可为我们的类定义它。在理想情况下，它的工作原　

理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用　finalize（），而且只有在下　

一次垃圾收集过程中，才会真正回收对象的内存。所以如果使用finalize（），就可以在垃圾收集期间进行一　

些重要的清除或清扫工作。　　

但也是一个潜在的编程陷阱，因为有些程序员（特别是在　C＋＋开发背景的）刚开始可能会错误认为它就是在　

C＋＋中为“破坏器”（Destructor）使用的finalize（）——破坏（清除）一个对象的时候，肯定会调用这个　

函数。但在这里有必要区分一下C＋＋和　Java　的区别，因为C＋＋的对象肯定会被清除（排开编程错误的因　

素），而Java　对象并非肯定能作为垃圾被“收集”去。或者换句话说：　　

　　

垃圾收集并不等于“破坏”！　　

　　

若能时刻牢记这一点，踩到陷阱的可能性就会大大减少。它意味着在我们不再需要一个对象之前，有些行动　

是必须采取的，而且必须由自己来采取这些行动。Java　并未提供“破坏器”或者类似的概念，所以必须创建　

一个原始的方法，用它来进行这种清除。例如，假设在对象创建过程中，它会将自己描绘到屏幕上。如果不　

从屏幕明确删除它的图像，那么它可能永远都不会被清除。若在finalize（）里置入某种删除机制，那么假设　

对象被当作垃圾收掉了，图像首先会将自身从屏幕上移去。但若未被收掉，图像就会保留下来。所以要记住　

的第二个重点是：　　

　　

我们的对象可能不会当作垃圾被收掉！　　

　　

有时可能发现一个对象的存储空间永远都不会释放，因为自己的程序永远都接近于用光空间的临界点。若程　

序执行结束，而且垃圾收集器一直都没有释放我们创建的任何对象的存储空间，则随着程序的退出，那些资　

源会返回给操作系统。这是一件好事情，因为垃圾收集本身也要消耗一些开销。如永远都不用它，那么永远　

也不用支出这部分开销。　　



4。3。1　finalize（）　用途何在　　



此时，大家可能已相信了自己应该将finalize（）作为一种常规用途的清除方法使用。它有什么好处呢？　　

要记住的第三个重点是：　　

　　

垃圾收集只跟内存有关！　　

　　

也就是说，垃圾收集器存在的唯一原因是为了回收程序不再使用的内存。所以对于与垃圾收集有关的任何活　

动来说，其中最值得注意的是finalize（）方法，它们也必须同内存以及它的回收有关。　　

但这是否意味着假如对象包含了其他对象，finalize（）就应该明确释放那些对象呢？答案是否定的——垃圾　

收集器会负责释放所有对象占据的内存，无论这些对象是如何创建的。它将对finalize（）的需求限制到特殊　

的情况。在这种情况下，我们的对象可采用与创建对象时不同的方法分配一些存储空间。但大家或许会注意　

到，Java　中的所有东西都是对象，所以这到底是怎么一回事呢？　　

之所以要使用finalize（），看起来似乎是由于有时需要采取与Java　的普通方法不同的一种方法，通过分配　

内存来做一些具有C　风格的事情。这主要可以通过“固有方法”来进行，它是从Java　里调用非　Java　方法的　

一种方式（固有方法的问题在附录　A　讨论）。C　和　C＋＋是目前唯一获得固有方法支持的语言。但由于它们能调　

用通过其他语言编写的子程序，所以能够有效地调用任何东西。在非　Java　代码内部，也许能调用　C　的　

malloc（）系列函数，用它分配存储空间。而且除非调用了free（），否则存储空间不会得到释放，从而造成内　

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