Java 中的泛型类型推断限制

Question

我在使用 Java 泛型类型推断的项目中遇到以下问题。这是一个类似于我原来的代码示例：

public class BuildableObject<R, S> {
  public static class OneParameter<R> { }
  public static class TwoParameters<R, S> { }
  interface TwoParamInterface<R, S> { }
  public static class Implementer<T> implements TwoParamInterface<T, T> {}

  private final OneParameter<R> first;
  private final OneParameter<S> second;
  private final TwoParameters<R, S> third;
  private final TwoParamInterface<R, S> fourth;

  private BuildableObject(OneParameter<R> first, OneParameter<S> second, TwoParameters<R, S> third, TwoParamInterface<R, S> fourth) {
    this.first = first;
    this.second = second;
    this.third = third;
    this.fourth = fourth;
  }

  public static class Builder<R, S> {
    private OneParameter<R> first = null;
    private OneParameter<S> second = null;
    private TwoParameters<R, S> third = null;
    private TwoParamInterface<R, S> fourth = null;

    public Builder() {}

    public Builder<R, S> first(OneParameter<R> first) {
      this.first = first; return this;
    }

    public Builder<R, S> second(OneParameter<S> second) {
      this.second = second; return this;
    }

    public Builder<R, S> third(TwoParameters<R, S> third) {
      this.third = third; return this;
    }

    public Builder<R, S> fourth(TwoParamInterface<R, S> fourth) {
      this.fourth = fourth; return this;
    }

    public BuildableObject<R, S> build() {
      return new BuildableObject<>(first, second, third, fourth);
    }
  }

  public static void main(String... args) {
    new Builder<>()
        .first(new OneParameter<>())
        .second(new OneParameter<>())
        .third(new TwoParameters<>())
        .fourth(new Implementer<String>())
        .build();
  }
}

此代码在new Implementer<String> 处中断，但如果我使用new Builder<String, String> 而不是new Builder<> 则有效。

如果new Implementer<String>中指定了R和S的类型，为什么Java不能推断出Builder的类型是Builder<String, String>？

Java 泛型类型推断的限制是什么？它是否只解析构造函数或静态方法中提供的类型？我还没有找到任何关于此的文档。

这是否意味着如果我们不能使用类型推断，这个类可能不是类型安全的？

Answer 1

在https://docs.oracle.com/javase/specs/jls/se9/html/jls-18.html 中有详细记录。但问题是它的文档详细：除非您阅读有关此主题的论文，否则您不太可能熟悉很多行话。

对于这种情况，您只需要了解对于类型推断，您在new Builder<>() 之后调用什么方法并不重要；仅使用构造函数本身的参数（以及目标类型，例如Builder<String, String> b = new Builder<>();，但在这种情况下您没有）。

它是否只解析构造函数或静态方法中提供的类型？

没有。

这是否意味着如果我们不能使用类型推断，这个类可能不是类型安全的？

它们完全不相关。

Answer 2

当代码过于复杂时，泛型类型推断可能会失败，但通常您可以显式指定类型，这样就不需要推断。链式方法调用有时会导致这种情况。这只是意味着您失去了不必自己指定类型的便利。

泛型类型检查 是一个单独的概念。通常，检查器不会看到推断类型（<> 推断为<String, String>）和显式类型（代码中编写的<String, String>）之间的区别，无论哪种方式，它都会检查是否只使用了字符串目的。只要编译器不抱怨，你的类就应该是类型安全的。