Class initialisation

Question

I've simply want to know why class initialisation is done after the constructor of a superclass has been called.
When the constructor of the superclass uses an abstract function that relies on class attributes it can't work because they aren't initialised until the constructor of the superclass has been finished.The code which was extracted from a concrete problem looks like this:
public class ClassInitialisation {
     private static int staticcounter = 0;
     public ClassInitialisation() {
          new ClassInit();
     public static void main( String[] args ) {
          new ClassInitialisation();
     public class ClassInit extends BaseClass {
          private Integer myobject = new Integer(-1);
          public ClassInit() {
               super();
               Integer result = (Integer) getAbstractFeature();
               System.out.println( "Value should be 0: " + result.intValue() );
          public Integer getAbstractFeature() {
               if( myobject.intValue() != -1 ) return( myobject );
               myobject = new Integer( staticcounter++ );
               System.out.println( "Object created: " + myobject.intValue() );
               return( myobject );
          } /* ENDCLASS */
          public abstract class BaseClass {
          private Integer myabstract ;
          public BaseClass() {
               myabstract = getAbstractFeature();
          public abstract Integer getAbstractFeature();
     } /* ENDCLASS */
} /* ENDCLASS */
My original code has done a check against null, so finding the bug was hard since the corresponding object was simply created again but the superclass referred to the previous one.
Ciao
Kasimir aka Daniel Kasmeroglu

Answer 1

That is extremely annoying, isn't it? I expect the designers of the Java language would have a good explanation, but I don't know what it is. I have been hit with this problem twice already in the project I am working on. I have seen this question discussed in these forums before, and "why" is interesting but pointless, because the Java gurus are not going to change it. The only solution is to modify your design so that your BaseClass does not call methods that could be overridden in its constructor. And this is probably not going to be easy; it was not easy for me. Extremely annoying.