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

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



惕，认为一切事情都是安全的。如果对两个足够大的　int　值执行乘法运算，结果值就会溢出。下面这个例子　

向大家展示了这一点：　　

　　

//：　Overflow。java　　

//　Surprise！　Java　lets　you　overflow。　　

　　

public　class　Overflow　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　int　big　=　0x7fffffff；　//　max　int　value　　

　　　　prt（〃big　=　〃　＋　big）；　　

　　　　int　bigger　=　big　*　4；　　

　　　　prt（〃bigger　=　〃　＋　bigger）；　　

　　｝　　

　　static　void　prt（String　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

｝　///：~　　

　　

输出结果如下：　　

big　=　2147483647　　

bigger　=　…4　　

　　

而且不会从编译器那里收到出错提示，运行时也不会出现异常反应。爪哇咖啡（Java　）确实是很好的东西，　

但却没有“那么”好！　　

对于　char，byte　或者　short，混合赋值并不需要造型。即使它们执行转型操作，也会获得与直接算术运算相　

同的结果。而在另一方面，将造型略去可使代码显得更加简练。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　83　


…………………………………………………………Page　85……………………………………………………………

大家可以看到，除boolean　以外，任何一种主类型都可通过造型变为其他主类型。同样地，当造型成一种较　

小的类型时，必须留意“缩小转换”的后果。否则会在造型过程中不知不觉地丢失信息。　　



3。2　执行控制　　



Java　使用了　C　的全部控制语句，所以假期您以前用C　或　C＋＋编程，其中大多数都应是非常熟悉的。大多数程　

序化的编程语言都提供了某种形式的控制语句，这在语言间通常是共通的。在Java　里，涉及的关键字包括　

if…else、while、do…while、for　以及一个名为switch　的选择语句。然而，Java　并不支持非常有害的goto　

　（它仍是解决某些特殊问题的权宜之计）。仍然可以进行象goto　那样的跳转，但比典型的　goto　要局限多　

了。　　



3。2。1　　真和假　　



所有条件语句都利用条件表达式的真或假来决定执行流程。条件表达式的一个例子是　A==B　。它用条件运算符　

　“==”来判断A　值是否等于　B　值。该表达式返回　true　或　false。本章早些时候接触到的所有关系运算符都可　

拿来构造一个条件语句。注意　Java　不允许我们将一个数字作为布尔值使用，即使它在　C　和　C＋＋里是允许的　

　（真是非零，而假是零）。若想在一次布尔测试中使用一个非布尔值——比如在if（a）里，那么首先必须用　

一个条件表达式将其转换成一个布尔值，例如　if（a！=0）。　　



3。2。2　ifelse　　



if…else　语句或许是控制程序流程最基本的形式。其中的　else　是可选的，所以可按下述两种形式来使用　if：　　

　　

if（布尔表达式）　　

语句　　

　　

或者　　

　　

if（布尔表达式）　　

语句　　

else　　

语句　　

　　

条件必须产生一个布尔结果。“语句”要么是用分号结尾的一个简单语句，要么是一个复合语句——封闭在　

括号内的一组简单语句。在本书任何地方，只要提及“语句”这个词，就有可能包括简单或复合语句。　　

作为　if…else　的一个例子，下面这个　test（）方法可告诉我们猜测的一个数字位于目标数字之上、之下还是相　

等：　　

　　

static　int　test（int　testval）　｛　　

　　int　result　=　0；　　

　　if（testval　》　target）　　

　　　　result　=　…1；　　

　　else　if（testval　《　target）　　

　　　　result　=　＋1；　　

　　else　　

　　　　result　=　0；　//　match　　

　　return　result；　　

｝　　

　　

最好将流程控制语句缩进排列，使读者能方便地看出起点与终点。　　

　　

1。　return　　

return　关键字有两方面的用途：指定一个方法返回什么值（假设它没有　void　返回值），并立即返回那个　

值。可据此改写上面的　test（）方法，使其利用这些特点：　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　84　


…………………………………………………………Page　86……………………………………………………………

　　

static　int　test2（int　testval）　｛　　

　　if（testval　》　target）　　

　　　　return　…1；　　

　　if（testval　《　target）　　

　　　　return　＋1；　　

　　return　0；　//　match　　

｝　　

　　

不必加上else，因为方法在遇到　return　后便不再继续。　　



3。2。3　　反复　　



while，do…while　和　for　控制着循环，有时将其划分为“反复语句”。除非用于控制反复的布尔表达式得到　

　“假”的结果，否则语句会重复执行下去。while　循环的格式如下：　　

　　

while（布尔表达式）　　

语句　　

　　

在循环刚开始时，会计算一次“布尔表达式”的值。而对于后来每一次额外的循环，都会在开始前重新计算　

一次。　　

