Running a method after the constructor of any derived class

Question

Let's say I have a Java class

abstract class Base {     abstract void init();     ... } 

and I know every derived class will have to call init() after it's constructed. I could, of course, simply call it in the derived classes' constructors:

class Derived1 extends Base {     Derived1() {         ...         init();     } }  class Derived2 extends Base {     Derived2() {         ...         init();     } } 

but this breaks "don't repeat yourself" principle rather badly (and there are going to be many subclasses of Base). Of course, the init() call can't go into the Base() constructor, since it would be executed too early.

Any ideas how to bypass this problem? I would be quite happy to see a Scala solution, too.

UPDATE: Here is a generic version of the Factory Method approach:

interface Maker<T extends Base> {     T make(); }  class Base {     ...     static <T extends Base> T makeAndInit(Maker<T> maker) {         T result = maker.make();         result.init();         return result;     } } 

UPDATE 2: This question is basically "how do you use Template Method for constructors"? And the answer seems to be, "You can, but it's a bad idea". So I can do a Template Factory (Template Method + Abstract Factory) instead.

Answer 1

Avoid this. If you do it, any class that extends your DerivedX class may decide to also call init() thus leaving the object in inconsistent state.

One approach is to let the init() method be invoked manually by clients of your class. Have an initialized field, and throw IllegalStateExcepion if any method that requires initialization is called without it.

A better approach would be to use a static factory method instead of constructors:

public Derived2 extends Base {     public static Derived2 create() {        Derived2 instance = new Dervied2();        instance.init();        return instance;     } } 

Update: As you suggest in your update, you can pass Builder to a static factory method, which will call the init() on the instance. If your subclasses are few, I think this is an overcomplication, though.