About Block Initializer

[Amanda Fu]

I'm interested in the sequence of variable(static or instance) declarations and their block initializers (static or instance respectively).
Is the declaration executed earlier then the block even it is declared later? Such as following code,

class Test {
    static {
        x=1;
    }
    static int x;
}

According to JLS8.3.2.3, http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#287406
it seems the above code will compile without error, but when I compile it under 1.4, it says "illegal forward reference". In JLS it also has a long code as follow,

class UseBeforeDeclaration {
static {
x = 100; // ok - assignment
int y = x + 1; // error - read before declaration
int v = x = 3; // ok - x at left hand side of assignment
int z = UseBeforeDeclaration.x * 2;
// ok - not accessed via simple name
Object o = new Object(){ 
void foo(){x++;} // ok - occurs in a different class
{x++;} // ok - occurs in a different class
    };
  }
{
j = 200; // ok - assignment
j = j + 1; // error - right hand side reads before declaration
int k = j = j + 1; 
int n = j = 300; // ok - j at left hand side of assignment
int h = j++; // error - read before declaration
int l = this.j * 3; // ok - not accessed via simple name
Object o = new Object(){ 
void foo(){j++;} // ok - occurs in a different class
{ j = j + 1;} // ok - occurs in a different class
};
}
int w = x= 3; // ok - x at left hand side of assignment
int p = x; // ok - instance initializers may access static fields
static int u = (new Object(){int bar(){return x;}}).bar();
// ok - occurs in a different class
static int x;
int m = j = 4; // ok - j at left hand side of assignment
int o = (new Object(){int bar(){return j;}}).bar(); 
// ok - occurs in a different class
int j;
}

I compile the above code with error lines commented, it fails too. So now I'm confused, or have I misunderstood the JLS?

[Andres Gonzalez]

From what I understand, static initializers are executed first in the order they've been placed in the code. Instance initializers are only executed (also in order) when you create an instance of the class.
[ July 21, 2003: Message edited by: Andres Gonzalez ]

[Amanda Fu]

Thanks for your reply! But how about the execute order of initializer and declaration?

[Andres Gonzalez]

Originally posted by Amanda:
Thanks for your reply! But how about the execute order of initializer and declaration?

Sorry but I did not get your question :roll:

[Amanda Fu]

As my understanding, a static block cannot make a forward reference to static variables that they are defined after its definition. So I cannot understand the above code in JLS, if we only concern the static variable x, remove all others unrelated lines,

  
class UseBeforeDeclaration {
static {
x = 100; // ok - assignment
int y = x + 1; // error - read before declaration
int v = x = 3; // ok - x at left hand side of assignment
int z = UseBeforeDeclaration.x * 2;
// ok - not accessed via simple name
Object o = new Object(){ 
void foo(){x++;} // ok - occurs in a different class
{x++;} // ok - occurs in a different class
    };
  }
static int x;
}

I regard even the first line: x=100 will not compile. But JLS says it is "Ok", that's where I'm confused.

[cyril vidal]

 
class Test {
    static {    
         x=1;   
     }    
    static int x;
}
 

it seems the above code will compile without error, but when I compile it under 1.4, it says "illegal forward reference".

Do you use an IDE?
I have no problem in compiling this by command-line with SDK1.4...

[Vicken Karaoghlanian]

I compiled the code successfully with SDK 1.4