下面这个简单的例子可产生随机数，直到符合特定的条件为止：　　

　　

//：　WhileTest。java　　

//　Demonstrates　the　while　loop　　

　　

public　class　WhileTest　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　double　r　=　0；　　

　　　　while（r　《　0。99d）　｛　　

　　　　　　r　=　Math。random（）；　　

　　　　　　System。out。println（r）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

它用到了Math　库里的　static　（静态）方法random（）　。该方法的作用是产生　0　和　1　之间（包括　0，但不包括　

1）的一个double值。while　的条件表达式意思是说：“一直循环下去，直到数字等于或大于0。99”。由于　

它的随机性，每运行一次这个程序，都会获得大小不同的数字列表。　　



3。2。4　dowhile　　



do…while　的格式如下：　　

　　

do　　

语句　　

while（布尔表达式）　　

　　

while　和　do…while　唯一的区别就是do…while　肯定会至少执行一次；也就是说，至少会将其中的语句“过一　

遍”——即便表达式第一次便计算为false。而在while　循环结构中，若条件第一次就为false，那么其中的　

语句根本不会执行。在实际应用中，while　比do…while　更常用一些。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　85　


…………………………………………………………Page　87……………………………………………………………

3。2。5　for　　



for　循环在第一次反复之前要进行初始化。随后，它会进行条件测试，而且在每一次反复的时候，进行某种　

形式的“步进”（Stepping　）。for　循环的形式如下：　　

　　

for（初始表达式　；　布尔表达式　；　步进）　　

语句　　

　　

无论初始表达式，布尔表达式，还是步进，都可以置空。每次反复前，都要测试一下布尔表达式。若获得的　

结果是　false，就会继续执行紧跟在　for　语句后面的那行代码。在每次循环的末尾，会计算一次步进。　　

for　循环通常用于执行“计数”任务：　　

　　

//：　ListCharacters。java　　

//　Demonstrates　〃for〃　loop　by　listing　　

//　all　the　ASCII　characters。　　

　　

public　class　ListCharacters　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　for（　char　c　=　0；　c　《　128；　c＋＋）　　

　　　　if　（c　！=　26　）　　//　ANSI　Clear　screen　　

　　　　　　System。out。println（　　

　　　　　　　　〃value：　〃　＋　（int）c　＋　　

　　　　　　　　〃　character：　〃　＋　c）；　　

　　｝　　

｝　///：~　　

　　

注意变量c　是在需要用到它的时候定义的——在　for　循环的控制表达式内部，而非在由起始花括号标记的代　

码块的最开头。c　的作用域是由for　控制的表达式。　　

以于象C　这样传统的程序化语言，要求所有变量都在一个块的开头定义。所以在编译器创建一个块的时候，　

它可以为那些变量分配空间。而在　Java　和C＋＋中，则可在整个块的范围内分散变量声明，在真正需要的地方　

才加以定义。这样便可形成更自然的编码风格，也更易理解。　　

可在for　语句里定义多个变量，但它们必须具有同样的类型：　　

　　

for（int　i　=　0；　j　=　1；　　

　　　　i　《　10　&&　j　！=　11；　　

　　　　i＋＋；　j＋＋）　　

　/*　body　of　for　loop　*/；　　

　　

其中，for　语句内的　int定义同时覆盖了　i　和　j。只有　for　循环才具备在控制表达式里定义变量的能力。对于　

其他任何条件或循环语句，都不可采用这种方法。　　

　　

1。　逗号运算符　　

早在第　1　章，我们已提到了逗号运算符——注意不是逗号分隔符；后者用于分隔函数的不同自变量。Java　里　

唯一用到逗号运算符的地方就是for　循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可使　

用一系列由逗号分隔的语句。而且那些语句均会独立执行。前面的例子已运用了这种能力，下面则是另一个　

例子：　　

　　

//：　maOperator。java　　

　　

public　class　maOperator　｛　　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　for（int　i　=　1；　j　=　i　＋　10；　i　《　5；　　

　　　　　　　　i＋＋；　j　=　i　*　2）　｛　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　86　


…………………………………………………………Page　88……………………………………………………………

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

　　　　｝　　

　　｝　　

｝　///：~　　

　　

输出如下：　　

　　

i=　1　j=　11　　

i=　2　j=　4　　

i=　3　j=　6　　

i=　4　j=　8　　

　　

大家可以看到，无论在初始化还是在步进部分，语句都是顺序执行的。此外，尽管初始化部分可设置任意数　

量的定义，但都属于同一类型。　　



3。2。6　　中断和继续　　



在任何循环语句的主体部分，亦可用break　和　continue　控制循环的流程。其中，break　用于强行退出循环，　

不执行循环中剩余的语句。而　continue　则停止执行当前的反复，然后退回循环起始和，开始新的反复。　　

