Java final字段编译时常量表达式 [英] Java final field compile-time constant expression

问题描述

以下文字来自jls http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3

The below text is from jls http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3

Even then, there are a number of complications. If a final field is 
initialized to a compile-time constant expression (§15.28) in the field 
declaration, changes to the final field may not be observed, since uses of that 
final field are replaced at compile time with the value of the constant 
expression.

任何人都可以给我更好的解释。我无法理解语句 可能无法观察到对最终字段的更改 。可以借助示例。

Can anyone Please give me better explanation for the above. i couldn't understand the statement changes to the final field may not be observed. May with the help of example.

提前致谢

推荐答案

我无法理解可能无法观察到对最终字段的更改声明

I couldn't understand the statement changes to the final field may not be observed

它告诉我们，如果最终变量被声明为编译时常量，则在程序执行期间程序中将无法使用程序中的反射API 对最终变量进行的任何更改。

例如考虑下面给出的代码：

It tells that , if a final variable is declared as compile time constant then any change made in the final variable using reflection API further in program will not be visible to the program during execution.
For example consider the code given below:

import java.lang.reflect.*;
class ChangeFinal 
{
    private final int x = 20;//compile time constant
    public static void change(ChangeFinal cf)
    {
        try
        {
            Class clazz = ChangeFinal.class;
            Field field = clazz.getDeclaredField("x");
            field.setAccessible(true);
            field.set(cf , 190);//changed x to 190 for object cf
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
    public static void main(String[] args) 
    {
        ChangeFinal cf = new ChangeFinal();
        System.out.println(cf.x);//prints 20
        change(cf);
        System.out.println(cf.x);//prints 20
    }
}

上述代码的输出为：

20
20

为什么？


答案在于 javap -c public static void main的命令：

WHY?
The answer lies in the output provided by javap -c command for public static void main:

public static void main(java.lang.String[]);
  Code:
   0:   new     #3; //class ChangeFinal
   3:   dup
   4:   invokespecial   #11; //Method "<init>":()V
   7:   astore_1
   8:   getstatic       #12; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  aload_1
   12:  invokevirtual   #13; //Method java/lang/Object.getClass:()Ljava/lang/Cla
ss;
   15:  pop
   16:  bipush  20
   18:  invokevirtual   #14; //Method java/io/PrintStream.println:(I)V
   21:  aload_1
   22:  invokestatic    #15; //Method change:(LChangeFinal;)V
   25:  getstatic       #12; //Field java/lang/System.out:Ljava/io/PrintStream;
   28:  aload_1
   29:  invokevirtual   #13; //Method java/lang/Object.getClass:()Ljava/lang/Cla
ss;
   32:  pop
   33:  bipush  20
   35:  invokevirtual   #14; //Method java/io/PrintStream.println:(I)V
   38:  return

}

在第16行（调用 changeFinal 方法之前） cf.x 被硬编码为 20 。在第33行（在调用 changeFinal 方法之后）， cf.x 的值再次硬编码为 20 。因此，虽然最终变量 x 的值的变化在执行期间由反射API 成功完成，但由于 x 作为编译时常量，它显示其常量值 20 。

At line 16 (before changeFinal method is called)the value of cf.x is hardcoded to 20 . And at line 33 (after changeFinal method is called) the value of cf.x is again hardcoded to 20. Therefore , Although the change in the value of final variable x is done successfully by reflection API during execution, but because of x being a compile time constant it is showing its constant value 20.

这篇关于Java final字段编译时常量表达式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！