Question

Suppose I have two classes defined the following way:

public class A {

   public A() {
      foo();
   }

   public void foo() {
      System.out.println("A");
   }
}

public class B extends A {

   private String bar;

   public B() {
      bar = "bar";
   }

   @Override
   public void foo() {
      System.out.println(bar);
   }

}

And then i instantiate B the following way:

A test = new B();

So why can’t the compiler respectively the IDE warn me that there will be a NullPointer in the foo method of B? That wouldn’t be to difficult to check and sometimes very useful.

Answer 1

While this is a design error, it’s not a grammatical error.

Here’s some quote from Effective Java 2nd Edition, Item 17: Design and document for inheritance, or else prohibit it:

There are a few more restrictions that a class must obey to allow inheritance. Constructors must not invoke overridable methods, directly or indirectly. If you violate this rule, program failure will result. The superclass constructor runs before the subclass constructor, so the overriding method in the subclass will be invoked before the subclass constructor has run. If the overriding method depends on any initialization performed by the subclass constructor, the method will not behave as expected.

An obedient compiler would let it compile just fine, since it is linguistically legal. Fortunately, code analysis tools can be used to find these design errors, e.g. findbugs:

UR: Uninitialized read of field method called from constructor of superclass (UR_UNINIT_READ_CALLED_FROM_SUPER_CONSTRUCTOR)

This method is invoked in the constructor of of the superclass. At this point, the fields of the class have not yet initialized.