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

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



　　　　n1。i　=　27；　　

　　　　System。out。println（〃3：　n1。i：　〃　＋　n1。i　＋　　

　　　　　　〃；　n2。i：　〃　＋　n2。i）；　　

　　｝　　

｝　///：~　　

　　

Number　类非常简单，它的两个实例（n1　和n2）是在main（）里创建的。每个Number　中的i值都赋予了一个不　

同的值。随后，将n2　赋给n1，而且n1　发生改变。在许多程序设计语言中，我们都希望n1　和n2　任何时候都　

相互独立。但由于我们已赋予了一个句柄，所以下面才是真实的输出：　　

1：　n1。i：　9；　n2。i：　47　　

2：　n1。i：　47；　n2。i：　47　　

3：　n1。i：　27；　n2。i：　27　　

看来改变n1　的同时也改变了n2！这是由于无论n1　还是n2　都包含了相同的句柄，它指向相同的对象（最初　

的句柄位于　n1　内部，指向容纳了值9　的一个对象。在赋值过程中，那个句柄实际已经丢失；它的对象会由　

　“垃圾收集器”自动清除）。　　

这种特殊的现象通常也叫作“别名”，是　Java　操作对象的一种基本方式。但假若不愿意在这种情况下出现别　

名，又该怎么操作呢？可放弃赋值，并写入下述代码：　　

n1。i　=　n2。i；　　

这样便可保留两个独立的对象，而不是将　n1　和n2　绑定到相同的对象。但您很快就会意识到，这样做会使对　

象内部的字段处理发生混乱，并与标准的面向对象设计准则相悖。由于这并非一个简单的话题，所以留待第　

12章详细论述，那一章是专门讨论别名的。其时，大家也会注意到对象的赋值会产生一些令人震惊的效果。　　

　　

1。　方法调用中的别名处理　　

将一个对象传递到方法内部时，也会产生别名现象。　　

　　

//：　PassObject。java　　

//　Passing　objects　to　methods　can　be　a　bit　tricky　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　61　


…………………………………………………………Page　63……………………………………………………………

　　

class　Letter　｛　　

　　char　c；　　

｝　　

　　

public　class　PassObject　｛　　

　　static　void　f（Letter　y）　｛　　

　　　　y。c　=　'z'；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Letter　x　=　new　Letter（）；　　

　　　　x。c　=　'a'；　　

　　　　System。out。println（〃1：　x。c：　〃　＋　x。c）；　　

　　　　f（x）；　　

　　　　System。out。println（〃2：　x。c：　〃　＋　x。c）；　　

　　｝　　

｝　///：~　　

在许多程序设计语言中，f（）方法表面上似乎要在方法的作用域内制作自己的自变量Letter　y　的一个副本。　

但同样地，实际传递的是一个句柄。所以下面这个程序行：　　

y。c　=　'z'；　　

实际改变的是f（）之外的对象。输出结果如下：　　

1：　x。c：　a　　

2：　x。c：　z　　

别名和它的对策是非常复杂的一个问题。尽管必须等至第　12章才可获得所有答案，但从现在开始就应加以重　

视，以便提早发现它的缺点。　　



3。1。3　　算术运算符　　



Java　的基本算术运算符与其他大多数程序设计语言是相同的。其中包括加号（＋）、减号（…）、除号　

　（/）、乘号（*）以及模数（％，从整数除法中获得余数）。整数除法会直接砍掉小数，而不是进位。　　

Java　也用一种简写形式进行运算，并同时进行赋值操作。这是由等号前的一个运算符标记的，而且对于语言　

中的所有运算符都是固定的。例如，为了将4　加到变量x，并将结果赋给x，可用：x＋=4　。　　

下面这个例子展示了算术运算符的各种用法：　　

　　

//：　MathOps。java　　

//　Demonstrates　the　mathematical　operators　　

import　java。util。*；　　

　　

public　class　MathOps　｛　　

　　//　Create　a　shorthand　to　save　typing：　　

　　static　void　prt（String　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

　　//　shorthand　to　print　a　string　and　an　int：　　

　　static　void　pInt（String　s；　int　i）　｛　　

　　　　prt（s　＋　〃　=　〃　＋　i）；　　

　　｝　　

　　//　shorthand　to　print　a　string　and　a　float：　　

　　static　void　pFlt（String　s；　float　f）　｛　　

　　　　prt（s　＋　〃　=　〃　＋　f）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　//　Create　a　random　number　generator；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　62　


…………………………………………………………Page　64……………………………………………………………

　　　　//　seeds　with　current　time　by　default：　　

　　　　Random　rand　=　new　Random（）；　　

　　　　int　i；　j；　k；　　

　　　　//　'％'　limits　maximum　value　to　99：　　

　　　　j　=　rand。nextInt（）　％　100；　　

　　　　k　=　rand。nextInt（）　％　100；　　

　　　　pInt（〃j〃；j）；　　pInt（〃k〃；k）；　　

　　　　i　=　j　＋　k；　pInt（〃j　＋　k〃；　i）；　　

　　　　i　=　j　k；　pInt（〃j　k〃；　i）；　　

