java - Java 中的 "final"关键字是如何工作的？ (我仍然可以修改对象。)

Question

在 Java 中，我们使用 final 关键字和变量来指定其值不会被更改。但是我看到您可以更改类的构造函数/方法中的值。同样，如果变量是 static 那么它就是一个编译错误。

代码如下:

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 static void main(String[] args) 
  {
      Test t = new Test();
      t.foo.add("bar"); // Modification-2
      System.out.println("print - " + t.foo);
  }
}

以上代码运行良好，没有错误。

现在将变量更改为static:

private static final List foo;

现在是编译错误。这个final到底是怎么工作的？

Answer 1

这是一个最喜欢的面试问题。通过这个问题，面试官试图找出你对构造函数、方法、类变量(静态变量)和实例变量的对象行为的理解程度。
现在面试官问另一个最喜欢的问题什么是 java 1.8 中的有效最终。
我将在最后解释 java 1.8 中的这个 有效最终。

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 是一个 instance 变量。当我们创建 Test 类对象时，实例变量 foo 将被复制到 Test 类的对象中。如果我们在构造函数内部赋值foo，那么编译器就知道构造函数只会被调用一次，所以在构造函数内部赋值没有问题。

如果我们在方法内部分配 foo，编译器知道一个方法可以被多次调用，这意味着值必须多次更改，这对于 final< 是不允许的变量。所以编译器决定构造函数是不错的选择! 您只能为最终变量赋值一次。

场景 2

private static final List foo = new ArrayList();

foo 现在是 静态 变量。当我们创建 Test 类的实例时，foo 不会被复制到对象中，因为 foo 是静态的。现在 foo 不是每个对象的独立属性。这是 Test 类的属性。但是 foo 可以被多个对象看到，如果使用 new 关键字创建的每个对象最终都会调用更改的 Test 构造函数创建多个对象时的值(记住 static foo 不是在每个对象中复制，而是在多个对象之间共享。)

场景 3

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

Modification-2 以上来自您的问题。在上述情况下，您不会更改第一个引用的对象，而是在允许的 foo 内添加内容。如果您尝试将 new ArrayList() 分配给 foo 引用变量，编译器会报错。
规则 如果你已经初始化了一个final 变量，那么你不能改变它来引用不同的对象。 (在本例中为 ArrayList)

final 类不能被子类化
final 方法不能被覆盖。 (此方法在父类(super class)中)
final 方法可以覆盖。 (以语法方式阅读。此方法在子类中)

现在让我们看看 java 1.8 中什么是有效的 final？

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 中抛出错误。实际上 final 是 Method Local Inner 类的一部分。我知道你很少会在方法本地类中使用如此有效的final，但我们必须为面试做好准备。