JAVA final深入理解

桃扇骨 2022-05-26 06:55 225阅读 0赞

Java的关键字final通常是指被它修饰的数据是不能被改变的，不想改变可能出于两种理由：设计或效率。主要特性：

*  final数据的使用
 *  final参数的使用
 *  final方法的使用
 *  final类不能被继承

### final数据 ###

**1.1 final修饰变量**

final 变量一经初始化，就不能改变其值

这里的值对于一个对象或者数组来说指的是这个对象或者数组的引用地址。因此，一个线程定义了一个final变量之后，其他任意线程都拿到这个变量。但有一点需要注意的是，当这个final变量为对象或者数组时，虽然我们不能讲这个变量赋值为其他对象或者数组，但是我们可以改变对象的域或者数组中的元素。

线程对这个对象变量的域或者数据的元素的改变不具有线程可见性；

所以final修饰的变量必须被初始化

public static final String LOAN = "loan";
    LOAN = new String("loan") //invalid compilation error

final变量初始化时机：

*  定义时初始化
 *  初始化块中,但不可在静态初始化块中,静态的final实例变量才可以在静态初始化块中
 *  构造方法中,但静态final实例变量不可以在其中

特性

*  修饰的变量是基本数据类型：告知编译器这一块数据是不变的，这样可以在执行计算时，减少一些运行时的负担；
 *  final变量必须在声明时被初始化；
 *  final实例变量必须在所有的构造函数末尾初始化；
 *  在JMM中要求final域的初始化动作必须在构造方法return之前完成；

package com.quancheng;
    
    import java.util.Random;
    
    public class FinalTest {
        private static Random random = new Random(20);
        private final int VALUE_A = 10;
        private static final int VALUE_B = 20;
        public static final int VALUE_C = random.nextInt(10);
        public  final int VALUE_D = random.nextInt(10);
        public static void main(String[] args) {
            FinalTest test = new FinalTest();
            //test.VALUE_A = 5;//Error:不可以这样做
            //test.VALUE_B =21;//Error:不可以这样做
    
            FinalTest finalT = new FinalTest();
            FinalTest finalT1 = new FinalTest();
    
            System.out.println("VALUE_C:"+VALUE_C);
            System.out.println("VALUE_C:"+finalT.VALUE_C);
            System.out.println("VALUE_C:"+finalT1.VALUE_C);
            System.out.println("---------");
            System.out.println("VALUE_D:"+finalT.VALUE_D);
            System.out.println("VALUE_D:"+finalT1.VALUE_D);
        }
    }
    
    output==>
    VALUE_C:3
    VALUE_C:3
    VALUE_C:3
    ---------
    VALUE_D:1
    VALUE_D:1

以上结果得出一点我们不能因为某数据时final的就认为在编译时可以知道它的值。在运行时使用随机生成的VALUE\_C和VALUE\_D说明了这一点。示例代码展示了final数值定义为static和非static的区别。此区别只有当数值在运行时内被初始化时才会显现，这是因为编译器对编译时数值一视同仁（并且他们可能因为优化而消失）。使用static final 的数值是不可以通过一个新的对象而改变的。这是因为在装载时已经被初始化，而不是每次创建新对象时初始化。

**1.2 final用于引用**

当使用final用于对对象的引用而不是基本类型时，对于基本类型final使数值恒定不变，而对于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然而，对象自身的数据是可以修改的

package com.game.lll;
    
    public class FinalTest {  
        private final int a = 10;  
    
        private final Value v1 = new Value(10);  
    
        public static void main(String[] args) {  
            FinalTest test = new FinalTest();  
            //test.a = 5;//不可以这样做 
            test.v1.value++;  
            //test.v1 = new Value(12);//Error:不可以这样做 
            System.out.println("对象内的数据:"+test.v1.value);  
        }  
    
        class Value{  
            int value;   
            public Value(int value) {  
                this.value = value;  
            }  
        }  
    }

**1.3 final用于数组**

final用于数组和引用时一样的，数组只不过是另一种引用，对于这个变量的引用是不能被重新赋值，但是对象本身是可以修改的。代码如下：

package com.game.lll;    
    
    public class FinalTest {    
        private final Value v1 = new Value(10);    
    
        private final int[] values = { 1, 2, 3, 4, 5, 6 };    
    
        public static void main(String[] args) {    
            FinalTest test = new FinalTest();    
            //test.a = 5;//不可以这样做 
            test.v1.value++;    
            //test.v1 = new Value(12);//Error:不可以这样做 
            test.values[0] = 100;//对象本身是可以修改的 
            for(int i = 0; i < test.values.length;i++){    
                System.out.println(test.values[i]++);//对于这个变量的引用是不能被重新赋值 
            }    
        }    
    
        class Value{    
            int value;     
            public Value(int value) {    
                this.value = value;    
            }    
        }    
    }

**1.4 空白final**

Java允许生成“空白final”，空白final是指被声明为final但又给未定初值的域。代码如下：

package com.game.lll;  
    
    public class BlankFinal {  
        private final int a;  
    
        public BlankFinal(int i)  
        {  
            this.a = i;  
        }  
    
    
        public static void main(String[] args) {  
            BlankFinal blankFinal = new BlankFinal(5);  
            System.out.println(blankFinal.a);  
        }  
    }

虽然未对a直接赋值，但是在构造函数中对a进行了初始化。所以无论什么情况，都要确保final在使用前被初始化

> 在JMM中要求final域的初始化动作必须在构造方法return之前完成

### final方法 ###

使用final方法的原因是把方法锁定，以防任何继承类修改它的含义。final声明的方法不能被重写；

*  当调用final方法时,直接将方法主体插入到调用处,而不是进行方法调用,这样能提高程序效率(内联机制)
 *  如果你认为一个方法的功能已经足够完整了，子类中不需要改变的话，你可以声明此方法为final
 *  final方法比非final方法快，因为在编译时候已静态绑定了，不需要在运行时再动态绑定

class PersonalLoan{ 
        public final String getName(){
            return "personal loan";
        }
    }
    
    class CheapPersonalLoan extends PersonalLoan{ 
        @Override
        public final String getName(){
            return "cheap personal loan"; //compilation error: overridden method is final
        }
    }

### final类 ###

当你将某个类定义为final class时，那么子类就无法继承该类

思考一个有趣的现象：

byte b1=1;
    byte b2=3;
    byte b3=b1+b2;  //当程序执行到这一行的时候会出错，因为b1、b2可以自动转换成int类型的变量，运算时java虚拟机对它进行了转换，结果导致把一个int赋值给byte
    final byte b1=1;
    final byte b2=3;
    byte b3=b1+b2;  //不会出错，相信你看了上面的解释就知道原因了。

### 其它特性 ###

*  final变量一经初始化，就不能改变其值；
 *  final变量应该全部应用大写（编码规则）；
 *  final类的所有方法为隐式的final方法；
 *  类不能同时被声明为final和abstract；

### 知识点 ###

*  为何System类中的out/err可以更改值
    
        public final static InputStream in = null;
        public final static PrintStream out = null;
        public final static PrintStream err = null;
    
    setOut/setIn/setErr是native方法，可以绕过java语言的存取控制机制；这种罕见的情况来自早期JAVA，并且不会再其它地方遇到；
    
        private static native void setIn0(InputStream in);
        private static native void setOut0(PrintStream out);
        private static native void setErr0(PrintStream err);