当你让它成为静态final时，它应该在静态初始化块中初始化

    private static final List foo;

    static {
        foo = new ArrayList();
    }

    public Test()
    {
//      foo = new ArrayList();
        foo.add("foo"); // Modification-1
    }

Final关键字有很多种用法:

final类不能被子类化。 final方法不能被子类重写 final变量只能初始化一次

其他用途:

在方法体中定义匿名内部类时， 在该方法范围内声明为final的所有变量为 从内部类内部访问

静态类变量将从JVM开始时就存在，并且应该在类中初始化。如果您这样做，错误消息将不会出现。

假设你有两个储蓄罐，红的和白的。你把这些钱箱只分配给两个孩子，他们不允许交换他们的钱箱。所以你有红色或白色的钱箱(最终)，你不能修改盒子，但你可以把钱放在你的盒子上。没人在乎(修改-2)。

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

首先，在你的代码中初始化(即第一次赋值)foo的地方在这里:

foo = new ArrayList();

foo是一个对象(类型为List)，因此它是一个引用类型，而不是一个值类型(如int)。因此，它持有对存储List元素的内存位置(例如0xA7D2A834)的引用。像这样的线

foo.add("foo"); // Modification-1

不要更改foo的值(同样，它只是一个对内存位置的引用)。相反，它们只是在引用的内存位置中添加元素。要违反final关键字，你必须尝试重新分配foo，如下所示:

foo = new ArrayList();

这将导致编译错误。

现在，考虑一下当您添加static关键字时会发生什么。

当你没有static关键字时，实例化类的每个对象都有自己的foo副本。因此，构造函数将一个值赋给foo变量的一个空白的新副本，这是完全没问题的。

然而，当你有static关键字时，内存中只有一个foo与类相关联。如果要创建两个或多个对象，构造函数每次都会尝试重新分配那个foo，这违反了final关键字。

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

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

在两种情况下冻结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