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

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


环境变量决定的。在我的机器上，它是：　　

CLASSPATH=。；D：JAVA　LIB；C：DOCJavaT　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　125　


…………………………………………………………Page　127……………………………………………………………

可以看出，CLASSPATH　里能包含大量备用的搜索路径。然而，使用　JAR　文件时要注意一个问题：必须将JAR　

文件的名字置于类路径里，而不仅仅是它所在的路径。所以对一个名为grape。jar　的JAR　文件来说，我们的　

类路径需要包括：　　

CLASSPATH=。；D：JAVA　LIB；C：flavorsgrape。jar　　

正确设置好类路径后，可将下面这个文件置于任何目录里（若在执行该程序时遇到麻烦，请参见第3　章的　

3。1。2　小节“赋值”）：　　

　　

//：　LibTest。java　　

//　Uses　the　library　　

package　c05；　　

import　。bruceeckel。util。*；　　

　　

public　class　LibTest　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Vector　v　=　new　Vector（）；　　

　　　　List　l　=　new　List（）；　　

　　｝　　

｝　///：~　　

　　

编译器遇到　import语句后，它会搜索由CLASSPATH　指定的目录，查找子目录　bruceeckelutil，然后查　

找名称适当的已编译文件（对于Vector　是Vector。class，对于　List　则是List。class）。注意Vector　和　

List　内无论类还是需要的方法都必须设为public。　　

　　

1。　自动编译　　

为导入的类首次创建一个对象时（或者访问一个类的static　成员时），编译器会在适当的目录里寻找同名　

的。class　文件（所以如果创建类　X　的一个对象，就应该是　X。class）。若只发现X。class，它就是必须使用　

的那一个类。然而，如果它在相同的目录中还发现了一个　X。java，编译器就会比较两个文件的日期标记。如　

果X。java　比X。class　新，就会自动编译　X。java，生成一个最新的　X。class。　　

对于一个特定的类，或在与它同名的。java　文件中没有找到它，就会对那个类采取上述的处理。　　

　　

2。　冲突　　

若通过*导入了两个库，而且它们包括相同的名字，这时会出现什么情况呢？例如，假定一个程序使用了下述　

导入语句：　　

import　。bruceeckel。util。*；　　

import　java。util。*；　　

由于java。util。*也包含了一个Vector　类，所以这会造成潜在的冲突。然而，只要冲突并不真的发生，那么　

就不会产生任何问题——这当然是最理想的情况，因为否则的话，就需要进行大量编程工作，防范那些可能　

可能永远也不会发生的冲突。　　

如现在试着生成一个Vector，就肯定会发生冲突。如下所示：　　

Vector　v　=　new　Vector（）；　　

它引用的到底是哪个Vector　类呢？编译器对这个问题没有答案，读者也不可能知道。所以编译器会报告一个　

错误，强迫我们进行明确的说明。例如，假设我想使用标准的　Java　Vector，那么必须象下面这样编程：　　

java。util。Vector　v　=　new　java。util。Vector（）；　　

由于它（与CLASSPATH　一起）完整指定了那个Vector　的位置，所以不再需要　import　java。util。*语句，除　

非还想使用来自java。util　的其他东西。　　



5。1。2　　自定义工具库　　



掌握前述的知识后，接下来就可以开始创建自己的工具库，以便减少或者完全消除重复的代码。例如，可为　

System。out。println（）创建一个别名，减少重复键入的代码量。它可以是名为　tools　的一个包（package）的　

一部分：　　

　　

//：　P。java　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　126　


…………………………………………………………Page　128……………………………………………………………

//　The　P。rint　&　P。rintln　shorthand　　

package　。bruceeckel。tools；　　

　　

public　class　P　｛　　

　　public　static　void　rint（Object　obj）　｛　　

　　　　System。out。print（obj）；　　

　　｝　　

　　public　static　void　rint（String　s）　｛　　

　　　　System。out。print（s）；　　

　　｝　　

　　public　static　void　rint（char＇＇　s）　｛　　

　　　　System。out。print（s）；　　

　　｝　　

　　public　static　void　rint（char　c）　｛　　

　　　　System。out。print（c）；　　

　　｝　　

　　public　static　void　rint（int　i）　｛　　

　　　　System。out。print（i）；　　

　　｝　　

　　public　static　void　rint（long　l）　｛　　

　　　　System。out。print（l）；　　

　　｝　　

　　public　static　void　rint（float　f）　｛　　

　　　　System。out。print（f）；　　

　　｝　　

　　public　static　void　rint（double　d）　｛　　

　　　　System。out。print（d）；　　

　　｝　　

　　public　static　void　rint（boolean　b）　｛　　