　　　　i　=　k　/　j；　pInt（〃k　/　j〃；　i）；　　

　　　　i　=　k　*　j；　pInt（〃k　*　j〃；　i）；　　

　　　　i　=　k　％　j；　pInt（〃k　％　j〃；　i）；　　

　　　　j　％=　k；　pInt（〃j　％=　k〃；　j）；　　

　　　　//　Floating…point　number　tests：　　

　　　　float　u；v；w；　　//　applies　to　doubles；　too　　

　　　　v　=　rand。nextFloat（）；　　

　　　　w　=　rand。nextFloat（）；　　

　　　　pFlt（〃v〃；　v）；　pFlt（〃w〃；　w）；　　

　　　　u　=　v　＋　w；　pFlt（〃v　＋　w〃；　u）；　　

　　　　u　=　v　w；　pFlt（〃v　w〃；　u）；　　

　　　　u　=　v　*　w；　pFlt（〃v　*　w〃；　u）；　　

　　　　u　=　v　/　w；　pFlt（〃v　/　w〃；　u）；　　

　　　　//　the　following　also　works　for　　

　　　　//　char；　byte；　short；　int；　long；　　

　　　　//　and　double：　　

　　　　u　＋=　v；　pFlt（〃u　＋=　v〃；　u）；　　

　　　　u　…=　v；　pFlt（〃u　…=　v〃；　u）；　　

　　　　u　*=　v；　pFlt（〃u　*=　v〃；　u）；　　

　　　　u　/=　v；　pFlt（〃u　/=　v〃；　u）；　　

　　｝　　

｝　///：~　　

　　

我们注意到的第一件事情就是用于打印（显示）的一些快捷方法：prt（）方法打印一个String；pInt（）先打　

印一个String，再打印一个　int；而pFlt（）先打印一个　String，再打印一个float。当然，它们最终都要用　

System。out。println（）结尾。　　

为生成数字，程序首先会创建一个　Random　（随机）对象。由于自变量是在创建过程中传递的，所以Java　将　

当前时间作为一个“种子值”，由随机数生成器利用。通过Random　对象，程序可生成许多不同类型的随机数　

字。做法很简单，只需调用不同的方法即可：nextInt（），nextLong（），nextFloat（）或者nextDouble（）。　　

若随同随机数生成器的结果使用，模数运算符（％　）可将结果限制到运算对象减　1　的上限（本例是99）之　

下。　　

　　

1。　一元加、减运算符　　

一元减号（…）和一元加号（＋）与二元加号和减号都是相同的运算符。根据表达式的书写形式，编译器会自　

动判断使用哪一种。例如下述语句：　　

x　=　…a；　　

它的含义是显然的。编译器能正确识别下述语句：　　

x　=　a　*　…b；　　

但读者会被搞糊涂，所以最好更明确地写成：　　

x　=　a　*　（…b）；　　

一元减号得到的运算对象的负值。一元加号的含义与一元减号相反，虽然它实际并不做任何事情。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　63　


…………………………………………………………Page　65……………………………………………………………

3。1。4　　自动递增和递减　　



和C　类似，Java　提供了丰富的快捷运算方式。这些快捷运算可使代码更清爽，更易录入，也更易读者辨读。　　

两种很不错的快捷运算方式是递增和递减运算符（常称作“自动递增”和“自动递减”运算符）。其中，递　

减运算符是“……”，意为“减少一个单位”；递增运算符是“＋＋”，意为“增加一个单位”。举个例子来　

说，假设A　是一个　int　（整数）值，则表达式＋＋A　就等价于（A　=　A　＋　1）。递增和递减运算符结果生成的是　

变量的值。　　

对每种类型的运算符，都有两个版本可供选用；通常将其称为“前缀版”和“后缀版”。“前递增”表示＋＋　

运算符位于变量或表达式的前面；而“后递增”表示＋＋运算符位于变量或表达式的后面。类似地，“前递　

减”意味着……运算符位于变量或表达式的前面；而“后递减”意味着……运算符位于变量或表达式的后面。对　

于前递增和前递减（如＋＋A　或……A　），会先执行运算，再生成值。而对于后递增和后递减（如A＋＋或A……），　

会先生成值，再执行运算。下面是一个例子：　　

　　

//：　AutoInc。java　　

//　Demonstrates　the　＋＋　and　…operators　　

　　

public　class　AutoInc　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　int　i　=　1；　　

　　　　prt（〃i　：　〃　＋　i）；　　

　　　　prt（〃＋＋i　：　〃　＋　＋＋i）；　//　Pre…increment　　

　　　　prt（〃i＋＋　：　〃　＋　i＋＋）；　//　Post…increment　　

　　　　prt（〃i　：　〃　＋　i）；　　

　　　　prt（〃……i　：　〃　＋　……i）；　//　Pre…decrement　　

　　　　prt（〃i…：　〃　＋　i……）；　//　Post…decrement　　

　　　　prt（〃i　：　〃　＋　i）；　　

　　｝　　

　　static　void　prt（String　s）　｛　　

　　　　System。out。println（s）；　　

