The method you write in class B will be exceuted for the instance of class B
even if it is called from Class A's constructor

No

--
Mike W

No, a superconstructors has always to be called by a (sub)constructor. If
you don't explicitly define a constructor, then the superconstructor with no
parameters is implicitly called (*)

I don't see the problem, please explain more in detail

(*) Only if the superclass has no explicitly defined constructors with more
then 0 params, otherwise the compiler will give an error

Any B constructor is also constructing/initialialising an inner A
object. Therefore it must first call SOME constructor of A.

If you don't do that, the compiler will often insert code for you that
does.

Constructors should avoid methods that are overridden. It creates
nightmarish can of worms and all kinds of very hard to figure out
bugs. I suspect, had it been easy to enforce, the JLS would have
banned the use of non final methods in constructors.

http://mindprod.com/jgloss/constructor.html
and follow links.

No.

The nearest you can come is something like the following.  If you have:

class A
{
   A(int i)
   {
       theMethod(int i);
   }

   void theMethod(int i) { }
}

And you want to create a subclass B which overrides theMethod() but without it
being called during initialisation. So:

class B
{
   boolean intialized;

   B(int i)
   {
       super(i);
       initialized = true;
   }

   void theMethod(int i)
   {
      if (!initialized)
      {
           super.theMethod(i);
           return;
       }
       // ...other code...
   }
}

Note that doing this sort of thing is normally a symptom of a design error
somewhere (possibly in the class you wish to subclass from, possibly in what
you are trying to do with it).

   -- chris

Constructors calling (virtual) methods are bad (though not as bad as in
C++). Best avoided.

If you really, really have to then make the overriding method correct
even before you constructor has executed. There are hacks with
thread-locals, synchronised statics or inner classes (with -target 1.4
or greater) to hand context information over.

You could rewrite the bytecode of A. Possibly if it is Serializable, you
could hack around the constructor calling the method, but the method
would probably get called during deserialisation anyway.

Tom Hawtin

kebabkongen@hotmail.com wrote on 22.11.2005 15:24:

This should work:

ClassA classAVar = new ClassA(<params>)
{
  public void fixMeMethod()
  {
    // do the correct work here
  }
};

Regards
Thomas