java中final的介绍详解

java中final的介绍详解

Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。

1、final类 

        final类 不能被继承，因此 final类的成员方法没有机会被覆盖，默认都是final 的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

      Class Base{ …}

       Final Class SubClass{…}

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

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

2、final方法 

如果 一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 
使用final方法的原因有二： 
第一、把方法锁定，防止任何继承类修改它的意义和实现。 
第二、高效。编译器在遇到调用final方法的时候会转入内嵌机制，大大提高执行效率。

      Class Father{ 

           public final void method(){
      System.out.println("Father doing method");
          }

      }

       public class child extends Father {

//提示  Cannot override the final method from 
// @Override
// public void method(){
//
// }

    }

     

子类不能继承和修改父类的final方法。

3、final变量（常量） 

    用final修饰的成员变量表示常量， 值一旦给定就无法改变！ 
    final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
   一旦给final变量初值后，值就不能再改变了。
另外， final变量定义的时候，可以先声明，而不给初值，其中变量也称为final空白，无论什么情况， 编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的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]; 常量对象引用不能再指向另一个对象引用

       }

}

 

空白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;

    }     

} 

4、final参数 

当函数参数为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

       }

}