JAVA中的final关键字用法实例详解
本文实例讲述了JAVA中的final关键字用法。分享给大家供大家参考,具体如下:
根据上下文环境,java的关键字final也存在着细微的区别,但通常指的是“这是无法改变的。”不想改变的理由有两种:一种是效率,另一种是设计。由于两个原因相差很远,所以关键子final可能被误用。
接下来介绍一下使用到final的三中情况:数据,方法,类
final数据
许多编程语言都有某种方法,来向编译器告知一块数据是恒定不变的。有时数据的恒定不变是很有用的,例如:
1.一个编译时恒定不变的常量
2.一个在运行时初始化,而你不希望它被改变。
对于编译期常量的这种情况,编译器可以将该常量值代入任何可能用到它的计算式中,也就是说,可以在编译期就执行计算式,这减轻了一些运行时的负担。在java中,这类常量必须是基本类型,并且以final表示。在对这个常量定义时,必须进行赋值。
一个即是static又是final的域只占一段不能改变的存储空间。
当final应用于对象引用时,而不是基本类型时,其含义有些让人疑惑。对基本类型使用final不能改变的是他的数值。而对于对象引用,不能改变的是他的引用,而对象本身是可以修改的。一旦一个final引用被初始化指向一个对象,这个引用将不能在指向其他对象。java并未提供对任何对象恒定不变的支持。这一限制也通用适用于数组,它也是对象。例如:
packagefinalPackage; importjava.util.*; classValue{ inti; publicValue(inti){ this.i=i; } } /** *final数据常量 *@authorAdministrator *对基本类型使用final不能改变的是它的数值。 *而对于对象引用,不能改变的是他的引用,而对象本身是可以修改的。 *一旦一个final引用被初始化指向一个对象,这个引用将不能在指向其他对象。 *注意,根据惯例,即是static又是final的域(即编译器常量)将用大写表示,并用下划分割个单词。 */ publicclassFinalData{ privatestaticRandomrand=newRandom(47); privateStringid; publicFinalData(Stringid){ this.id=id; } //编译时常量Canbecompile-timeconstants: privatefinalintvalueOne=9; privatestaticfinalintVALUE_TWO=99; //典型的公共常量Typicalpublicconstant: publicstaticfinalintVALUE_THREE=39; //运行时常量Cannotbecompile-timeconstants: privatefinalinti4=rand.nextInt(20); staticfinalintINT_5=rand.nextInt(20); privateValuev1=newValue(11); privatefinalValuev2=newValue(22); privatestaticfinalValueVAL_3=newValue(33); //数组Arrays: privatefinalint[]a={1,2,3,4,5,6}; publicStringtoString(){ returnid+":"+"i4="+i4+",INT_5="+INT_5; } publicstaticvoidmain(String[]args){ FinalDatafd1=newFinalData("fd1"); //!fd1.valueOne++;//Error:can'tchangevalue fd1.v2.i++;//Objectisn'tconstant! fd1.v1=newValue(9);//OK--notfinal for(inti=0;i<fd1.a.length;i++) fd1.a[i]++;//Objectisn'tconstant! //!fd1.v2=newValue(0);//Error:Can't //!fd1.VAL_3=newValue(1);//changereference //!fd1.a=newint[3]; System.out.println(fd1); System.out.println("CreatingnewFinalData"); FinalDatafd2=newFinalData("fd2"); System.out.println(fd1); System.out.println(fd2); } /** *输出结果: *fd1:i4=15,INT_5=18 *CreatingnewFinalData *fd1:i4=15,INT_5=18 *fd2:i4=13,INT_5=18 */ }
由于valueOne和VALUE_TWO都是带有编译时数值的final基本类型,所以它们二者均可以用作编译期常量,并且没有重大区别。VALUE_THREE是一种更加典型的对常量进行定义的方式:定义为public,可以被任何人访问;定义为static,则强调只有一份;定义为final,这说明它是个常量。请注意带有恒定初始值的finalstatic基本类型全用大写字母命名,并且字母与字母之间用下划线隔开。
我们不能因为某些数据是final的就认为在编译时可以知道它的值。在运行时使用随机数来初始化i4和INT_5的值说明了这一点。实例中fd1和fd2中i4的值是唯一的,每次都会被初始化为15,13。INT_5的值是不可以通过创建第二个FinalData对象加以改变的。这是因为他是static的,在装载类时(也就是第一次创建这个类对象时)已经被初始化,而不是每次创建都初始化。
java也许生成"空白final",所谓空白final是指被声明为final但又未给初值的域。无论什么情况下编译器都会保证final域在使用前初始化。但空白final在final的使用上提供了很大的灵活性,为此,一个final域可以根据某些对象有所不同,却又保持恒定不变的特性。下面的事例说明了一点:
packagefinalPackage; classPoppet{ privateinti; Poppet(intii){ i=ii; } publicintgetI(){ returni; } publicvoidsetI(inti){ this.i=i; } } /** *空白final *@authorAdministrator *所谓空白final是指被声明为final但又未给初值的域。无论什么情况下编译器都会保证final域在使用前初始化。 */ publicclassBlankFinal{ privatefinalinti=0;//Initializedfinal privatefinalintj;//Blankfinal privatefinalPoppetp;//Blankfinalreference //BlankfinalsMUSTbeinitializedintheconstructor: publicBlankFinal(){ j=1;//Initializeblankfinal p=newPoppet(1);//Initializeblankfinalreference } publicBlankFinal(intx){ j=x;//Initializeblankfinal p=newPoppet(x);//Initializeblankfinalreference } publicstaticvoidmain(String[]args){ BlankFinalb1=newBlankFinal(); BlankFinalb2=newBlankFinal(47); System.out.println("b1.j="+b1.j+"\t\tb1.p.i="+b1.p.getI()); System.out.println("b2.j="+b2.j+"\t\tb2.p.i="+b2.p.getI()); } /** *输出结果: *b1.j=1b1.p.i=1 *b2.j=47b2.p.i=47 */ }
final参数
java中也许将参数列表中的参数以声明的方式声指明为final。这意味着你无发改变参数所指向的对象。例如:
packagefinalPackage; classGizmo{ publicvoidspin(Stringtemp){ System.out.println(temp+"MethodcallGizmo.spin()"); } } /** *final参数 *@authorAdministrator *如果将参数列表中的参数指明为final,这意味着你无发改变参数所指向的对象的引用。 */ publicclassFinalArguments{ voidwith(finalGizmog){ //!g=newGizmo();//Illegal--gisfinal } voidwithout(Gizmog){ g=newGizmo();//OK--gnotfinal g.spin("without"); } //voidf(finalinti){i++;}//Can'tchange //Youcanonlyreadfromafinalprimitive: intg(finalinti){ returni+1; } publicstaticvoidmain(String[]args){ FinalArgumentsbf=newFinalArguments(); bf.without(null); bf.with(null); System.out.println("bf.g(10)="+bf.g(10)); } /** *输出结果: *withoutMethodcallGizmo.spin() *bf.g(10)=11 */ }
使用final方法有两个原因。第一个原因是把方法锁定,以防止任何继承它的类修改它的含义。这是出于设计的考虑:想要确保在继承中使用的方法保持不变,并且不会被覆盖。
过去建议使用final方法的第二个原因是效率。在java的早期实现中,如果将一个方法指明为final,就是同意编译器将针对该方法的所有调用都转为内嵌调用。当编译器发现一个final方法调用命令时,它会根据自己的谨慎判断,跳过插入程序代码这种正常的调用方式而执行方法调用机制(将参数压入栈,跳至方法代码处执行,然后跳回并清理栈中的参数,处理返回值),并且以方法体中的实际代码的副本来代替方法调用。这将消除方法调用的开销。当然,如果一个方法很大,你的程序代码会膨胀,因而可能看不到内嵌所带来的性能上的提高,因为所带来的性能会花费于方法内的时间量而被缩减。
在最近的java版本中,虚拟机(特别是hotspot技术)可以探测到这些情况,并优化去掉这些效率反而降低的额外的内嵌调用,因此不再需要使用final方法来进行优化了。事实上,这种做法正逐渐受到劝阻。在使用javase5/6时,应该让编译器和JVM去处理效率问题,只有在想明确禁止覆盖式,才将方法设置为final的。
final和private关键字
类中的所有private方法都是隐式的制定为final的。由于你无法访问private方法你也就无法覆盖它。可以对private方法添加final修饰词,但这毫无意义。例如:
packagefinalPackage; /** *final和private关键字 * *类中的所有private方法都是隐式的制定为final的。 *由于你无法访问private方法,所以你也就无法覆盖它。 *可以对private方法添加final修饰词,但这毫无意义。 */ classWithFinals{ //Identicalto"private"alone: privatefinalvoidf(){ System.out.println("WithFinals.f()"); } //Alsoautomatically"final": privatevoidg(){ System.out.println("WithFinals.g()"); } } classOverridingPrivateextendsWithFinals{ privatefinalvoidf(){ System.out.println("OverridingPrivate.f()"); } privatevoidg(){ System.out.println("OverridingPrivate.g()"); } } classOverridingPrivate2extendsOverridingPrivate{ publicfinalvoidf(){ System.out.println("OverridingPrivate2.f()"); } publicvoidg(){ System.out.println("OverridingPrivate2.g()"); } } publicclassOverideFinal{ publicstaticvoidmain(String[]args){ WithFinalsw1=newWithFinals(); //!w1.f();//Error,无法访问私有方法 //!w1.g();//Error,无法访问私有方法 OverridingPrivatew2=newOverridingPrivate(); //!w2.f();//Error,无法访问私有方法 //!w2.g();//Error,无法访问私有方法 OverridingPrivate2w3=newOverridingPrivate2(); w3.f(); w3.g(); } /** *输出结果: *OverridingPrivate2.f() *OverridingPrivate2.g() */ }
"覆盖"只有在某方法是基类接口的一部分时才会发生。即,必须将一个对象向上转型为它的基类并调用相同的方法。如果某方法是private的,它就不是基类接口的一部分。它仅是一些隐藏于类中的程序代码,如果一个基类中存在某个private方法,在派生类中以相同的名称创建一个public,protected或包访问权限方法的话,该方法只不过是与基类中的方法有相同的名称而已,并没有覆盖基类方法。由于private方法无法触及而且能有效隐藏,所以除了把它看成是因为它所归属的类的组织结构的原因而存在外,其他任何事物都不需要考虑它。
final类
当将类定义为final时,就表明了你不打算继承该类,而且也不许别人这样做。换句话说,出于某种考虑,你对该类的设计永不需要做任何变动,或者出于安全的考虑,你不希望他有子类。例如:
packagefinalPackage; classSmallBrain{ } finalclassDinosaur{ inti=7; intj=1; SmallBrainx=newSmallBrain(); voidf(){ System.out.println("Dinosaur.f()"); } } //!classFurtherextendsDinosaur{} //error:Cannotextendfinalclass'Dinosaur' /** *final类 * *final类中的属性可以选择是否定义为final *final类中的方法都隐式的制定为final方法,因此你无法覆盖他们 */ publicclassJurassic{ publicstaticvoidmain(String[]args){ Dinosaurn=newDinosaur(); n.f(); n.i=40; n.j++; System.out.println("n.i="+n.i); System.out.println("n.j="+n.j); } /** *输出结果为: *Dinosaur.f() *n.i=40 *n.j=2 */ }
请注意,final类的域可以根据个人的意愿选择是或不是final。不论类是否被定义为final,相同的规则同样适用于定义为final的域。然而,由于final是无法继承的,所以被final修饰的类中的方法都隐式的制定为fianl,因为你无法覆盖他们。在fianl类中可以给方法添加final,但这不会产生任何意义。
结论:
根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。
final类不能被继承,没有子类,final类中的方法默认是final的。
final方法不能被子类的方法覆盖,但可以被继承。
final成员变量表示常量,只能被赋值一次,赋值后值不再改变。
final不能用于修饰构造方法。
注意:父类的private成员方法是不能被子类方法覆盖的,因此private类型的方法默认是final类型的。
希望本文所述对大家Java程序设计有所帮助。