Mfcttrf

class Foo
 public static int x = 1;

 public static void main(String[] args) 
 Foo foo;
 System.out.println(foo.x); // Error: Variable 'foo' might not have been initialized
 

While trying to access x via an uninitialized local variable Foo foo; I get the compile error Variable 'foo' might not have been initialized.

It could seem like this error makes sense, but only until we realize that to access a static member the compiler doesn't use the value of a variable, but only its type.

For instance I can initialize foo with value null and this will let us access x without any problems:

Foo foo = null;
System.out.println(foo.x);//Now it works!!!

Such scenario works because compiler realizes that x is static and treats foo.x as it was written Foo.x (at least that is what I thought until now).

So why compiler suddenly insists on foo having a value which it will NOT use at that place?

^{(Disclaimer: This is not code which would be used in real application, just interesting phenomenon which I couldn't find answer to on Stack Overflow so I decided to ask about it.)}

§15.11. Field Access Expressions:

If the field is static:

The Primary expression is evaluated, and the result is discarded. If evaluation of the Primary expression completes abruptly, the field access expression completes abruptly for the same reason.

Where earlier it states that field access is identified by Primary.Identifier.

This shows that even though it seems to not use the Primary, it is still evaluated and the result is then discarded which is why it will need to be initialized. This can make a difference when the evaluation halts the access as stated in the quote.

Chapter 16. Definite Assignment

Each local variable (§14.4) and every blank final field (§4.12.4, §8.3.1.2) must have a definitely assigned value when any access of its value occurs.

It doesn't really matter what you try to access via a local variable. The rule is that it should be definitely assigned before that.

To evaluate a field access expression foo.x, the primary part of it (foo) must be evaluated first. It means that access to foo will occur, which will result in a compile-time error.

For every access of a local variable or blank final field x, x must be definitely assigned before the access, or a compile-time error occurs.

There is value in keeping the rules as simple as possible, and “don’t use a variable that might not have been initialised” is as simple as it gets.

More to the point, there is an established way of calling static methods - always use the class name, not a variable.

System.out.println(Foo.x);

The variable “foo” is unwanted overhead that should be removed, and the compiler errors and warnings could be seen as helping leading towards that.