　　｝　　

｝　///：~　　

　　

该程序的输出如下：　　

　　

i　：　1　　

＋＋i　：　2　　

i＋＋　：　2　　

i　：　3　　

……i　：　2　　

i…：　2　　

i　：　1　　

　　

从中可以看到，对于前缀形式，我们在执行完运算后才得到值。但对于后缀形式，则是在运算执行之前就得　

到值。它们是唯一具有“副作用”的运算符（除那些涉及赋值的以外）。也就是说，它们会改变运算对象，　

而不仅仅是使用自己的值。　　

递增运算符正是对“C＋＋”这个名字的一种解释，暗示着“超载C　的一步”。在早期的一次Java　演讲中，　

Bill　Joy　（始创人之一）声称“Java=C＋＋……”（C　加加减减），意味着Java　已去除了C＋＋一些没来由折磨人　

的地方，形成一种更精简的语言。正如大家会在这本书中学到的那样，Java　的许多地方都得到了简化，所以　

Java　的学习比C＋＋更容易。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　64　


…………………………………………………………Page　66……………………………………………………………

3。1。5　　关系运算符　　



关系运算符生成的是一个“布尔”（Boolean）结果。它们评价的是运算对象值之间的关系。若关系是真实　

的，关系表达式会生成　true　（真）；若关系不真实，则生成false　（假）。关系运算符包括小于（）、小于或等于（=）、等于（==）以及不等于（！=）。等于和不等于适用于所有内　

建的数据类型，但其他比较不适用于boolean　类型。　　

　　

1。　检查对象是否相等　　

关系运算符==和！=也适用于所有对象，但它们的含义通常会使初涉　Java　领域的人找不到北。下面是一个例　

子：　　

　　

//：　Equivalence。java　　

　　

public　class　Equivalence　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Integer　n1　=　new　Integer（47）；　　

　　　　Integer　n2　=　new　Integer（47）；　　

　　　　System。out。println（n1　==　n2）；　　

　　　　System。out。println（n1　！=　n2）；　　

　　｝　　

｝　///：~　　

　　

其中，表达式System。out。println（n1　==　n2）可打印出内部的布尔比较结果。一般人都会认为输出结果肯定　

先是true，再是　false，因为两个　Integer　对象都是相同的。但尽管对象的内容相同，句柄却是不同的，而　

==和！=比较的正好就是对象句柄。所以输出结果实际上先是false，再是　true。这自然会使第一次接触的人　

感到惊奇。　　

若想对比两个对象的实际内容是否相同，又该如何操作呢？此时，必须使用所有对象都适用的特殊方法　

equals（）。但这个方法不适用于“主类型”，那些类型直接使用==和！=即可。下面举例说明如何使用：　　

　　

//：　EqualsMethod。java　　

　　

public　class　EqualsMethod　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Integer　n1　=　new　Integer（47）；　　

　　　　Integer　n2　=　new　Integer（47）；　　

　　　　System。out。println（n1。equals（n2））；　　

　　｝　　

｝　///：~　　

　　

正如我们预计的那样，此时得到的结果是　true。但事情并未到此结束！假设您创建了自己的类，就象下面这　

样：　　

　　

//：　EqualsMethod2。java　　

　　

class　Value　｛　　

　　int　i；　　

｝　　

　　

public　class　EqualsMethod2　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Value　v1　=　new　Value（）；　　

　　　　Value　v2　=　new　Value（）；　　

　　　　v1。i　=　v2。i　=　100；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　65　


…………………………………………………………Page　67……………………………………………………………

　　　　System。out。println（v1。equals（v2））；　　

　　｝　　

｝　///：~　　

　　

此时的结果又变回了false　！这是由于equals（）的默认行为是比较句柄。所以除非在自己的新类中改变了　

equals（），否则不可能表现出我们希望的行为。不幸的是，要到第　7　章才会学习如何改变行为。但要注意　

equals（）的这种行为方式同时或许能够避免一些“灾难”性的事件。　　

大多数Java　类库都实现了　equals（），所以它实际比较的是对象的内容，而非它们的句柄。　　



3。1。6　　逻辑运算符　　



逻辑运算符　AND　（&&）、OR　（｜｜）以及NOT　（！）能生成一个布尔值（true　或　false）——以自变量的逻辑关　

系为基础。下面这个例子向大家展示了如何使用关系和逻辑运算符。　　

　　

//：　Bool。java　　

//　Relational　and　logical　operators　　

import　java。util。*；　　

　　

public　class　Bool　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Random　rand　=　new　Random（）；　　

　　　　int　i　=　rand。nextInt（）　％　100；　　

　　　　int　j　=　rand。nextInt（）　％　100；　　

　　　　prt（〃i　=　〃　＋　i）；　　

　　　　prt（〃j　=　〃　＋　j）；　　

　　　　prt（〃i　》　j　is　〃　＋　（i　》　j））；　　

　　　　prt（〃i　《　j　is　〃　＋　（i　《　j））；　　

　　　　prt（〃i　》=　j　is　〃　＋　（i　》=　j））；　　

　　　　prt（〃i