具有递归类型参数的泛型类型以及抽象 self 方法如何允许方法链正常工作？

Question

我正在阅读《Effective Java Edition 3》。在第 2 章第 14 页中，作者讨论了构建器模式并呈现了以下代码：

public abstract class Pizza {
    public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
    final Set<Topping> toppings;
    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }
        abstract Pizza build();
        // Subclasses must override this method to return "this"
        protected abstract T self();
    }
    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone(); // See Item 50
    }
}

上述抽象类的实现：

public class NyPizza extends Pizza {
    public enum Size { SMALL, MEDIUM, LARGE }
    private final Size size;
    public static class Builder extends Pizza.Builder<Builder> {
        private final Size size;
        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }
        @Override public NyPizza build() {
            return new NyPizza(this);
        }
        @Override protected Builder self() { return this; }
    }
    private NyPizza(Builder builder) {
        super(builder);
        size = builder.size;
    }
}

我们可以使用这样的代码：

NyPizza pizza = new NyPizza.Builder(SMALL)
.addTopping(SAUSAGE).addTopping(ONION).build();

书中引用：

请注意，这Pizza.Builder是带有递归类型参数的泛型类型。这与抽象 self 方法一起允许方法链在子类中正常工作，而不需要强制转换。

现在我的问题是<T extends Builder<T>>为Pizza班级添加了哪些力量/价值以及它与 有何不同<T extends Builder>？如果你要用<T extends Builder<T>>简单的英语向一个五岁的孩子解释你会怎么解释？

我无法弄清楚超类中抽象 self 方法的用途？

---

因为评论区所以我添加了这部分

想象一下我已经像这样更改了上面的代码（这不会是仅用于说明目的的最佳示例）：

我将其更改NyPizza.Builder为通用的：

public class NyPizza extends Pizza {
    public enum Size { SMALL, MEDIUM, LARGE }
    private final Size size;
    public static class Builder<T> extends Pizza.Builder<Builder<T>> {
        private final Size size;
        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }
        @Override public NyPizza build() {
            return new NyPizza(this);
        }
        @Override protected Builder self() { return this; }
    }
    private NyPizza(Builder builder) {
        super(builder);
        size = builder.size;
    }
}

和Pizza这样的类：

public abstract class Pizza {
    public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
    final Set<Topping> toppings;
    abstract static class Builder<T extends Builder> {
        T obj;
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        public T builder(){
            return obj;
        }

        abstract Pizza build();
        // Subclasses must override this method to return "this"
        protected abstract T self();
    }
    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone(); // See Item 50
    }
}

并像这样使用上面的类：

NyPizza.Builder<String> test = new NyPizza.Builder<String>(SMALL).builder();

现在因为我没有以class Builder<T extends Builder>这种形式定义：类中的方法class Builder<T extends Builder<T>>不应该能够检测到 T 的类型，但它可以。这怎么可能？如何将其更改为需要铸造？builderPizzaNyPizza.Builder<String>

Answer 1

想象一下一个类：

class Foo<T extends Foo<T>> {
  T foo() { ... }
}

这意味着类foo()中的方法Foo<T>将返回也是 a 的实例Foo<T>，因为由 表示的所有可能类型T都是 的子类Foo<T>。

所以它可以返回自身 - 这就是为什么它对于与构建器的方法链接很有用；但实际上没有什么可以阻止它返回范围内的其他类。

如果您将其声明为：

class Foo<T extends Foo> {
  T foo() { ... }
}

那么这将生成T一个原始类型 Foo：foo()返回 a Foo，而不是 a Foo<T>。因为原始类型会擦除所有泛型，这意味着在像 之类的调用链中foo().foo()，您将在第一次调用后丢失类型信息。

在许多情况下，这可能并不显得非常重要。但几乎在所有情况下都应该避免原始类型。这里原始类型的后果是：

1. 如果您没有返回 self 类型（上面提到“实际上没有什么可以阻止它返回其他类”），那么您将在第一个方法调用后丢失该“其他类”。
2. 如果您在 中还有其他泛型方法Foo，例如List<String> myList() { ... }，原始类型Foo将返回 raw List，而不是List<String>（原始类型会删除所有泛型，而不仅仅是与省略的类型变量相关的泛型）。

这些显然并不适用于所有情况；但由于引入不必要的原始类型是一种不好的做法，因此请确保不要引入它们。