Java泛型。为什么要编译？

Question

abstract class Type<K extends Number> {
    abstract <K> void use1(Type<K> k);           // Compiler error (Type parameter K is not within its bounds)
    abstract <K> void use2(Type<? extends K> k); // fine
    abstract <K> void use3(Type<? super K> k);   // fine
}

方法泛型类型 K 隐藏了类泛型类型 K，所以 <K>不匹配 <K extends Number>在use1() .编译器对新泛型类型一无所知<K>在use2()和 use3()但编译仍然是合法的。为什么 <? extends K> (或 <? super K> )匹配 <K extends Number> ？

Answer 1

你的问题是有两个K类型。如果重命名可能会更清楚。

abstract class Type<N extends Number> {
    abstract <K extends Number> void use1(Type<K> k); // fine
    abstract <K> void use2(Type<? extends K> k); // fine
    abstract <K> void use3(Type<? super K> k);   // fine
}

在某些情况下，您必须提供编译器可以推断出的重复信息，而在其他情况下则不需要。在 Java 7 中，它添加了一个 <>。菱形表示法告诉编译器推断它以前没有推断的类型。

---

为了说明我的意思。以下是创建泛型类实例的不同方法。有些需要类型给出两次，有些只需要一次。编译器可以推断类型。

一般来说，Java 不会在大多数其他语言中推断类型。

class Type<N extends Number> {
    private final Class<N> nClass;

    Type(Class<N> nClass) {
        this.nClass = nClass;
    }

    static <N extends Number> Type<N> create(Class<N> nClass) {
        return new Type<N>(nClass);
    }

    static void main(String... args) {
      // N type is required.
      Type<Integer> t1 = new Type<Integer>(Integer.class);

      // N type inferred in Java 7.
      Type<Integer> t2 = new Type<>(Integer.class); 

      // type is optional
      Type<Integer> t3 = Type.<Integer>create(Integer.class); 

      // type is inferred
      Type<Integer> t4 = create(Integer.class);
    }