Forward Reference

Question

Hi all,
I seem to have a problem in understanding the Java Specs relative to Forward Reference during initialization.
It goes like this:
"8.3.2.3 Restrictions on the use of Fields during Initialization
The declaration of a member needs to appear before it is used only if the member is an instance (respectively static) field of a class or interface C and all of the following conditions hold:
The usage occurs in an instance (respectively static) variable initializer of C or in an instance (respectively static) initializer of C.
The usage is not on the left hand side of an assignment.
C is the innermost class or interface enclosing the usage.
A compile-time error occurs if any of the three requirements above are not met."
you can find it at http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#287406
A worthy example follows:
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;
}My compiler complains where it should not, for example at the very first assignment x = 100; // ok - assignment . Furthermore, how do you account for the following line:
int z = UseBeforeDeclaration.x * 2;
// ok - not accessed via simple name, I just don't understand why this works while the unqualified counterpart int z = x * 2 does not seem to work. What is the difference? According to the requirements none of the code in first static block should work.
If anyone could shed some light with more examples or even a detailed explaination line by line of the above class, I would be very grateful.
Thank you
luca

Answer 1

My compiler complains where it should not, for example
at the very first assignment
����x = 100; // ok - assignment If you get a compiler error at that line, then your compiler has a bug in it. What compiler are you using?
Furthermore, how do you account
for the following line:
����int z = UseBeforeDeclaration.x * 2; // ok - not accessed via simple name
, I just don't understand why this works while the
unqualified counterpart
����int z = x * 2
does not seem to work. What is the difference?I can see your confusion here. The JLS appears only to say that this is okay in the example, but not in any text. I too would be interested in any explainatino that could be offered for this.
According to the requirements none of the code in
first static block should work.I don't agree. The only code in the first static initialiser block that should fail is the line
����int y = x + 1; // error - read before declaration