How to write subclass constructors without duplicating your code?

Question

I want to call an abstract method, generateId(), in the constructor of an abstract super class, where this abstract method depends on some fields of the respective subclasses. Consider the following pieces of code for clarity:

Abstract class: SuperClass

public abstract class SuperClass {
   protected String id;

   public SuperClass() {
        generateId();
   }

   protected abstract void generateId();
}

Subclass: Sub1

public class Sub1 extends SuperClass {
   private SomeType fieldSub1;

   public Sub1(SomeType fieldSub1) {
      this.fieldSub1 = fieldSub1;
      super();
   }

   protected void generateId() {
      // Some operations that use fieldSub1
   }
}

Subclass: Sub2

public class Sub2 extends SuperClass {
   private SomeOtherType fieldSub2;

   public Sub2(SomeOtherType fieldSub2) {
      this.fieldSub2 = fieldSub2;
      super();
   }

   protected void generateId() {
      // Some operations that use fieldSub2
   }
}

However, the subclass constructors won't work because the super(); must be the first statement in a constructor.

OTOH, if I make super(); the first statement in the constructors of the subclasses, then I won't be able to call generateId() in SuperClass. Because generateId() uses fields in subclasses, where these fields must be initialized before being used.

The only way to "solve" this problem appears to me: Remove the call to generateId() in the superclass. Place a call to generateId() at the end of constructors of each subclass. But this results in code duplication.

So is there any way to solve this problem without duplicating my code? (That is, without calling generateId() at the end of constructors of each subclass?)

Answer 1

As @GuillaumeDarmont pointed out, using overridable methods in constructs is bad practice.

You want to oblige the superclass id to be initialized by subclasses, so change the constructor:

public abstract class SuperClass {
    protected String id;

    public SuperClass(String id) {
        this.id = id;
    }
}

Also, you might want to change generateId() to be a static method, since you cannot reference this before superclass constructor has been called:

public class Sub1 extends SuperClass {
    private SomeType fieldSub1;

    public Sub1(SomeType fieldSub1) {
        super(generateId(fieldSub1));
        this.fieldSub1 = fieldSub1;
    }

    private static String generateId(SomeType fieldSub1) {
        // Some operations that use fieldSub1
    }
}

EDIT: As SuperClass does not know how to calculate the id, but you want to enforce it has an id, one of your options is the solution above. Another option would be:

public abstract class SuperClass {
    private String id;

    public String getId() {
        if (id == null) { id = generateId(); }
        return id;
    }
    protected abstract String generateId();
}


public class Sub1 extends SuperClass {
    private SomeType fieldSub1;

    public Sub1(SomeType fieldSub1) {
        this.fieldSub1 = fieldSub1;
    }

    @Override protected String generateId() {
        // Some operations that use fieldSub1
    }
}

The difference between both solutions is about when the id will be calculated: at the object initialization time, or the first time the id is requested. That is what @Turing85 was discussing.

Answer 2

You can try to use instance or static initialization blocks.

Order of initialization:

1. All static items in their source code order.
2. All member variables.
3. The constructor is called.

For example:

class InitBlocksDemo {

    private String name ;

    InitBlocksDemo(int x) {
        System.out.println("In 1 argument constructor, name = " + this.name);
    }

    InitBlocksDemo() {
        name = "prasad";
        System.out.println("In no argument constructor, name = " + this.name);

    }

    /* First static initialization block */
    static {
        System.out.println("In first static init block ");
    }

    /* First instance initialization block  */
    {
        System.out.println("In first instance init block, name = " + this.name);
    }

    /* Second instance initialization block */
    {
        System.out.println("In second instance init block, name = " + this.name);
    }

    /* Second static initialization block  */
    static {
        System.out.println("In second static int block ");
    }

    public static void main(String args[]) {
        new InitBlocksDemo();
        new InitBlocksDemo();
        new InitBlocksDemo(7);
    }

}

Output:

In first static init block
In second static int block
In first instance init block, name = null
In second instance init block, name = null
In no argument constructor, name = prasad
In first instance init block, name = null
In second instance init block, name = null
In no argument constructor, name = prasad
In first instance init block, name = null
In second instance init block, name = null
In 1 argument constructor, name = null

Source of examples: link.

Answer 3

You could make SuperClass have a ParentType variable and then cast the type in the subclasses. Sorry about what I said in the comments, the terminology was a bit off. You can't change the type of a superclass's variables in the subclass. But you can cast.

I just realized that you can't pass a super class and cast it to a subclass. You can only go the other way, as "all dogs are animals but not all animals are dogs".

Anyway, I thought of another possible solution. First the variables:

public class ParentType { //stuff }

public class SomeType extends ParentType { //more stuff }

public class SomeOtherType extends ParentType { //even more stuff }

You could use an idea from this post. BTW I'm kind of venturing into the unknown here, I haven't done this before. If someone spots a mistake with this, please comment or edit.

Make your class generic:

public abstract class SuperClass<Type extends ParentType> {
    protected Type field;
}

public class Sub1<SomeType> {
    //now field is of type SomeType
}

public class Sub2<SomeOtherType> {
    //now field is of type SomeOtherType
}