“最终变量只能赋值一次”

*反思* -“哇哦，等等，拿着我的啤酒”。

在两种情况下冻结final字段:

构造函数结束。 当反射设置字段的值时。(想要多少次就有多少次)

让我们犯法吧

public class HoldMyBeer 
{
    final int notSoFinal;
    
    public HoldMyBeer()
    {
       notSoFinal = 1;
    }

    static void holdIt(HoldMyBeer beer, int yetAnotherFinalValue) throws Exception
    {
       Class<HoldMyBeer> cl = HoldMyBeer.class;
       Field field = cl.getDeclaredField("notSoFinal");
       field.setAccessible(true);
       field.set(beer, yetAnotherFinalValue);
    }

    public static void main(String[] args) throws Exception 
    {
       HoldMyBeer beer = new HoldMyBeer();
       System.out.println(beer.notSoFinal);
       holdIt(beer, 50);
       System.out.println(beer.notSoFinal);
       holdIt(beer, 100);
       System.out.println(beer.notSoFinal);
       holdIt(beer, 666);
       System.out.println(beer.notSoFinal);
       holdIt(beer, 8888);
       System.out.println(beer.notSoFinal);
    }    
}

输出:

1
50
100
666
8888

“final”字段已经被分配了5个不同的“final”值(注意引号)。它可以一直被赋予不同的值……

为什么?因为反射就像chucknorris，如果它想改变一个初始化的final字段的值，它就会这样做。有人说他自己就是那个将新值推入堆栈的人:

Code:
   7: astore_1
  11: aload_1
  12: getfield                
  18: aload_1
  19: bipush        50        //wait what
  27: aload_1
  28: getfield                
  34: aload_1
  35: bipush        100       //come on...
  43: aload_1
  44: getfield                
  50: aload_1
  51: sipush        666      //...you were supposed to be final...
  60: aload_1
  61: getfield                
  67: aload_1
  68: sipush        8888     //ok i'm out whatever dude
  77: aload_1
  78: getfield                

值得一提的是一些简单的定义:

类/方法

您可以将类的部分或全部方法声明为final，以指示该方法不能被子类覆盖。

变量

一旦final变量初始化，它总是包含相同的值。

Final基本上避免被任何东西(子类，变量“重赋”)覆盖/上写，这取决于情况。

由于final变量是非静态的，所以可以在构造函数中初始化它。但是如果你让它是静态的，它就不能被构造函数初始化(因为构造函数不是静态的)。 对列表的添加不期望通过使列表最终停止。Final只是将引用绑定到特定对象。你可以自由地改变对象的“状态”，但不能改变对象本身。

我只能回答你的问题，在这种情况下，你不能改变foo的参考值。你只需要在同一个引用中放入值，这就是为什么你可以在foo引用中添加值。这个问题发生在你不能很好地理解参考值和原始值之间的区别。引用值也是在堆内存中存储对象地址(即value)的值。

public static void main(String[] args) 
  {
      Test t = new Test();
      t.foo.add("bar"); // Modification-2
      System.out.println("print - " + t.foo);
  }

但是在这种情况下，您可以看到，如果尝试编写以下代码，将会出现编译时错误。

public static void main(String[] args)
{
    Main main = new Main();
    main.foo=new ArrayList<>();//Cannot assign a value to final variable 'foo'
    System.out.println("print - " + main.foo);
}

如果你让foo是静态的，你必须在类构造函数中初始化它(或者你定义它的内联)，就像下面的例子。

类构造函数(不是实例):

private static final List foo;

static
{
   foo = new ArrayList();
}

内联:

private static final List foo = new ArrayList();

这里的问题不是最终修饰符如何工作，而是静态修饰符如何工作。

final修饰符强制在调用构造函数完成之前对引用进行初始化(即必须在构造函数中初始化它)。

当你内联初始化一个属性时，它会在你为构造函数定义的代码运行之前初始化，所以你会得到以下结果:

如果foo是静态的，foo = new ArrayList()将在你为你的类定义的静态{}构造函数执行之前执行 如果foo不是静态的，foo = new ArrayList()将在运行构造函数之前执行

如果不内联初始化属性，final修饰符强制初始化它，并且必须在构造函数中初始化。如果你也有一个静态修饰符，你必须初始化属性的构造函数是类的初始化块:static{}。

您在代码中得到的错误来自于这样一个事实，即静态{}在加载类时运行，在您实例化该类的对象之前。因此，在创建类时，你还没有初始化foo。

可以将静态{}块视为Class类型对象的构造函数。在这里必须初始化静态final类属性(如果不是内联完成的话)。

注:

final修饰符仅对基本类型和引用保证const性。

当你声明一个final对象时，你得到的是该对象的最终引用，但对象本身不是常量。

当你声明一个final属性时，你真正实现的是，一旦你声明了一个特定目的的对象(就像你已经声明的final List)，这个对象将被用于该目的:你不能将List foo更改为另一个List，但你仍然可以通过添加/删除项来改变你的List(你正在使用的List将是相同的，只是它的内容被改变了)。

我想在这里写一个更新的和深入的回答。

Final关键字可以在几个地方使用。

类

final类意味着没有其他类可以扩展这个final类。当Java运行时(JRE)知道一个对象引用的类型是final类(比如F)时，它就知道该引用的值只能是F类型。

Ex:

F myF;
myF = new F();    //ok
myF = someOther;  //someOther cannot be in type of a child class of F.
                  //because F cannot be extended.

因此，当它执行该对象的任何方法时，该方法不需要在运行时使用虚拟表进行解析。即不能应用运行时多态性。所以运行时不会担心这个。这意味着它节省了处理时间，从而提高了性能。

方法

任何类的final方法意味着任何扩展该类的子类都不能重写该final方法。因此，此场景中的运行时行为也与前面提到的类的行为完全相同。

字段，局部变量，方法参数

如果将上述任何类型指定为final，则意味着该值已经最终确定，因此不能更改该值。

Ex:

对于字段，为本地参数

final FinalClass fc = someFC; //need to assign straight away. otherwise compile error.
final FinalClass fc; //compile error, need assignment (initialization inside a constructor Ok, constructor can be called only once)
final FinalClass fc = new FinalClass(); //ok
fc = someOtherFC; //compile error
fc.someMethod(); //no problem
someOtherFC.someMethod(); //no problem

对于方法参数

void someMethod(final String s){
    s = someOtherString; //compile error
}

这仅仅意味着不能更改最终参考值的值。也就是说，只允许一次初始化。在这个场景中，在运行时，由于JRE知道值不能更改，它将所有这些最终确定的值(最终引用的值)加载到L1缓存中。因为它不需要一次又一次地从主存中加载。否则它会加载到L2缓存，并从主存中进行时间到时间的加载。所以这也是一种性能提升。

因此，在上述三种情况下，当我们没有在可以使用的地方指定最后的关键字时，我们不需要担心，编译器优化会为我们做这件事。编译器优化还为我们做了很多其他的事情。：）