　　　　System。out。print（b）；　　

　　｝　　

　　public　static　void　rintln（）　｛　　

　　　　System。out。println（）；　　

　　｝　　

　　public　static　void　rintln（Object　obj）　｛　　

　　　　System。out。println（obj）；　　

　　｝　　

　　public　static　void　rintln（String　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

　　public　static　void　rintln（char＇＇　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

　　public　static　void　rintln（char　c）　｛　　

　　　　System。out。println（c）；　　

　　｝　　

　　public　static　void　rintln（int　i）　｛　　

　　　　System。out。println（i）；　　

　　｝　　

　　public　static　void　rintln（long　l）　｛　　

　　　　System。out。println（l）；　　

　　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　127　


…………………………………………………………Page　129……………………………………………………………

　　public　static　void　rintln（float　f）　｛　　

　　　　System。out。println（f）；　　

　　｝　　

　　public　static　void　rintln（double　d）　｛　　

　　　　System。out。println（d）；　　

　　｝　　

　　public　static　void　rintln　（boolean　b）　｛　　

　　　　System。out。println（b）；　　

　　｝　　

｝　///：~　　

　　

所有不同的数据类型现在都可以在一个新行输出（P。rintln（）），或者不在一个新行输出（P。rint（）　）。　　

大家可能会猜想这个文件所在的目录必须从某个CLASSPATH　位置开始，然后继续/bruceeckel/tools。编　

译完毕后，利用一个　import　语句，即可在自己系统的任何地方使用P。class　文件。如下所示：　　

　　

//：　ToolTest。java　　

//　Uses　the　tools　library　　

import　。bruceeckel。tools。*；　　

　　

public　class　ToolTest　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　P。rintln（〃Available　from　now　on！〃）；　　

　　｝　　

｝　///：~　　

　　

所以从现在开始，无论什么时候只要做出了一个有用的新工具，就可将其加入tools　目录（或者自己的个人　

util　或tools　目录）。　　

　　

1。　CLASSPATH　的陷阱　　

P。java　文件存在一个非常有趣的陷阱。特别是对于早期的　Java　实现方案来说，类路径的正确设定通常都是　

很困难的一项工作。编写这本书的时候，我引入了　P。java　文件，它最初看起来似乎工作很正常。但在某些情　

况下，却开始出现中断。在很长的时间里，我都确信这是　Java　或其他什么在实现时一个错误。但最后，我终　

于发现在一个地方引入了一个程序（即第　17　章要说明的　CodePackager。java），它使用了一个不同的类P。　

由于它作为一个工具使用，所以有时候会进入类路径里；另一些时候则不会这样。但只要它进入类路径，那　

么假若执行的程序需要寻找。bruceeckel。tools　中的类，Java　首先发现的就是CodePackager。java　中的　

P。此时，编译器会报告一个特定的方法没有找到。这当然是非常令人头疼的，因为我们在前面的类　P　里明明　

看到了这个方法，而且根本没有更多的诊断报告可为我们提供一条线索，让我们知道找到的是一个完全不同　

的类（那甚至不是public　的）。　　

乍一看来，这似乎是编译器的一个错误，但假若考察　import　语句，就会发现它只是说：“在这里可能发现了　

P”。然而，我们假定的是编译器搜索自己类路径的任何地方，所以一旦它发现一个P，就会使用它；若在搜　

索过程中发现了“错误的”一个，它就会停止搜索。这与我们在前面表述的稍微有些区别，因为存在一些讨　

厌的类，它们都位于包内。而这里有一个不在包内的P，但仍可在常规的类路径搜索过程中找到。　　

如果您遇到象这样的情况，请务必保证对于类路径的每个地方，每个名字都仅存在一个类。　　



5。1。3　　利用导入改变行为　　



Java　已取消的一种特性是C　的“条件编译”，它允许我们改变参数，获得不同的行为，同时不改变其他任何　

代码。Java　之所以抛弃了这一特性，可能是由于该特性经常在　C　里用于解决跨平台问题：代码的不同部分根　

据具体的平台进行编译，否则不能在特定的平台上运行。由于　Java　的设计思想是成为一种自动跨平台的语　

言，所以这种特性是没有必要的。　　

然而，条件编译还有另一些非常有价值的用途。一种很常见的用途就是调试代码。调试特性可在开发过程中　

使用，但在发行的产品中却无此功能。Alen　Holub　（holub。　）提出了利用包（package）来模仿条件　

编译的概念。根据这一概念，它创建了C　“断定机制”一个非常有用的Java　版本。之所以叫作“断定机　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　128　


…………………………………………………………Page　130……………………………………………………………

制”，是由于我们可以说“它应该为真”或者“它应该为假”。如果语句不同意你的断定，就可以发现相关　

