Final关键字有很多种用法:

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

其他用途:

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

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

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

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

在两种情况下冻结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只与引用本身有关，而与被引用对象的内容无关。

Java没有对象不变性的概念;这是通过仔细设计对象来实现的，这是一个远不是微不足道的努力。

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

我只能回答你的问题，在这种情况下，你不能改变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);
}

阅读所有答案。

在另一个用户案例中，final关键字可以用在方法参数中:

public void showCaseFinalArgumentVariable(final int someFinalInt){

   someFinalInt = 9; // won't compile as the argument is final

}

可用于不应更改的变量。