Default initialisation of instance vars...

Question

* This program currently prints "s before Super() finished is Hello"
* followed by "s after Super() finished is Hello"
* If the declaration 'String s' is changed to 'String s = null'
* the program prints "s after Super() finished is null"
* I know this is the wrong way to do things, but my question is
* Why isn't the initialisation of instance var s set to null even if
* I don't explicitly say 'String s = null' i.e. what happened to the
* default initialisation to null??
* I believe this is a potentially disastrous situation for our app
* which uses this type of initialisation extensively, however am
* having trouble convincing the designer of this.
class Super {
     public Super() {
          init();
     protected void init() {
class Sub extends Super {
     String s;
     public Sub() {
          super();
          System.out.println("s after Super() finished is " + s);
     protected void init() {
          s = "Hello!";
          System.out.println("s before Super() finished is " + s);
public class Test1 {
     public static void main(String[] args) {
          new Sub();

Answer 1

My suggestion to your designer:
An init() method shared between constructors (within a class) is great and centralised, but declare it final. If you can't declare it final, then declare it private, which statically links the method call so the base class will always call its own init method, never its sub-classes'.
Allowing a base class constructor to access a method in a subclass is potentially catastrophic!
The following demonstrates the initialisation order for classes...class Base {
    static {
        System.out.println("Base static initialization");
    private int base = init();
    public Base() {
        System.out.println("Base constructor");
    private int init() {
        System.out.println("Base initialization");
        return 1;
class Sub extends Base {
    static {
        System.out.println("Sub static initialization");
    private int sub = init();
    public Sub() {
        System.out.println("Sub constructor");
    private int init() {
        System.out.println("Sub initialization");
        return 2;
public class Test {
    public static void main(String[] args) {
        new Sub();
$ java Test
Base static initialization
Sub static initialization
Base initialization
Base constructor
Sub initialization
Sub constructorThe primary use for a constructor (IMHO) is to create an instance of a class that satisfies the class invariants. The logic within the constructor should then, in particular, ensure those invariants before exiting. If a constructor calls (directly or indirectly) an overridable method that is required to ensure the base class invariants, and the overriding method does not call make a call to the overriden method, then the base class invariants no longer hold.
Further, in the case of an init() method that all classes will call on construction, and in sub classes the first line will always call the super-class implementation (Thus preventing the above situation), in subclasses this init method will be called more than once - by each constructor in the chain - which may lower performance, or even break class invariants once again.
Finally, it's just too uncertain exactly what order your initialisation is going to complete in... except that at some point, you will have access to uninitialised members of your subclass.
This topic is one of those covered in Joshua Bloch's Effective Java, stating that a constructor should simply never call an overridable method. Go final, or go private.
If the designer doesn't listen, tell him (her?) s/he'll have to debug any initialisation timing problems that crop up, because no sane programmer will take that job :-)
-Troy