具有继承性的 Java Builder 模式

Question

我想用静态内部类实现一个构建器模式，让我们说类 A 有字段(a1，a2，a3)，B 有字段(b1，b2)和 C 有字段(c1)，而所有共享字段( s1, s2) 来自父类(super class) SuperClass:

public class A extends SuperClass {
    private final String a1;
    ...

    private A(ABuilder builder) {
        super(builder);
        this.a1 = builder.a1;
        ...
    }

    public static class ABuilder extends SuperClassBuilder implements ABuilderInterface {
        private String a1;
        ...

        @Override
        public ABuilder withA1(String a1) {
            this.a1 = a1;
            return this;
        }
        ...

        @Override
        public SuperClass build() {
            return new A(this);
        }
    }
}

相应地，对于 B 和 C，构建器的不同之处在于它们具有自己的字段并实现自己的接口(interface)(BBuilderInterface 和 CBuilderInterface)，而这些接口(interface)仅定义要实现的方法:

public interface ABuilderInterface extends SuperClassBuilderInterface {
    ABuilderInterface withA1(String a1);
    ...
}
...<interfaces for B and C>

public interface SuperClassBuilderInterface {
   SuperClassBuilderInterface withS1(String s1);
   ...
   SuperClass build();
}

// Usage of the builders:
public SuperClass foo() {
    return new A.ABuilder()
        .withA1(...) // returns ABuilderInterface
        ...
        .withS1(...) // returns SuperClassBuilderInterface
        ...
        .build();
}

public abstract class SuperClass {
private final String s1;
...

protected SuperClass(SuperClassBuilder builder) {
    this.s1 = builder.s1;
    ...
}

protected static abstract class SuperClassBuilder implements SuperClassBuilderInterface {
    private String s1;
    ...

    @Override
    public SuperClassBuilder withS1(String s1) {
        this.s1 = s1;
        return this;
    }
    ...

    @Override
    public abstract SuperClass build();
}
}

现在你可以发现当我使用构建器时我必须注意首先调用与子类相关的 with... 方法的限制，然后链接父类(super class)的方法，这不是一个很大的成交了，但还是不确定做法是否好。另一方面，我可以将子类的 with... 方法一起添加到父类(super class)接口(interface)中，然后限制就消失了，但是我有一个混合了 with... 不同子类方法的接口(interface)。

您更喜欢/推荐哪一个？

Answer 1

修改父类(super class)的构建器以使用 F-bound(也称为 Curiously Recurring Template Pattern)。

public interface SuperClassBuilderInterface<SELF extends SuperClassBuilderInterface<SELF>> {
    SELF withS1(String s1);
    // etc.
    Superclass build();
}

那么你有:

class SuperClassBuilder<SELF extends SuperClassBuilder<SELF>> implements SuperClassBuilderInterface<SELF>

interface ABuilderInterface<SELF extends ABuilderInterface<SELF>> extends SuperClassBuilderInterface<SELF>

class ABuilder extends SuperClassBuilder<ABuilder> implements ABuilderInterface<ABuilder>

请注意，SuperClassBuilder 的实现必须包含 return (SELF)this; 形式的未经检查的转换。类型系统在理论上足够强大，不需要它，但生成的编码可能会非常丑陋(请参阅 this )并且它可能不值得。

编辑:这就是@shmosel 的意思