Java关键字之final详解

在我们编写Java程序时总会根据需求将变量、方法、类设置成static（静态）或final（最终），熟练掌握final用法是必须的，现在我们就来详细了解final关键字！

一、final概述

概念：由字面可以了解，final有最终态，无法改变的意思。

使用目的：为了阻止改变与提高效率。

高效原因：Java内嵌机制，final方法会在编译的过程中利用内嵌机制进行inline优化。

inline优化是指：在编译的时候直接调用方法代码替换，也就是内嵌，而不是在运行时调用方法。

inline需要在编译的时候就知道最后要用哪个方法。

显然，非final是不行的。
非final方法可能在子类中被重写，由于可能出现多态的情况，编译器在编译阶段
并不能确定将来调用方法的对象的真正类型，也就无法确定到底调用哪个方法。）

修饰对象：

1、非抽象类，由于被final修饰的类是不能被继承的，而抽象类必须被继承才有意义。

2、非抽象方法，由于被final修饰的方法是不能被重写的，而抽象方法必须被重写才有意义。

3、变量或常量。

注意：

1、final不能修饰构造方法。

2、父类的private方法是不能被子类重写的，因为private方法默认是final的。

二、具体用法

1、修饰类

final类不能被继承，所有其成员与方法自然没有机会被覆盖，默认是final的。所以在将类设计成final类的时候，一定要特别慎重考虑，确定这个类不需要有子类，类实现不能被改变，类不能被扩展的时候才能用final修饰。

注：Java中String类就是一个final类。

2、修饰方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法用final修饰。

这样做的目的可在《Java编程思想》中查到：

“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。”

 

public class Test1 {
public static void main(String[] args) {
    // TODO 自动生成方法存根
}
public void f1() {
    System.out.println("f1");
}
//无法被子类覆盖的方法
public final void f2() {
    System.out.println("f2");
}
public void f3() {
    System.out.println("f3");
}
private void f4() {
    System.out.println("f4");
}
}
public class Test2 extends Test1 {

public void f1(){
    System.out.println("Test1父类方法f1被覆盖!");
}
public static void main(String[] args) {
    Test2 t=new Test2();
    t.f1();
    t.f2(); //调用从父类继承过来的final方法
    t.f3(); //调用从父类继承过来的方法
    //t.f4(); //调用失败，无法从父类继承获得
}
}

 

 

 

3、修饰变量（重点）

1、final修饰基本数据类型变量，则其数值一旦被初始化就不能被更改。

2、final修饰引用变量（如ObjectName obj = new ObjectName();中obj就是一个引用变量，指向堆内存中对象空间的首地址），则其初始化后就不能修改引用指向另一个对象。

 

public class Test2 {
        private final String S = "final实例变量S";
        private final int A = 100;
        public final int B = 90;

        public static final int C = 80;
        private static final int D = 70;

        public final int E; //final空白,必须在初始化对象的时候赋初值

        public Test3(int x) {
                E = x;
        }

        /**
         * @param args
         */
        public static void main(String[] args) {
                Test3 t = new Test3(2);
                //t.A=101;    //出错,final变量的值一旦给定就无法改变
                //t.B=91; //出错,final变量的值一旦给定就无法改变
                //t.C=81; //出错,final变量的值一旦给定就无法改变
                //t.D=71; //出错,final变量的值一旦给定就无法改变

                System.out.println(t.A);
                System.out.println(t.B);
                System.out.println(t.C); //不推荐用对象方式访问静态字段
                System.out.println(t.D); //不推荐用对象方式访问静态字段
                System.out.println(Test3.C);
                System.out.println(Test3.D);
                //System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同.
                System.out.println(t.E);

                Test3 t1 = new Test3(3);
                System.out.println(t1.E); //final空白变量E依据对象的不同而不同
        }

        private void test() {
                System.out.println(new Test3(1).A);
                System.out.println(Test3.C);
                System.out.println(Test3.D);
        }

        public void test2() {
                final int a;     //final空白,在需要的时候才赋值
                final int b = 4;    //局部常量--final用于局部变量的情形
                final int c;    //final空白,一直没有给赋值.
                a = 3;
                //a=4;    出错,已经给赋过值了.
                //b=2; 出错,已经给赋过值了.
        }
}

四、修饰参数

 

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

 

public class Test3 {
        public static void main(String[] args) {
                new Test4().f1(2);
        }

        public void f1(final int i) {
                //i++;    //i是final类型的,值不允许改变的.
                System.out.print(i);
        }
}