的情况。这种工具在调试过程中是特别有用的。　　

可用下面这个类进行程序调试：　　

　　

//：　Assert。java　　

//　Assertion　tool　for　debugging　　

package　。bruceeckel。tools。debug；　　

　　

public　class　Assert　｛　　

　　private　static　void　perr（String　msg）　｛　　

　　　　System。err。println（msg）；　　

　　｝　　

　　public　final　static　void　is_true（boolean　exp）　｛　　

　　　　if（！exp）　perr（〃Assertion　failed〃）；　　

　　｝　　

　　public　final　static　void　is_false（boolean　exp）｛　　

　　　　if（exp）　perr（〃Assertion　failed〃）；　　

　　｝　　

　　public　final　static　void　　　

　　is_true（boolean　exp；　String　msg）　｛　　

　　　　if（！exp）　perr（〃Assertion　failed：　〃　＋　msg）；　　

　　｝　　

　　public　final　static　void　　　

　　is_false（boolean　exp；　String　msg）　｛　　

　　　　if（exp）　perr（〃Assertion　failed：　〃　＋　msg）；　　

　　｝　　

｝　///：~　　

　　

这个类只是简单地封装了布尔测试。如果失败，就显示出出错消息。在第　9　章，大家还会学习一个更高级的　

错误控制工具，名为“违例控制”。但在目前这种情况下，perr（）方法已经可以很好地工作。　　

如果想使用这个类，可在自己的程序中加入下面这一行：　　

import　。bruceeckel。tools。debug。*；　　

如欲清除断定机制，以便自己能发行最终的代码，我们创建了第二个Assert　类，但却是在一个不同的包里：　　

　　

//：　Assert。java　　

//　Turning　off　the　assertion　output　　　

//　so　you　can　ship　the　program。　　

package　。bruceeckel。tools；　　

　　

public　class　Assert　｛　　

　　public　final　static　void　is_true（boolean　exp）｛｝　　

　　public　final　static　void　is_false（boolean　exp）｛｝　　

　　public　final　static　void　　　

　　is_true（boolean　exp；　String　msg）　｛｝　　

　　public　final　static　void　　　

　　is_false（boolean　exp；　String　msg）　｛｝　　

｝　///：~　　

　　

现在，假如将前一个　import　语句变成下面这个样子：　　

import　。bruceeckel。tools。*；　　

程序便不再显示出断言。下面是个例子：　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　129　


…………………………………………………………Page　131……………………………………………………………

　　

//：　TestAssert。java　　

//　Demonstrating　the　assertion　tool　　

package　c05；　　

//　ment　the　following；　and　unment　the　　

//　subsequent　line　to　change　assertion　behavior：　　

import　。bruceeckel。tools。debug。*；　　

//　import　。bruceeckel。tools。*；　　

　　

public　class　TestAssert　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Assert。is_true（（2　＋　2）　==　5）；　　

　　　　Assert。is_false（（1　＋　1）　==　2）；　　

　　　　Assert。is_true（（2　＋　2）　==　5；　〃2　＋　2　==　5〃）；　　

　　　　Assert。is_false（（1　＋　1）　==　2；　〃1　＋1　！=　2〃）；　　

　　｝　　

｝　///：~　　

　　

通过改变导入的package，我们可将自己的代码从调试版本变成最终的发行版本。这种技术可应用于任何种　

类的条件代码。　　



5。1。4　　包的停用　　



大家应注意这样一个问题：每次创建一个包后，都在为包取名时间接地指定了一个目录结构。这个包必须存　

在（驻留）于由它的名字规定的目录内。而且这个目录必须能从CLASSPATH　开始搜索并发现。最开始的时　

候，package　关键字的运用可能会令人迷惑，因为除非坚持遵守根据目录路径指定包名的规则，否则就会在　

运行期获得大量莫名其妙的消息，指出找不到一个特定的类——即使那个类明明就在相同的目录中。若得到　

象这样的一条消息，请试着将package　语句作为注释标记出去。如果这样做行得通，就可知道问题到底出在　

哪儿。　　



5。2　Java　访问指示符　　



针对类内每个成员的每个定义，Java　访问指示符　poublic，protected　以及private　都置于它们的最前面—　

—无论它们是一个数据成员，还是一个方法。每个访问指示符都只控制着对那个特定定义的访问。这与C＋＋　

存在着显著不同。在C＋＋中，访问指示符控制着它后面的所有定义，直到又一个访问指示符加入为止。　　

通过千丝万缕的联系，程序为所有东西都指定了某种形式的访问。在后面的小节里，大家要学习与各类访问　

有关的所有知识。首次从默认访问开始。