下面这个程序向大家展示了break　和　continue　在　for　和　while　循环中的例子：　　

　　

//：　BreakAndContinue。java　　

//　Demonstrates　break　and　continue　keywords　　

　　

public　class　BreakAndContinue　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　for（int　i　=　0；　i　《　100；　i＋＋）　｛　　

　　　　　　if（i　==　74）　break；　//　Out　of　for　loop　　

　　　　　　if（i　％　9　！=　0）　continue；　//　Next　iteration　　

　　　　　　System。out。print　ln（i）；　　

　　　　｝　　

　　　　int　i　=　0；　　

　　　　//　An　〃infinite　loop〃：　　

　　　　while（true）　｛　　

　　　　　　i＋＋；　　

　　　　　　int　j　=　i　*　27；　　

　　　　　　if（j　==　1269）　break；　//　Out　of　loop　　

　　　　　　if（i　％　10　！=　0）　continue；　//　Top　of　loop　　

　　　　　　System。out。println（i）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

在这个　for　循环中，i　的值永远不会到达　100。因为一旦　i到达74，break　语句就会中断循环。通常，只有在　

不知道中断条件何时满足时，才需象这样使用　break。只要　i　不能被　9　整除，continue　语句会使程序流程返　

回循环的最开头执行（所以使i　值递增）。如果能够整除，则将值显示出来。　　

第二部分向大家揭示了一个“无限循环”的情况。然而，循环内部有一个　break　语句，可中止循环。除此以　

外，大家还会看到　continue　移回循环顶部，同时不完成剩余的内容（所以只有在　i　值能被　9　整除时才打印出　

值）。输出结果如下：　　

　　

0　　

9　　

18　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　87　


…………………………………………………………Page　89……………………………………………………………

27　　

36　　

45　　

54　　

63　　

72　　

10　　

20　　

30　　

40　　

　　

之所以显示　0，是由于0％9　等于0。　　

无限循环的第二种形式是for（；；）。编译器将while（true）与　for（；；）看作同一回事。所以具体选用哪个取决　

于自己的编程习惯。　　

　　

1。　臭名昭著的“goto”　　

goto　关键字很早就在程序设计语言中出现。事实上，goto　是汇编语言的程序控制结构的始祖：“若条件　A，　

则跳到这里；否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码，就会发现程序控制里包含了许多　

跳转。然而，goto　是在源码的级别跳转的，所以招致了不好的声誉。若程序总是从一个地方跳到另一个地　

方，还有什么办法能识别代码的流程呢？随着　Edsger　Dijkstra　著名的“Goto　有害”论的问世，goto　便从此　

失宠。　　

事实上，真正的问题并不在于使用　goto，而在于goto　的滥用。而且在一些少见的情况下，goto　是组织控制　

流程的最佳手段。　　

尽管goto　仍是Java　的一个保留字，但并未在语言中得到正式使用；Java　没有goto。然而，在break　和　

continue　这两个关键字的身上，我们仍然能看出一些goto　的影子。它并不属于一次跳转，而是中断循环语　

句的一种方法。之所以把它们纳入　goto　问题中一起讨论，是由于它们使用了相同的机制：标签。　　

　“标签”是后面跟一个冒号的标识符，就象下面这样：　　

label1：　　

对Java　来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语句的前方——在　

标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另　

一个循环或者一个开关。这是由于　break　和　continue　关键字通常只中断当前循环，但若随同标签使用，它们　

就会中断到存在标签的地方。如下所示：　　

　　

label1：　　

外部循环｛　　

内部循环｛　　

//。。。　　

break；　//1　　

//。。。　　

continue；　//2　　

//。。。　　

continue　label1；　//3　　

//。。。　　

break　label1；　//4　　

｝　　

｝　　

　　

在条件　1　中，break　中断内部循环，并在外部循环结束。在条件2　中，continue　移回内部循环的起始处。但　

在条件　3　中，continue　label1　却同时中断内部循环以及外部循环，并移至label1　处。随后，它实际是继续　

循环，但却从外部循环开始。在条件4　中，break　label1　也会中断所有循环，并回到　label1　处，但并不重　

新进入循环。也就是说，它实际是完全中止了两个循环。　　

下面是for　循环的一个例子：　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　88　


…………………………………………………………Page　90……………………………………………………………

　　

//：　LabeledFor。java　　

//　Java’s　〃labeled　for　loop〃　　

　　

public　class　LabeledFor　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　int　i　=　0；　　

　　　　outer：　//　Can't　have　statements　here　　

　　　　for（；　true　；）　｛　//　infinite　loop　　

　　　　　　inner：　//　Can't　have　statements　here　　

　　　　　　for（；　i　《　10；　i＋＋）　｛　　

　　　　　　　　prt（〃i　=　〃　＋　i）；　　

　　　　　　　　if（i　==　2）　｛　　

