Generic builder pattern with abstract class

[Alex Miel]

Hi,

I have two classes that inherit abstract class and implement interface. In abstract class I have variables common for both implementation. I also need to construct classes using same builder, which is generic and static in abstract class. Unfortunately it's impossible in Java to call constructor for generic parameter. I want to avoid making specific builder for all implementation. Is there some way to do this?

It looks like this (this is just example but shows what is my problem).

public interface Foo {
    public double start();
}

public abstract class Bar implements Foo {
    protected final double field1;
    protected final double field2;

    protected Bar(Builder builder) {
        this.field1 = builder.field1;
        this.field2 = builder.field2;
    }

    public static class Builder<T extends Bar> {
        private final double field1;
        private double field2;

        public Builder(double field1) {
            this.field1 = field1;
        }

        public Builder add(double field2) {
            this.field2 = field2;
            return this;
        }

        public T build() {
            return new T(this); //type parameter cannot be instantiated directly
        }
    }
}

public class BarImpl1 extends Bar {
    private BarImpl1(Builder builder) {
        super(builder);
    }

    @Override
    public double start() {
        return field1 + field2;
    }
}

public class BarImpl2 extends Bar {
    private BarImpl2(Builder builder) {
        super(builder);
    }

    @Override
    public double start() {
        return field1 * field2;
    }
}

public class Test {
    public static void main(String[] args) {
        Foo foo1 = new Bar.Builder<BarImpl1>(1).add(2).build();
        Foo foo2 = new Bar.Builder<BarImpl2>(3).add(4).build();
    }
}

[R. Jain]

I'm afraid that wouldn't be possible. But suppose even if it was possible, and you created `Builder` instance of super class. Then how would you set attributes for subclasses? Wouldn't be possible right? Only Builder class specific to subclass will do it.

Also, if your super class is abstract, you should also make your super `Builder` class abstract. Else, which object would you expect it's `build()` method to create?

[Stephan van Hulst]

R. Jain, that's not completely true. It would probably be possible through reflection, and the Builder class doesn't need to be abstract. The object created would be determined by the type parameter.

This would however be a completely messy, unnecessary and fragile solution though.

Alex, I would really discourage you from doing this. Why do you need a builder to create subtypes?

[Alex Miel]

I'm aware of reflection and I'd rather not to use them. I need common builder, because sub classes have the same variables but different implementation of interface. I simply don't want to duplicate code. I was also thinking about one subclass without abstract class between and strategy pattern for different implementation.

[Stephan van Hulst]

Use composition over inheritance:

final class FooImpl1 implements Foo {

  private final Bar bar;

  FooImpl1(Bar bar) {
    Objects.requireNonNull(bar);
    this.bar = bar;
  }

  public double start() {
    return bar.getField1() + bar.getField2();
  }
}

You should always be wary of extending classes.

[Winston Gutkowski]

Alex Miel wrote:I have two classes that inherit abstract class and implement interface. In abstract class I have variables common for both implementation. I also need to construct classes using same builder, which is generic and static in abstract class. Unfortunately it's impossible in Java to call constructor for generic parameter. I want to avoid making specific builder for all implementation. Is there some way to do this?

Yes but, like the others, I suspect it's not what you want.

1. Builders are usually used to create complex objects - especially ones that have many "default" values - not generic ones.
2. If the subtypes have identical contents, why are they subtypes? You may have a reason, but I think you need to explain it.

What is possible is that your Bar class constructor takes a Builder<? extends Bar> and uses it to initialize its fields, while the subclass has something like a make(Builder<SubClass>) method (defined as abstract in Bar) that uses a "dummy" constant of its own type. Your generic Builder could then call:
return T.make(this);
in its build() method. But it's quite tortuous, and I suspect there's a more elegant solution.

Winston