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();
  }
}

此代码在新的Implementer< String>中断,但是如果我使用new Builder< String,String>而不是新的Builder<>.

为什么Java不能推断Builder的类型是Builder< String,String>如果在新的实施者< String>中指定了R和S的类型？

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

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