《Java编程思想第4版[中文版](PDF格式)》第59章

prt（〃char　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
void　testByte（）　｛
byte　x　=　0；
prt（〃byte　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
void　testShort（）　｛
short　x　=　0；
prt（〃short　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
void　testInt（）　｛
int　x　=　0；
prt（〃int　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
void　testLong（）　｛
long　x　=　0；
prt（〃long　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
void　testFloat（）　｛
float　x　=　0；
99　
…………………………………………………………Page　101……………………………………………………………
prt（〃float　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
void　testDouble（）　｛
double　x　=　0；
prt（〃double　argument：〃）；
f1（x）；f2（x）；f3（x）；f4（x）；f5（x）；f6（x）；f7（x）；
｝
public　static　void　main（String＇＇　args）　｛
PrimitiveOverloading　p　=
new　PrimitiveOverloading（）；
p。testConstVal（）；
p。testChar（）；
p。testByte（）；
p。testShort（）；
p。testInt（）；
p。testLong（）；
p。testFloat（）；
p。testDouble（）；
｝
｝　///：~
若观察这个程序的输出，就会发现常数值　5　被当作一个　int值处理。所以假若可以使用一个过载的方法，就　
能获取它使用的int值。在其他所有情况下，若我们的数据类型“小于”方法中使用的自变量，就会对那种　
数据类型进行“转型”处理。char　获得的效果稍有些不同，这是由于假期它没有发现一个准确的　char　匹　
配，就会转型为　int。
若我们的自变量“大于”过载方法期望的自变量，这时又会出现什么情况呢？对前述程序的一个修改揭示出　
了答案：
//：　Demotion。java
//　Demotion　of　primitives　and　overloading
public　class　Demotion　｛
static　void　prt（String　s）　｛
System。out。println（s）；
｝
void　f1（char　x）　｛　prt（〃f1（char）〃）；　｝
void　f1（byte　x）　｛　prt（〃f1（byte）〃）；　｝
void　f1（short　x）　｛　prt（〃f1（short）〃）；　｝
void　f1（int　x）　｛　prt（〃f1（int）〃）；　｝
void　f1（long　x）　｛　prt（〃f1（long）〃）；　｝
void　f1（float　x）　｛　prt（〃f1（float）〃）；　｝
void　f1（double　x）　｛　prt（〃f1（double）〃）；　｝
void　f2（char　x）　｛　prt（〃f2（char）〃）；　｝
void　f2（byte　x）　｛　prt（〃f2（byte）〃）；　｝
void　f2（short　x）　｛　prt（〃f2（short）〃）；　｝
void　f2（int　x）　｛　prt（〃f2（int）〃）；　｝
void　f2（long　x）　｛　prt（〃f2（long）〃）；　｝
void　f2（float　x）　｛　prt（〃f2（float）〃）；　｝
100　
…………………………………………………………Page　102……………………………………………………………
void　f3（char　x）　｛　prt（〃f3（char）〃）；　｝
void　f3（byte　x）　｛　prt（〃f3（byte）〃）；　｝
void　f3（short　x）　｛　prt（〃f3（short）〃）；　｝
void　f3（int　x）　｛　prt（〃f3（　int）〃）；　｝
void　f3（long　x）　｛　prt（〃f3（long）〃）；　｝
void　f4（char　x）　｛　prt（〃f4（char）〃）；　｝
void　f4（byte　x）　｛　prt（〃f4（byte）〃）；　｝
void　f4（short　x）　｛　prt（〃f4（short）〃）；　｝
void　f4（int　x）　｛　prt（〃f4（int）〃）；　｝
void　f5（char　x）　｛　prt（〃f5（char）〃）；　｝
void　f5（byte　x）　｛　prt（〃f5（byte）〃）；　｝
void　f5（short　x）　｛　prt（〃f5（short）〃）；　｝
void　f6（char　x）　｛　prt（〃f6（char）〃）；　｝
void　f6（byte　x）　｛　prt（〃f6（byte）〃）；　｝
void　f7（char　x）　｛　prt（〃f7（char）〃）；　｝
void　testDouble（）　｛
double　x　=　0；
prt（〃double　argument：〃）；
f1（x）；f2（（float）x）；f3（（long）x）；f4（（int）x）；
f5（（short）x）；f6（（byte）x）；f7（（char）x）；
｝
public　static　void　main（String＇＇　args）　｛
Demotion　p　=　new　Demotion（）；
p。testDouble（）；
｝
｝　///：~
在这里，方法采用了容量更小、范围更窄的主类型值。若我们的自变量范围比它宽，就必须用括号中的类型　
名将其转为适当的类型。如果不这样做，编译器会报告出错。
大家可注意到这是一种“缩小转换”。也就是说，在造型或转型过程中可能丢失一些信息。这正是编译器强　
迫我们明确定义的原因——我们需明确表达想要转型的愿望。
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，那么您也许不知道如何为这两个对象同时?