Question

我正在将一些代码重构为构建器模式，并在为子类的子构建器进行子类化时遇到问题。

当我有一个构建器子类，并且我尝试在父类中链接一个方法时，它将返回父构建器，因此我的实例不再能够访问子类方法。

public class App {

    public static void main(String[] args) {
        Parent p;
        p = new App().new ChildBuilder()
            .withName("Test")
            .withNickName("Test1")
            .build();// Doesn't Compile
        p = new App().new ChildBuilder()
            .withNickName("Test1")
            .withName("Test")
            .build();

    }

    class Parent {
        public Parent(ParentBuilder builder) {}
    }

    class Child extends Parent {
        public Child(ChildBuilder builder) { super(builder); }
    }

    class ParentBuilder {
        private String name;
        public ParentBuilder() {}

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

        public ParentBuilder withName(String name) { 
            this.name = name; 
            return this; 
        }
    }

    class ChildBuilder extends ParentBuilder {
        private String nickName;
        public ChildBuilder withNickName(String nickName) { 
            this.nickName = nickName; 
            return this; 
        }
    }
}

main方法中的第二行不会编译，因为withName("Test")在ParentBuilder类上并返回ParentBuilder。重新排序链以调用所有ChildBuilder方法首先解决问题，但对于使用我的api（包括我自己）的人来说，这听起来像是一种糟糕的体验。
如果我在孩子中添加覆盖，我可以通过协方差使其工作：

        @Override
        public ChildBuilder withName(String name) { 
            super.withName(name); 
            return this; 
        }

但这是很多样板代码，我宁愿不维护（每个父构建器都可以有一些子类，所以我需要在父类的每个方法的每个子类中重写这些方法）。

有没有办法在没有覆盖的情况下做我想做的事情？可以java＆＃34;推断＆＃34;孩子们的协变方法？

我也担心这个问题表明我正在错误地设计构建器。

Answer 1

不，没有推断的协方差，但它是由奇怪的重复模板模式（或CRTP，起源于C ++）模仿。

您可以通过添加使用CRTP的2（包私有）抽象类来解决此问题（即，参数类型是子类）。将构建器功能移动到这些类，然后创建2个扩展抽象构建器的空类。

我还将构造函数更改为不直接依赖于构建器，而是根据实际参数，因为这通常是它的完成方式，并且它使得实现在这里更清洁：

public static void main(String[] args) {
    // Both examples now compile
    Parent p;
    p = new App().new ChildBuilder()
        .withName("Test")
        .withNickName("Test1")
        .build();
    p = new App().new ChildBuilder()
        .withNickName("Test1")
        .withName("Test")
        .build();

}

class Parent {
    public Parent(String name) {}
}

class Child extends Parent {
    public Child(String name, String nickName) { super(name); }
}

abstract class AbstractParentBuilder<T extends AbstractParentBuilder<T>> {
    protected String name;
    protected AbstractParentBuilder() {}

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

    @SuppressWarnings("unchecked")
    public T withName(String name) {
        this.name = name; 
        return (T) this; 
    }
}

class ParentBuilder extends AbstractParentBuilder<ParentBuilder> {}

abstract class AbstractChildBuilder<T extends AbstractChildBuilder<T>> extends AbstractParentBuilder<T> {
    protected String nickName;
    protected AbstractChildBuilder() {}        

    public Child build() { return new Child(name, nickName); }

    @SuppressWarnings("unchecked")
    public T withNickName(String nickName) { 
        this.nickName = nickName; 
        return (T) this; 
    }
}

class ChildBuilder extends AbstractChildBuilder<ChildBuilder> {}

是否存在推断的协方差

1 个答案: