java中的final关键字所起的作用解析

　　一、关键字final的理解

　　1、final数据

　　在java编程语言中，有时候需要告知编译器一段数据是不变的编译期常量。对于这种情况，编译器可以将此常量值带入需要用到它的计算式子当中，这种在编译时执行计算式的方法减轻了运行时的开销。通常，这类常量数据都是基本类型的数据，并赋予关键字final，同时在对此常量定义时需要进行赋值。

　　值得注意的是：对于基本类型，使用final关键字将使数值恒定不变；而对于对象引用，final则是使引用恒定不变。一旦引用被初始化为指向一个对象时，它也就无法再指向另外一个对象，然而该对象本身是可以被修改的。通常，对于一个既是static又是final的域只占一段不能改变的存储空间。

　　下面的例子验证了final数据的含义。

　　class Hank

　　{

　　int i;

　　public Hank（int i）{this.i=i;}

　　}

　　public class FinalTest

　　{

　　private String s;

　　public FinalTest（String s）{this.s=s;}

　　private final int value=20;

　　private static final int INT_1=50;

　　public static final int INT_2=60;

　　static final int INT_3=70;

　　private final Hank h1=new Hank（1）;

　　private static final Hank h2=new Hank（2）;

　　private Hank h3=new Hank（3）;

　　private final int［］ a={1，2，3，4，5};

　　public String toString（）

　　{

　　return s+“： ”+“INT_2= ”+INT_2;

　　}

　　public static void main（String［］ args）

　　{

　　FinalTest ft1=new FinalTest（“ft1”）;

　　//ft1.value++;常量值不能被修改

　　ft1.h1.i++;//对象引用不能改变，但是其对象本身是可以修改的

　　ft1.h3=new Hank（2）;

　　//ft1.h1=new Hank（1）;常量对象引用不能再指向另一个对象引用

　　for（int i=0;i《ft1.a.length;i++）

　　{

　　ft1.a［i］++; //对象引用不能改变，但是其对象本身是可以修改的

　　System.out.println（ft1.a［i］）;

　　}

　　//ft1.a=new int［3］; 常量对象引用不能再指向另一个对象引用

　　}

　　}

　　2、空白final

　　被声明为final但又没有给定初值的域即为空白final，编译器确保使用前必须初始化空白final。比如：

　　class Blank

　　{

　　private int i;

　　Blank（int i）{this.i=i;System.out.println（“Blank.i=”+this.i）;}

　　}

　　public class BlankFinal

　　{

　　private final int i;//blank final

　　private final Blank b;//blank final reference

　　BlankFinal（）

　　{

　　i=1;b=new Blank（1）;//使用前必须初始化

　　System.out.println（“BlankFinal.i=”+this.i）;

　　}

　　BlankFinal（int i）

　　{

　　this.i=i;b=new Blank（i）; //使用前必须初始化

　　System.out.println（“BlankFinal.i=”+this.i）;

　　}

　　public static void main（String［］ args）

　　{

　　new BlankFinal（）;//Blank.i=1;BlankFinal.i=1;

　　new BlankFinal（2）; //Blank.i=2;BlankFinal.i=2;

　　}

　　}

　　3、final参数

　　Java允许在函数参数列表中以声明的方式将参数指明为final，这使得在函数体当中修改参数引用所指向的对象变得不合法。比如说：

　　class Args

　　{

　　public void f（String s）{System.out.println（s）;}

　　}

　　public class ArgsFinal

　　{

　　void has（final Args arg）

　　{

　　//arg=new Args（）;不能修改final参数

　　arg.f（“with final”）;

　　}

　　void dnthas（Args arg）

　　{

　　arg=new Args（）;//能修改final参数

　　arg.f（“without final”）;

　　}

　　public static void main（String［］ args）

　　{

　　ArgsFinal af=new ArgsFinal（）;

　　Args ar=new Args（）;

　　af.has（ar）;//with final

　　af.dnthas（ar）;//without final

　　}

　　}

　　4、final类

　　如果不想继承某个类，则可以考虑将此类设置成final的形式。即是说，程序员对该类不能做任何改动，同时也意味着它不会有子类。比如：

　　Class Base{ …}

　　Final Class SubClass{…}

　　//！ Class Derived extends SubClass{…}不能由final类SubClass导出新类

　　需要注意的是，所有final类中的方法都隐式的final，他们是无法被覆盖或修改的，因此在其中的方法显示指明为final就显得有些多此一举了。

　　二、Java中的final关键字所起的作用

　　1、final修饰类中的属性或者变量

　　无论属性是基本类型还是引用类型，final所起的作用都是变量里面存放的“值”不能变。

　　这个值，对于基本类型来说，变量里面放的就是实实在在的值，如1，“abc”等。

　　而引用类型变量里面放的是个地址，所以用final修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可以变，这个一定要注意。

　　例如：类中有一个属性是final Person p=new Person（“name”）； 那么你不能对p进行重新赋值，但是可以改变p里面属性的值，p.setName（‘newName’）;

　　final修饰属性，声明变量时可以不赋值，而且一旦赋值就不能被修改了。对final属性可以在三个地方赋值：声明时、初始化块中、构造方法中。总之一定要赋值。

　　2、final修饰类中的方法

　　作用：可以被继承，但继承后不能被重写。

　　3、final修饰类

　　作用：类不可以被继承。

　　思考一个有趣的现象：

　　byte b1=1;

　　byte b2=3;

　　byte b3=b1+b2;//当程序执行到这一行的时候会出错，因为b1、b2可以自动转换成int类型的变量，运算时java虚拟机对它进行了转换，结果导致把一个int赋值给byte-----出错

　　如果对b1 b2加上final就不会出错

　　final byte b1=1;

　　final byte b2=3;

　　byte b3=b1+b2;//不会出错，相信你看了上面的解释就知道原因了。