returning inherited class instead of superclass in method overriding

Question

I have a certain class structure that looks something like this:

class Parent {
    public Parent(int property) { /* use property */}
}
class Son extends Parent {
    public Son(int parentProperty, String sonProperty) { 
        super(parentProperty);
        /* use son property */ 
    }
}

I'd like to create builders for both these classes such that:

class ParentBuilder {
    protected int parentProperty;

    public ParentBuilder parentProperty(int parentPropertyValue) {
        parentPropertyValue = parentPropertyValue;
        return this;
    }

    public Parent build() {
        return new Parent(parentProperty);
    }
}
class SonBuilder extends ParentBuilder {
    private String sonProperty;

    public SonBuilder sonProperty(String sonProperty) {
        this.sonProperty = sonProperty;
        return this;
    }

    @Override
    public Son build() {
        return new Son(parentProperty, sonProperty);
    }
}

but this causes the following problem:

SonBuilder sonBuilder = new SonBuilder();
sonBuilder.sonProperty("aString").build(); // this works and creates Son
sonBuilder.sonProperty("aString").parentProperty(1).build(); // this works and creates Parent instead of Son
sonBuilder.parentProperty(1).sonProperty("aString").build(); // this doesn't work

I realize I'm nitpicking and this could be solved with just not returning this (i.e. without method chaining), but I'm wondering if there is an elegant solution.

edit

It seems that the word "elegant" is a source for a bit of confusion.

By "elegant" I mean a solution which allows for method chaining and does not involve casting.

I'm a C++ guy so not sure, but would your 3rd line really create a `Parent` object? Or a `Son` object and return it as `Parent` reference? — king_nak, Nov 09 '17 at 09:25
@king_nak yes, I was actually asking if it was possible to return the current class (`Parent` or `Son`) when returning `this`. Without casting and without forgoing the method chaining. — qwertyizer, Nov 09 '17 at 09:50

davidxxx · Accepted Answer · 2017-11-09T09:24:37.220

First point

sonBuilder.sonProperty("aString").parentProperty(1).build();

this works and creates Parent instead of Son

It is expected as parentProperty() returns a ParentBuilder :

public ParentBuilder parentProperty(int parentPropertyValue) {...

And ParentBuilder.build() creates a Parent :

public Parent build() {
    return new Parent(parentProperty);
}

Second point

sonBuilder.parentProperty(1).sonProperty("aString").build(); // this doesn't work

As said in the first point, parentProperty() returns a ParentBuilder.
And ParentBuilder of course doesn't have a sonProperty() method.
So it cannot compile.

I'm wondering if there is an elegant solution.

An elegant solution would be not make SonBuilder inherited ParentBuilder but compose with a ParentBuilder field. For example :

class SonBuilder {

    private String sonProperty;
    private ParentBuilder parentBuilder = new ParentBuilder();

    public SonBuilder sonProperty(String sonProperty) {
      this.sonProperty = sonProperty;
      return this;
    }

    public SonBuilder parentProperty(int parentPropertyValue) {
      parentBuilder.parentProperty(parentPropertyValue);
      return this;
    }

    public Son build() {
      return new Son(parentBuilder.parentProperty, sonProperty);
    }
}

You can so create the Son in this way :

SonBuilder sonBuilder = new SonBuilder();
Son son = sonBuilder.sonProperty("aString").parentProperty(1).build();

I like it, a bit of extra coding but it's typesafe and has no functional leakage, will use. — qwertyizer, Nov 09 '17 at 09:47
It is its big advantage : no leakage/coupling between the builders. This other answer https://stackoverflow.com/a/47198377/270371 provides a shorter way but has this drawback. I suppose that according to the level of class stability, the one or the second one is fine. — davidxxx, Nov 09 '17 at 10:04

midorlo · Answer 2 · 2017-11-09T09:22:11.690

0

You can test for the parent property to exist in your build() method.

return (parentProperty == null) ? new Parent(parentProperty, sonProperty) : new Son(sonProperty);

edited Nov 09 '17 at 09:22

answered Nov 09 '17 at 09:12

midorlo

33
5

Would that be 'elegant'? – Stefan Nov 09 '17 at 09:14
parent property will always exist, it is part of `ParentBuilder`, the problem is that when I set `parentProprerty` via `parentProperty(...)` I'm getting back a `ParentBuilder` instead of `SonBuilder` – qwertyizer Nov 09 '17 at 09:15

score 0 · Answer 3 · answered Nov 09 '17 at 09:17

0

I'm not sure if it can be considered as elegant, but you can use casting:

SonBuilder sonBuilder = new SonBuilder();
Son son1 = sonBuilder.sonProperty("aString").build();
Son son2 = (Son) sonBuilder.sonProperty("aString").parentProperty(1).build();
Son son3 = ((SonBuilder) sonBuilder.parentProperty(1)).sonProperty("aString").build();

answered Nov 09 '17 at 09:17

Eran

387,369
54
702
768

1

honestly, this is probably the shortest way, with the least code repetition. – qwertyizer Nov 09 '17 at 09:45

Alexey Romanov · Answer 4 · 2017-11-09T09:50:58.307

Override parentProperty in SonBuilder:

@Override
public SonBuilder parentProperty(int parentPropertyValue) {
    super.parentProperty(parentPropertyValue);
    return this;
}

This is safe because (and as long as) super.parentProperty returns this. If you have immutable builders instead, your override would also be different.

Or use generics:

abstract class AParentBuilder<T extends Parent> {
    protected int parentProperty;

    public AParentBuilder<T> parentProperty(int parentPropertyValue) {
        parentPropertyValue = parentPropertyValue;
        return this;
    }

    abstract public T build();
}

class ParentBuilder extends AParentBuilder<Parent> {
    @Override
    public Parent build() {
        return new Parent(parentProperty);
    }
}

abstract class ASonBuilder<T extends Son> extends AParentBuilder<T> {
    private String sonProperty;

    public ASonBuilder<T> sonProperty(String sonProperty) {
        this.sonProperty = sonProperty;
        return this;
    }
}

class SonBuilder extends ASonBuilder<Son> {
    @Override
    public Son build() {
        return new Son(parentProperty, sonProperty);
    }
}

davidxxx · Answer 5 · 2017-11-09T09:58:55.633

An alternative way is using covariant return type in the subclass method.

Keep SonBuilder extend ParentBuilder but override parentProperty() to return a SonBuilder :

@Override
public SonBuilder parentProperty(int parentPropertyValue) {
   super.parentProperty(parentPropertyValue);
   return this;
}

You can still create the Son in this way :

SonBuilder sonBuilder = new SonBuilder();
Son son = sonBuilder.sonProperty("aString").parentProperty(1).build();

as now parentProperty(1) invokes the subclass method that returns a SonBuilder.

This solution may seem fine but it has a drawback.
It creates a strong coupling between the subclass builder and the base builder.
At each time you add a setProperty method in the parent builder, you have to override it in the subclass.
Otherwise, you would still have the initial problem : a code that doesn't compile or it would instantiate the Parent instead of the Son class.
For classes that don't change at all, it may be acceptable.
Otherwise, it should be avoided.

The solution using the composition is better as it allows the SonBuilder to evolve at its own rhythm and with its own rules.

returning inherited class instead of superclass in method overriding

5 Answers5

Linked