Is the following code the case of legal forward referencing? if yes why?

public class MyClass
{
  private static int x = getValue();
  private static int y = 5;
  private static int getValue()
  {
    return y;
  }
  public static void main(String[] args)
  {
    System.out.println(x);
  }
}

• java
• reference
• forward
• static-initialization

The above code you have is perfectly legal Java. In Java, static fields are initialized as follows: first, all fields are set to the default for their type (0, false, or null), and then initialized in the order in which they are declared. This means that the above code is guaranteed to do the following:

1. Set x and y to zero, since that's the default value for ints.
2. Initialize x by calling getValue(), which reads the value of y. Since y hasn't yet been initialized, it still has the value 0.
3. Initialize y to 5.

This means that x will take the value 0 and y will take the value 5. This behavior is portable and guaranteed. You can see this here.

Hope this helps!

You can tell whether it's legal or not by the fact that it compiles; unlike some other languages, Java doesn't have the notion of "undefined behavior." What happens here is completely spelled out. It may be counterintuitive, but it's specifically legal: you can access a static variable before it's initialized from a method called while initializing another static variable. The superficially similar case of accessing y directly from x's initializer -- i.e.,

private static int x = y;
private static int y = 5;

is specifically disallowed. There's really no strong reason why -- it's just how it is.