Why does Java compiler allow static variable access through null object? [duplicate]

Answer 1

There is no need for an instance while invoking static member or method.

Since static members belongs to class rather than instance.

A null reference may be used to access a class (static) variable without causing an exception.

http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#d5e19846

If you see the example (see full example in spec)

 public static void main(String[] args) {
        System.out.println(favorite().mountain); //favorite() returns null
    }

Even though the result of favorite() is null, a NullPointerException is not thrown. That "Mount " is printed demonstrates that the Primary expression is indeed fully evaluated at run time, despite the fact that only its type, not its value, is used to determine which field to access (because the field mountain is static).

Answer 2

What is the reason of NullPointerException in a code like that:

  TestClass t = null;
  t.SomeMethod();

If SomeMethod is an instance method it'll do something with standard this reference:

  public void SomeMethod() {
    // Here we'll have a NullPointerException (since "this" is null)
    this.SomeField = ... // <- We usually omit "this" in such a code
  }

Since this is null we'll have NullPointerException. If method, field etc. is static it's guaranteed the absense of this reference, so there'll be no NullPointerException

  public static void SomeStaticMethod() {
    // You can't put "this.SomeField = ..." here, because the method is static
    // Ans since you can't address "this", there's no reason for NullPointerException
    ...
  }

  ...

  TestClass t = null; 
  // Equal to "TestClass.SomeStaticMethod();"
  t.SomeStaticMethod(); // <- "this" is null, but it's not addressed

Answer 3

t1.a is equivalent to TestClass1.a in this case, since a is a static member (not an instance member). The compiler looks at the declaration of t1 to see what type it is, and then just treats it as if you had used the type name. The value of t1 is never checked. (But if it were a method call, like method(args).a, I think the method would be called. But the return value would be thrown away, and never checked.) (Edit: I've verified that method(args) is called, but no exception is thrown if the function result is null.)

Answer 4

Any Static member can be accessed by Directly class name as TestClass1.a no need of instance for it

  System.out.println(TestClass1 .a);

output: 10

Answer 5

The static members are shared by all the instances of a class and not reallocated separately to each instance. These are loaded by the classloader moment the class is encountered for the first time. A related SO question

Please do keep in mind these static members do not belong to a specific class instance. More info here. I have included a small code snippet for reference:

@NotThreadSafe
public class Test {

  // For all practical purpuose the following block will be only executed once at class load time.
  static {
   System.out.println("Loaded by the classloader : " + Test.class.getClassLoader());
  }

  // Keeps track of created instances.
  static int instanceCount;


  // A simple constructor that increments instance count.
  public Test(){
   Test.instanceCount++;
   System.out.println("instance number : " + instanceCount);
  }

  public static void main(String[] args) {
   System.out.println("Instaintiating objects");
   new Test(); new Test();
  }

  // Where would you expect this line to get printed? 
  // i.e last statement on the console or somewhere in the middle :)
  static {
    System.out.println("It should be printed at the end or would it?");
   }
 }

Answer 6

Since a is static compiler converts it to TestClass1.a. For non-static variables it would throw NullPointerException.