构建器模式和继承

Question

public class Rabbit
{
    public String sex;
    public String name;

    public Rabbit(Builder builder)
    {
        sex = builder.sex;
        name = builder.name;
    }

    public static class Builder
    {
        protected String sex;
        protected String name;

        public Builder() { }

        public Builder sex(String sex)
        {
            this.sex = sex;
            return this;
        }

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

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

public class Lop extends Rabbit
{
    public float earLength;
    public String furColour;

    public Lop(LopBuilder builder)
    {
        super(builder);
        this.earLength = builder.earLength;
        this.furColour = builder.furColour;
    }

    public static class LopBuilder extends Rabbit.Builder
    {
        protected float earLength;
        protected String furColour;

        public LopBuilder() { }

        public Builder earLength(float length)
        {
            this.earLength = length;
            return this;
        }

        public Builder furColour(String colour)
        {
            this.furColour = colour;
            return this;
        }

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

Lop lop = new Lop.LopBuilder().furColour("Gray").name("Rabbit").earLength(4.6f);

由于无法解析最后一个链接调用，Builder未定义EarLength方法，因此此调用将不会编译。所以这种方式要求所有调用都以特定的顺序链接起来，这是非常不切实际的，特别是对于一个深度层次结构树。

现在，在我寻找答案的过程中，我遇到了一个Java Builder类的子类，它建议使用奇怪的递归泛型模式。但是，由于我的层次结构不包含一个抽象类，所以这个解决方案对我不起作用。但是这种方法依赖于抽象和多态性来发挥作用，这就是为什么我不相信我能使它适应我的需要。

我目前使用的一种方法是重写层次结构中超类builder的所有方法，并简单地执行以下操作：

public ConcreteBuilder someOverridenMethod(Object someParameter)
{
    super(someParameter);
    return this;
}

Answer 1

对于递归绑定，这当然是可能的，但是子类型构建器也需要是泛型的，并且您需要一些临时的抽象类。它有点麻烦，但仍然比非泛型版本容易。

/**
 * Extend this for Mammal subtype builders.
 */
abstract class GenericMammalBuilder<B extends GenericMammalBuilder<B>> {
    String sex;
    String name;

    B sex(String sex) {
        this.sex = sex;
        return self();
    }

    B name(String name) {
        this.name = name;
        return self();
    }

    abstract Mammal build();

    @SuppressWarnings("unchecked")
    final B self() {
        return (B) this;
    }
}

/**
 * Use this to actually build new Mammal instances.
 */
final class MammalBuilder extends GenericMammalBuilder<MammalBuilder> {
    @Override
    Mammal build() {
        return new Mammal(this);
    }
}

/**
 * Extend this for Rabbit subtype builders, e.g. LopBuilder.
 */
abstract class GenericRabbitBuilder<B extends GenericRabbitBuilder<B>>
        extends GenericMammalBuilder<B> {
    Color furColor;

    B furColor(Color furColor) {
        this.furColor = furColor;
        return self();
    }

    @Override
    abstract Rabbit build();
}

/**
 * Use this to actually build new Rabbit instances.
 */
final class RabbitBuilder extends GenericRabbitBuilder<RabbitBuilder> {
    @Override
    Rabbit build() {
        return new Rabbit(this);
    }
}

有一种方法可以避免“具体的”叶类，如果我们有：

class MammalBuilder<B extends MammalBuilder<B>> {
    ...
}
class RabbitBuilder<B extends RabbitBuilder<B>>
        extends MammalBuilder<B> {
    ...
}

然后需要创建带有菱形的新实例，并在引用类型中使用通配符：

static RabbitBuilder<?> builder() {
    return new RabbitBuilder<>();
}

@SuppressWarnings("unchecked")
final B self() {
    return (B) this;
}

有一种方法可以避免这种未经检查的强制转换,即使方法抽象：

abstract B self();

然后在leaf子类中重写它：

@Override
RabbitBuilder self() { return this; }

这样做的问题是，尽管它的类型安全度更高，但子类可以返回this以外的东西。基本上，无论哪种方法，子类都有可能做错一些事情，所以我看不出有什么理由更喜欢这两种方法中的一种而不是另一种。