为什么最终实例变量不需要初始化，而最终局部变量不需要初始化？

Question

The following example class does not compile:

class Test {
    final int x;  // Compilation error: requires initialization.
}

The compilation error message for this code is:

..\src\pkgs\main\Test.java:3: error: variable x might not have been initialized
class Test {
^

However, Java does not generate any error message for a class that contains the following method:

class Test {
    void method() {
        final int x;  // Compiles OK; has no initialization.
    }
}

Regarding initialization and its requirement, why does Java treat final instance variables and final local variables differently? Thanks.

Answer 1

An instance variable is implicitly used by the instance. The local variable example you gave isn't using the local variable, so there's no error (the variable isn't used).

Your local variable example will fail to compile (with the same error) if you try to use x :

class Test {

    Test() {
        final int x;
        System.out.println(x); // <== Compilation error - "variable x might not have been initialized"
    }
}

Similarly, your first example is fine provided you do initialize the variable at some point, not necessarily in the declaration:

class Test {
    final int x;

    Test() {
        this.x = 10;
    }
}

Answer 2

Any use , ie read, of the second case would give you an error . But unused variables count as a warning, not an error; the meaning of the code that runs is unambiguous, if quite likely wrong.

For the constructor case, there isn't that kind of unused variable analysis performed by the compiler, if only because (for anything except private fields) it might be read in another file the compiler doesn't have access to.

So it needs to be trapped as an error to avoid run-time behaviour that would end up depending on unspecified JVM implementaion details.

Answer 3

Final attricutes should be initialized in constructors, that's why it does not compile in your example. Final variable should be also initialized before being used. It's fine to declare it method with not initialization.