javajava-8staticstatic-block

why static block cannot access the static variable defined after it

I've checked Forward References During Field Initialization and this the answer from @assylias, but still I got no answer to the why.

Why a static block can assign the static variable declared after it but can NOT access it? 

   class Parent {
        static {
            i = 2; // valid
            // can only assign new value to it instead of accessing it?
//            System.out.println(i); // invalid - compile-error
        }
        static int i = 0;
        static {
            i = 3; // valid
        }
    }

Is it due to the fact: the value is not initialized yet, so we just explicitly inhibit you from using it? or there are something related to security I don't know?

updated

this is not a duplicate of that problem which is about

Why this doesn't happen when accessing with class name?

This question is about why we have this design? for what purpose?

Solution

  • After some further reading, I think Pavel is not quite accurate in this point as @Holger pointed out in the comment.

    we have initialized i variable twice, which is not possible, since the field is static.

    As the 12.4.2. Detailed Initialization Procedure points out

    For each class or interface C, there is a unique initialization lock LC. The mapping from C to LC is left to the discretion of the Java Virtual Machine implementation.

    I suppose the initialization twice is okay to the class initializer itself as long as it's just once to the invoking clients.

    But the demos Pavel provided still stands its position so I basically just reuse it here but with different explanation. 

    static {
       i = 2;
       j = i + 5; 
       // no one knows whether "i" here initialized properly here
}
static int i = 10;
static int j;

    But when you use MyClass.i directly in j = MyClass.i + 5, the compiler would know it would then be okay as 8.3.3. Forward References During Field Initialization detailed with four conditions.

    Specifically, it is a compile-time error if all of the following are true:

    1. The declaration of a class variable in a class or interface C appears textually after a use of the class variable;

    2. The use is a simple name in either a class variable initializer of C or a static initializer of C;

    3. The use is not on the left hand side of an assignment;

    4. C is the innermost class or interface enclosing the use.

    And there is a detailed discussion in this answer already.

    To wind it up, I think this would be for predictable behavior to add these restrictions. Once again, the other official purpose pointed out in 8.3.3. Forward References During Field Initialization.

    These restrictions are designed to catch, at compile time, circular or otherwise malformed initializations.