why static block cannot access the static variable defined after it

Question

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?

Answer 1

Static fields are initialized based on the order they appear in the code.

So, when you assign a value to i variable you just say to the compiler: "Hey, guy, when you get to initialize this variable, set its value to...". But you can not use it until it's initialized because it simply does not exist yet.

UPDATE:

As it says in the book "The Java Language Specification" by James Gosling, Bill Joy, Guy Steele and Gilad Bracha:

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

Consider this:

static {
            i = 2;
            j = i + 5; //should it be 7 or 15?
}
static int i = 10;
static int j;

Should j variable be 7 or 15? If it's 7, then we have initialized i variable twice, which is not possible, since the field is static. If it's 15 then what does i = 2; mean?

This code is ambiguous, so Java Specification does not allow to do that.

Answer 2

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.

Answer 3

The same is also applicable to the non-static members. You can assign values to them in instance initializer block but can not use them before initialization.

class Parent {
    {
        x = 3; // works fine
        // System.out.println(x); // gives compilation error.

    }
    int x = 0;

    public static void main(String[] args) {

    }
}