这是一个很常见的面试问题。通过这些问题，面试官试图了解你对对象行为的理解程度，包括构造函数、方法、类变量(静态变量)和实例变量。
如今，面试官们会问另一个最受欢迎的问题: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，但是对于面试，我们必须做好准备。
