java中的final关键字

        谈到final关键字，想必很多人都不陌生，在使用匿名内部类的时候可能会经常用到final关键字。另外，Java中的

String类就是一个final类，那么今天我们就来了解final这个关键字的用法。

 

一、final

  

   根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类

成员方法和变量。当我们为了效率不想让某些类，方法或者变量被改变时，可以考虑final。

1. final类不能被继承，没有子类，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
2. final方法不能被子类的方法覆盖，但可以被继承。
3. final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
4. final不能用于修饰构造方法。

注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类

        

  final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要

有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

       注意：在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

2、final方法

      

 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。使用final方法的原因有二：

   第一、把方法锁定，防止任何继承类修改它的意义和实现。

   第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

例如：

<span style="font-size:18px;">public class Test1 { 
public static void main(String[]args) { 
    
} 
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(); //调用失败，无法从父类继承获得 
} 
}</span>

3、final变量（常量）      

• 用final修饰的成员变量表示常量，值一旦给定就无法改变！
• final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
• 从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。

  另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空

白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的

final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

<span style="font-size:18px;">public class Test3 { 
        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) { 
                Test3t = 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); 
 
                Test3t1 = 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; 出错,已经给赋过值了. 
        } 
}</span>

4、final参数    

    

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

<span style="font-size:18px;">public class Test4 { 
        public static void main(String[]args) { 
                new Test4().f1(2); 
        } 
 
        public void f1(final int i) { 
                //i++;    //i是final类型的,值不允许改变的. 
                System.out.print(i); 
        } 
}</span>

二.深入理解final关键字

  

1.类的final变量和普通变量有什么区别？

   当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即

可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。

   那么final变量和普通变量到底有何区别呢？下面请看一个例 

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = "hello";
        String d = "hello";
        String c = b + 2; 
        String e = d + 2;
        System.out.println((a == c));
        System.out.println((a == e));
    }
}

输出结果：

   true
   false

   大家可以先想一下这道题的输出结果。为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final

变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器

会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这

种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用

到b的地方会直接将变量b替换为它的 值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该

明白了，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，比如下面的这段代

码就不会进行优化：

<span style="font-size:18px;">public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = getHello();
        String c = b + 2; 
        System.out.println((a == c));
 
    }
     
    public static String getHello() {
        return "hello";
    }
}</span>

这段代码的输出结果为false。

2.被final修饰的引用变量指向的对象内容可变吗？

  在上面提到被final修饰的引用变量一旦初始化赋值之后就不能再指向其他的对象，那么该引用变量指向的对象的内容

可变吗？看下面这个例子：

<span style="font-size:18px;">public class Test {
    public static void main(String[] args)  {
        final MyClass myClass = new MyClass();
        System.out.println(++myClass.i);
 
    }
}
 
class MyClass {
    public int i = 0;
}</span>

   这段代码可以顺利编译通过并且有输出结果，输出结果为1。这说明引用变量被final修饰之后，虽然不能再指向其他

对象，但是它指向的对象的内容是可变的。

3.final和static

  很多时候会容易把static和final关键字混淆，static作用于成员变量用来表示只保存一份副本，而final的作用是用

来保证变量不可变。看下面这个例子：

<span style="font-size:18px;">public class Test {
    public static void main(String[] args)  {
        MyClass myClass1 = new MyClass();
        MyClass myClass2 = new MyClass();
        System.out.println(myClass1.i);
        System.out.println(myClass1.j);
        System.out.println(myClass2.i);
        System.out.println(myClass2.j);
 
    }
}
 
class MyClass {
    public final double i = Math.random();
    public static double j = Math.random();
}</span>

   运行这段代码就会发现，每次打印的两个j值都是一样的，而i的值却是不同的。

三、总结

     

       final关键字是我们在编程和阅读源码的时候经常遇到的，深入理解它的意思，才能读懂源码，也可以在合

适的条件下，提高我们代码的效率。