　　　　　　　　　　prt（〃continue〃）；　　

　　　　　　　　　　continue；　　

　　　　　　　　｝　　

　　　　　　　　if（i　==　3）　｛　　

　　　　　　　　　　prt（〃break〃）；　　

　　　　　　　　　　i＋＋；　//　Otherwise　i　never　　

　　　　　　　　　　　　　　　//　gets　incremented。　　

　　　　　　　　　　break；　　

　　　　　　　　｝　　

　　　　　　　　if（i　==　7）　｛　　

　　　　　　　　　　prt（〃continue　outer〃）；　　

　　　　　　　　　　i＋＋；　//　Otherwise　i　never　　

　　　　　　　　　　　　　　　//　gets　incremented。　　

　　　　　　　　　　continue　outer；　　

　　　　　　　　｝　　

　　　　　　　　if（i　==　8）　｛　　

　　　　　　　　　　prt（〃break　outer〃）；　　

　　　　　　　　　　break　outer；　　

　　　　　　　　｝　　

　　　　　　　　for（int　k　=　0；　k　《　5；　k＋＋）　｛　　

　　　　　　　　　　if（k　==　3）　｛　　

　　　　　　　　　　　　prt（〃continue　inner〃）；　　

　　　　　　　　　　　　continue　inner；　　

　　　　　　　　　　｝　　

　　　　　　　　｝　　

　　　　　　｝　　

　　　　｝　　

　　　　//　Can't　break　or　continue　　

　　　　//　to　labels　here　　

　　｝　　

　　static　void　prt（String　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

｝　///：~　　

　　

这里用到了在其他例子中已经定义的prt（）方法。　　

注意break　会中断　for　循环，而且在抵达　for　循环的末尾之前，递增表达式不会执行。由于　break　跳过了递　

增表达式，所以递增会在　i==3　的情况下直接执行。在　i==7　的情况下，continue　outer　语句也会到达循环顶　

部，而且也会跳过递增，所以它也是直接递增的。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　89　


…………………………………………………………Page　91……………………………………………………………

下面是输出结果：　　

　　

i　=　0　　

continue　inner　　

i　=　1　　

continue　inner　　

i　=　2　　

continue　　

i　=　3　　

break　　

i　=　4　　

continue　inner　　

i　=　5　　

continue　inner　　

i　=　6　　

continue　inner　　

i　=　7　　

continue　outer　　

i　=　8　　

break　outer　　

　　

如果没有break　outer　语句，就没有办法在一个内部循环里找到出外部循环的路径。这是由于break　本身只　

能中断最内层的循环（对于continue　同样如此）。　　

当然，若想在中断循环的同时退出方法，简单地用一个return　即可。　　

下面这个例子向大家展示了带标签的break　以及continue　语句在　while　循环中的用法：　　

　　

//：　LabeledWhile。java　　

//　Java's　〃labeled　while〃　loop　　

　　

public　class　LabeledWhile　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　int　i　=　0；　　

　　　　outer：　　

　　　　while（true）　｛　　

　　　　　　prt（〃Outer　while　loop〃）；　　

　　　　　　while（true）　｛　　

　　　　　　　　i＋＋；　　

　　　　　　　　prt（〃i　=　〃　＋　i）；　　

　　　　　　　　if（i　==　1）　｛　　

　　　　　　　　　　prt（〃continue〃）；　　

　　　　　　　　　　continue；　　

　　　　　　　　｝　　

　　　　　　　　if（i　==　3）　｛　　

　　　　　　　　　　prt（〃continue　outer〃）；　　

　　　　　　　　　　continue　outer；　　

　　　　　　　　｝　　

　　　　　　　　if（i　==　5）　｛　　

　　　　　　　　　　prt（〃break〃）；　　

　　　　　　　　　　break；　　

　　　　　　　　｝　　

　　　　　　　　if（i　==　7）　｛　　

　　　　　　　　　　prt（〃break　outer〃）；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　90　


…………………………………………………………Page　92……………………………………………………………

　　　　　　　　　　break　outer；　　

　　　　　　　　｝　　

　　　　　　｝　　

　　　　｝　　

　　｝　　

　　static　void　prt（String　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

｝　///：~　　

　　

同样的规则亦适用于while：　　

（1）　简单的一个　continue　会退回最内层循环的开头（顶部），并继续执行。　　

（2）　带有标签的　continue　会到达标签的位置，并重新进入紧接在那个标签后面的循环。　　

（3）　break　会中断当前循环，并移离当前标签的末尾。　　

（4）　带标签的break　会中断当前循环，并移离由那个标签指示的循环的末尾。　　

这个方法的输出结果是一目了然的：　　

　　

Outer　while　loop　　

i　=　1　　

continue　　

i　=　2　　

i　=　3　　

continue　outer　　

Outer