java中的方法和类2.docx
- 文档编号:7279738
- 上传时间:2023-05-11
- 格式:DOCX
- 页数:32
- 大小:32.06KB
java中的方法和类2.docx
《java中的方法和类2.docx》由会员分享,可在线阅读,更多相关《java中的方法和类2.docx(32页珍藏版)》请在冰点文库上搜索。
java中的方法和类2
第7章进一步研究方法和类
在本章中我们接着上一章继续研究方法和类。
我们先研究几个有关方法的主题,包括方法重载、参数传递和递归。
然后研究类,讨论存取控制,关键字static的用法,以及Java最重要的内置类之一:
String。
7.1方法重载
在Java中,同一个类中的2个或2个以上的方法可以有同一个名字,只要它们的参数声明不同即可。
在这种情况下,该方法就被称为重载(overloaded),这个过程称为方法重载(methodoverloading)。
方法重载是Java实现多态性的一种方式。
如果你以前从来没有使用过一种允许方法重载的语言,这个概念最初可能有点奇怪。
但是你将看到,方法重载是Java最激动人心和最有用的特性之一。
当一个重载方法被调用时,Java用参数的类型和(或)数量来表明实际调用的重载方法的版本。
因此,每个重载方法的参数的类型和(或)数量必须是不同的。
虽然每个重载方法可以有不同的返回类型,但返回类型并不足以区分所使用的是哪个方法。
当Java调用一个重载方法时,参数与调用参数匹配的方法被执行。
下面是一个说明方法重载的简单例子:
//Demonstratemethodoverloading.
classOverloadDemo{
voidtest(){
System.out.println("Noparameters");
}
//Overloadtestforoneintegerparameter.
voidtest(inta){
System.out.println("a:
"+a);
}
//Overloadtestfortwointegerparameters.
voidtest(inta,intb){
System.out.println("aandb:
"+a+""+b);
}
//overloadtestforadoubleparameter
doubletest(doublea){
System.out.println("doublea:
"+a);
returna*a;
}
}
classOverload{
publicstaticvoidmain(Stringargs[]){
OverloadDemoob=newOverloadDemo();
doubleresult;
//callallversionsoftest()
ob.test();
ob.test(10);
ob.test(10,20);
result=ob.test(123.25);
System.out.println("Resultofob.test(123.25):
"+result);
}
}
该程序产生如下输出:
Noparameters
a:
10
aandb:
1020
doublea:
123.25
Resultofob.test(123.25):
15190.5625
从上述程序可见,test()被重载了四次。
第一个版本没有参数,第二个版本有一个整型参数,第三个版本有两个整型参数,第四个版本有一个double型参数。
由于重载不受方法的返回类型的影响,test()第四个版本也返回了一个和重载没有因果关系的值。
当一个重载的方法被调用时,Java在调用方法的参数和方法的自变量之间寻找匹配。
但是,这种匹配并不总是精确的。
在一些情况下,Java的自动类型转换也适用于重载方法的自变量。
例如,看下面的程序:
//Automatictypeconversionsapplytooverloading.
classOverloadDemo{
voidtest(){
System.out.println("Noparameters");
}
//Overloadtestfortwointegerparameters.
voidtest(inta,intb){
System.out.println("aandb:
"+a+""+b);
}
//overloadtestforadoubleparameter
voidtest(doublea){
System.out.println("Insidetest(double)a:
"+a);
}
}
classOverload{
publicstaticvoidmain(Stringargs[]){
OverloadDemoob=newOverloadDemo();
inti=88;
ob.test();
ob.test(10,20);
ob.test(i);//thiswillinvoketest(double)
ob.test(123.2);//thiswillinvoketest(double)
}
}
该程序产生如下输出:
Noparameters
aandb:
1020
Insidetest(double)a:
88
Insidetest(double)a:
123.2
在本例中,OverloadDemo的这个版本没有定义test(int)。
因此当在Overload内带整数参数调用test()时,找不到和它匹配的方法。
但是,Java可以自动地将整数转换为double型,这种转换就可以解决这个问题。
因此,在test(int)找不到以后,Java将i扩大到double型,然后调用test(double)。
当然,如果定义了test(int),当然先调用test(int)而不会调用test(double)。
只有在找不到精确匹配时,Java的自动转换才会起作用。
方法重载支持多态性,因为它是Java实现“一个接口,多个方法”范型的一种方式。
要理解这一点,考虑下面这段话:
在不支持方法重载的语言中,每个方法必须有一个惟一的名字。
但是,你经常希望实现数据类型不同但本质上相同的方法。
可以参考绝对值函数的例子。
在不支持重载的语言中,通常会含有这个函数的三个及三个以上的版本,每个版本都有一个差别甚微的名字。
例如,在C语言中,函数abs()返回整数的绝对值,labs()返回long型整数的绝对值(),而fabs()返回浮点值的绝对值。
尽管这三个函数的功能实质上是一样的,但是因为C语言不支持重载,每个函数都要有它自己的名字。
这样就使得概念情况复杂许多。
尽管每一个函数潜在的概念是相同的,你仍然不得不记住这三个名字。
在Java中就不会发生这种情况,因为所有的绝对值函数可以使用同一个名字。
确实,Java的标准的类库包含一个绝对值方法,叫做abs()。
这个方法被Java的math类重载,用于处理数字类型。
Java根据参数类型决定调用的abs()的版本。
重载的价值在于它允许相关的方法可以使用同一个名字来访问。
因此,abs这个名字代表了它执行的通用动作(generalaction)。
为特定环境选择正确的指定(specific)版本是编译器要做的事情。
作为程序员的你,只需要记住执行的通用操作就行了。
通过多态性的应用,几个名字减少为一个。
尽管这个例子相当简单,但如果你将这个概念扩展一下,你就会理解重载能够帮助你解决更复杂的问题。
当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。
没有什么规定要求重载方法之间必须互相关联。
但是,从风格上来说,方法重载还是暗示了一种关系。
这就是当你能够使用同一个名字重载无关的方法时,你不应该这么做。
例如,你可以使用sqr这个名字来创建一种方法,该方法返回一个整数的平方和一个浮点数值的平方根。
但是这两种操作在功能上是不同的。
按照这种方式应用方法就违背了它的初衷。
在实际的编程中,你应该只重载相互之间关系紧密的操作。
7.1.1构造函数重载
除了重载正常的方法外,构造函数也能够重载。
实际上,对于大多数你创建的现实的类,重载构造函数是很常见的,并不是什么例外。
为了理解为什么会这样,让我们回想上一章中举过的Box类例子。
下面是最新版本的Box类的例子:
classBox{
doublewidth;
doubleheight;
doubledepth;
//ThisistheconstructorforBox.
Box(doublew,doubleh,doubled){
width=w;
height=h;
depth=d;
}
//computeandreturnvolume
doublevolume(){
returnwidth*height*depth;
}
}
在本例中,Box()构造函数需要三个自变量,这意味着定义的所有Box对象必须给Box()构造函数传递三个参数。
例如,下面的语句在当前情况下是无效的:
Boxob=newBox();
因为Box()要求有三个参数,因此如果不带参数的调用它则是一个错误。
这会引起一些重要的问题。
如果你只想要一个盒子而不在乎(或知道)它的原始的尺寸该怎么办?
或,如果你想用仅仅一个值来初始化一个立方体,而该值可以被用作它的所有的三个尺寸又该怎么办?
如果Box类是像现在这样写的,与此类似的其他问题你都没有办法解决,因为你只能带三个参数而没有别的选择权。
幸好,解决这些问题的方案是相当容易的:
重载Box构造函数,使它能处理刚才描述的情况。
下面程序是Box的一个改进版本,它就是运用对Box构造函数的重载来解决这些问题的:
/*Here,Boxdefinesthreeconstructorstoinitialize
thedimensionsofaboxvariousways.
*/
classBox{
doublewidth;
doubleheight;
doubledepth;
//constructorusedwhenalldimensionsspecified
Box(doublew,doubleh,doubled){
width=w;
height=h;
depth=d;
}
//constructorusedwhennodimensionsspecified
Box(){
width=-1;//use-1toindicate
height=-1;//anuninitialized
depth=-1;//box
}
//constructorusedwhencubeiscreated
Box(doublelen){
width=height=depth=len;
}
//computeandreturnvolume
doublevolume(){
returnwidth*height*depth;
}
}
classOverloadCons{
publicstaticvoidmain(Stringargs[]){
//createboxesusingthevariousconstructors
Boxmybox1=newBox(10,20,15);
Boxmybox2=newBox();
Boxmycube=newBox(7);
doublevol;
//getvolumeoffirstbox
vol=mybox1.volume();
System.out.println("Volumeofmybox1is"+vol);
//getvolumeofsecondbox
vol=mybox2.volume();
System.out.println("Volumeofmybox2is"+vol);
//getvolumeofcube
vol=mycube.volume();
System.out.println("Volumeofmycubeis"+vol);
}
}
该程序产生的输出如下所示:
Volumeofmybox1is3000.0
Volumeofmybox2is-1.0
Volumeofmycubeis343.0
在本例中,当new执行时,根据指定的自变量调用适当的构造函数。
7.2把对象作为参数
到目前为止,我们都使用简单类型作为方法的参数。
但是,给方法传递对象是正确的,也是常用的。
例如,考虑下面的简单程序:
//Objectsmaybepassedtomethods.
classTest{
inta,b;
Test(inti,intj){
a=i;
b=j;
}
//returntrueifoisequaltotheinvokingobject
booleanequals(Testo){
if(o.a==a&&o.b==b)returntrue;
elsereturnfalse;
}
}
classPassOb{
publicstaticvoidmain(Stringargs[]){
Testob1=newTest(100,22);
Testob2=newTest(100,22);
Testob3=newTest(-1,-1);
System.out.println("ob1==ob2:
"+ob1.equals(ob2));
System.out.println("ob1==ob3:
"+ob1.equals(ob3));
}
}
该程序产生如下输出:
ob1==ob2:
true
ob1==ob3:
false
在本程序中,在Test中的equals()方法比较两个对象的相等性,并返回比较的结果。
也就是,它把调用的对象与被传递的对象作比较。
如果它们包含相同的值,则该方法返回值为真,否则返回值为假。
注意equals中的自变量o指定Test作为它的类型。
尽管Test是程序中创建的类的类型,但是它的使用与Java的内置类型相同。
对象参数的最普通的使用涉及到构造函数。
你经常想要构造一个新对象,并且使它的初始状态与一些已经存在的对象一样。
为了做到这一点,你必须定义一个构造函数,该构造函数将一个对象作为它的类的一个参数。
例如,下面版本的Box允许一个对象初始化另外一个对象:
//Here,Boxallowsoneobjecttoinitializeanother.
classBox{
doublewidth;
doubleheight;
doubledepth;
//constructcloneofanobject
Box(Boxob){//passobjecttoconstructor
width=ob.width;
height=ob.height;
depth=ob.depth;
}
//constructorusedwhenalldimensionsspecified
Box(doublew,doubleh,doubled){
width=w;
height=h;
depth=d;
}
//constructorusedwhennodimensionsspecified
Box(){
width=-1;//use-1toindicate
height=-1;//anuninitialized
depth=-1;//box
}
//constructorusedwhencubeiscreated
Box(doublelen){
width=height=depth=len;
}
//computeandreturnvolume
doublevolume(){
returnwidth*height*depth;
}
}
classOverloadCons2{
publicstaticvoidmain(Stringargs[]){
//createboxesusingthevariousconstructors
Boxmybox1=newBox(10,20,15);
Boxmybox2=newBox();
Boxmycube=newBox(7);
Boxmyclone=newBox(mybox1);
doublevol;
//getvolumeoffirstbox
vol=mybox1.volume();
System.out.println("Volumeofmybox1is"+vol);
//getvolumeofsecondbox
vol=mybox2.volume();
System.out.println("Volumeofmybox2is"+vol);
//getvolumeofcube
vol=mycube.volume();
System.out.println("Volumeofcubeis"+vol);
//getvolumeofclone
vol=myclone.volume();
System.out.println("Volumeofcloneis"+vol);
}
}
在本程序中你能看到,当你开始创建你自己的类的时候,为了方便高效的构造对象,必须为同一构造函数方法提供多种形式。
7.3参数是如何传递的
总的来说,计算机语言给子程序传递参数的方法有两种。
第一种方法是按值传递(call-by-value)。
这种方法将一个参数值(value)复制成为子程序的正式参数。
这样,对子程序的参数的改变不影响调用它的参数。
第二种传递参数的方法是引用调用(call-by-reference)。
在这种方法中,参数的引用(而不是参数值)被传递给子程序参数。
在子程序中,该引用用来访问调用中指定的实际参数。
这样,对子程序参数的改变将会影响调用子程序的参数。
你将看到,根据传递的对象不同,Java将使用这两种不同的方法。
在Java中,当你给方法传递一个简单类型时,它是按值传递的。
因此,接收参数的子程序参数的改变不会影响到该方法之外。
例如,看下面的程序:
//Simpletypesarepassedbyvalue.
classTest{
voidmeth(inti,intj){
i*=2;
j/=2;
}
}
classCallByValue{
publicstaticvoidmain(Stringargs[]){
Testob=newTest();
inta=15,b=20;
System.out.println("aandbbeforecall:
"+
a+""+b);
ob.meth(a,b);
System.out.println("aandbaftercall:
"+
a+""+b);
}
}
该程序的输出如下所示:
aandbbeforecall:
1520
aandbaftercall:
1520
可以看出,在meth()内部发生的操作不影响调用中a和b的值。
它们的值没在本例中没有变为30和10。
当你给方法传递一个对象时,这种情形就会发生戏剧性的变化,因为对象是通过引用传递的。
记住,当你创建一个类类型的变量时,你仅仅创建了一个类的引用。
因此,当你将这个引用传递给一个方法时,接收它的参数将会指向该参数指向的同一个对象。
这有力地证明了对象是通过引用调用传递给方法的。
该方法中对象的改变确实影响了作为参数的对象。
例如,考虑下面的程序:
//Objectsarepassedbyreference.
classTest{
inta,b;
Test(inti,intj){
a=i;
b=j;
}
//passanobject
voidmeth(Testo){
o.a*=2;
o.b/=2;
}
}
classCallByRef{
publicstaticvoidmain(Stringargs[]){
Testob=newTest(15,20);
System.out.println("ob.aandob.bbeforecall:
"+
ob.a+""+ob.b);
ob.meth(ob);
System.out.println("ob.aandob.baftercall:
"+
ob.a+""+ob.b);
}
}
该程序产生下面的输出:
ob.aandob.bbeforecall:
1520
ob.aandob.baftercall:
3010
正如你所看到的,在这个例子中,在meth()中的操作影响了作为参数的对象。
有趣的一点是,当一个对象引用被传递给方法时,引用本身使用按值调用被传递。
但是,因为被传递的值指向一个对象,该值的拷贝仍然指向它相应的参数所指向的同一个对象。
注意:
当一个简单类型传递给一个方法时,使用按值传递。
对象传递则按引用传。
7.4返回对象
方法能够返回任何类型的数据,包括你创建的类的类型。
例如,在下面的程序中,incrByTen()方法返回一个对象,在该对象中的值a比调用对象中的值a大10。
//Returninganobject.
classTest{
inta;
Test(inti){
a=i;
}
TestincrByTen(){
Testtemp=newTest(a+10);
returntemp;
}
}
classRetOb{
publicstaticvoidmain(Stringargs[]){
Testob1=newTest
(2);
Testob2;
ob2=ob1.incrByTen();
System.out.println("ob1.a:
"+ob1.a);
System.out.println("ob2.a:
"+ob2.a);
ob2=ob2.incrByTen();
System.out.println("ob2.aaftersecondincrease:
"
+ob2.
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- java 中的 方法
![提示](https://static.bingdoc.com/images/bang_tan.gif)