由于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);
}

这是一个很常见的面试问题。通过这些问题，面试官试图了解你对对象行为的理解程度，包括构造函数、方法、类变量(静态变量)和实例变量。 如今，面试官们会问另一个最受欢迎的问题:java 1.8的最终版本是什么?我将在最后在java 1.8中解释这个有效的final。

import java.util.ArrayList;
import java.util.List;

class Test {
    private final List foo;

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

    public void setFoo(List foo) {
       //this.foo = foo; Results in compile time error.
    }
}

在上面的例子中，我们为'Test'定义了一个构造函数，并给了它一个'setFoo'方法。

关于构造函数:通过使用new关键字，每次创建对象只能调用构造函数一次。不能多次调用构造函数，因为构造函数不是这样设计的。

关于方法:一个方法可以被你想调用多少次就调用多少次(甚至从来没有调用过)，而且编译器知道它。

场景1

private final List foo;  // 1

foo is an instance variable. When we create Test class object then the instance variable foo, will be copied inside the object of Test class. If we assign foo inside the constructor, then the compiler knows that the constructor will be invoked only once, so there is no problem assigning it inside the constructor. If we assign foo inside a method, the compiler knows that a method can be called multiple times, which means the value will have to be changed multiple times, which is not allowed for a final variable. So the compiler decides constructor is good choice! You can assign a value to a final variable only one time.

场景2

private static final List foo = new ArrayList();

foo is now a static variable. When we create an instance of Test class, foo will not be copied to the object because foo is static. Now foo is not an independent property of each object. This is a property of Test class. But foo can be seen by multiple objects and if every object which is created by using the new keyword which will ultimately invoke the Test constructor which changes the value at the time of multiple object creation (Remember static foo is not copied in every object, but is shared between multiple objects.)

场景3

t.foo.add("bar"); // Modification-2

以上修改-2来自你的问题。在上面的例子中，你没有改变第一个被引用的对象，但是你在foo中添加了允许的内容。如果你试图给foo引用变量赋值一个新的ArrayList()，编译器会报错。 如果你已经初始化了一个final变量，那么你不能改变它来引用一个不同的对象。(在本例中是ArrayList)

Final类不能被子类化 Final方法不能被覆盖。(此方法在超类中) Final方法可以被重写。(请按语法方式阅读。这个方法在一个子类中)

现在让我们看看在java 1.8中什么是有效的最终版本?

public class EffectivelyFinalDemo { //compile code with java 1.8
    public void process() {
        int thisValueIsFinalWithoutFinalKeyword = 10; //variable is effectively final
        
        //to work without final keyword you should not reassign value to above variable like given below 
        thisValueIsFinalWithoutFinalKeyword = getNewValue(); // delete this line when I tell you.
        
        class MethodLocalClass {
            public void innerMethod() {
                //below line is now showing compiler error like give below
                //Local variable thisValueIsFinalWithoutFinalKeyword defined in an enclosing scope must be final or effectively final
                System.out.println(thisValueIsFinalWithoutFinalKeyword); //on this line only final variables are allowed because this is method local class
                // if you want to test effectively final is working without final keyword then delete line which I told you to delete in above program.  
            }
        }
    }

    private int getNewValue() {
        return 0;
    }
}

如果你没有使用final关键字，上面的程序将在java 1.7或<1.8中抛出错误。effective 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关键字。

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

你总是可以初始化一个final变量。编译器确保你只能做一次。

注意，调用存储在final变量中的对象的方法与final的语义无关。换句话说:final只与引用本身有关，而与被引用对象的内容无关。

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