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程序设计有所帮助。