Why is the order of declarations important for static initializers?

Question

I have this code

private static Set<String> myField;

static {
    myField = new HashSet<String>();
    myField.add("test");
}

and it works. But when I flip the order, I get an illegal forward reference error.

static {
    myField = new HashSet<String>();
    myField.add("test"); // illegal forward reference
}

private static Set<String> myField;

I'm a little bit shocked, I didn't expect something like this from Java. :)

What happens here? Why is the order of declarations important? Why does the assignment work but not the method call?

Answer 1

First of all, let's discuss what a "forward reference" is and why it is bad. A forward reference is a reference to a variable that has not yet been initialized, and it is not confined only to static initalizers. These are bad simply because, if allowed, they'd give us unexpected results. Take a look at this bit of code:

public class ForwardRef {
    int a = b; // <--- Illegal forward reference
    int b = 10;
}

What should j be when this class is initialized? When a class is initialized, initializations are executed in order the first to the last encountered. Therefore, you'd expect the line

a = b; 

to execute prior to:

b = 10; 

In order to avoid this kind of problems, Java designers completely disallowed such uses of forward references.

EDIT

this behaviour is specified by section 8.3.2.3 of Java Language Specifications:

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.

Answer 2

try this:

class YourClass {
    static {
        myField = new HashSet<String>();
        YourClass.myField.add("test");
    }

    private static Set<String> myField;
}

it should compile without errors according the JLS...
(don't really help, or?)

Answer 3

In Java, all initializers, static or otherwise, are evaluated in the order in which they appear in the class definition.

Answer 4

See the rules for forward references in the JLS. You cannot use forward references if:

• 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.
• The usage is via a simple name.
• C is the innermost class or interface enclosing the usage.

Since all of these hold for your example, the forward reference is illegal.

Answer 5

To elaborate on DFA's answer:

I think what's tripping you up is the "left hand side" rule in the second bullet point in JLS 8.2.3.2. In your initialization, myField is on the left-hand side. In your call to add, it's on the right-hand side. The code here is implicitly:

boolean result = myField.add('test')  

You're not evaluating the result, but the compiler still acts as if it's there. That's why your initialization passes while your call to add() fails.

As for why this is so, I have no idea. It may well be for the convenience of the JVM developers, for all I know.

Answer 6

I think the method call is problematic because the compiler cannot determine which add() method to use without a reference type for myField.

At runtime, the method used will be determined by the object type, but the compiler only knows about the reference type.