使用两个不同的泛型参数调用泛型函数仍然可以编译

Question

下面的代码怎么可能编译？据我所见，count 函数是用两种不同的类型调用的，但编译器并没有抱怨，而是愉快地编译了这段代码。

public class Test {
        public static <T> int count(T[] x,T y){
                int count = 0;
                for(int i=0; i < x.length; i++){
                        if(x[i] == y) count ++;
                }
                return count;  
        }
        public static void main(String[] args) {
                Integer [] data = {1,2,3,1,4};
                String value = "1";
                int r =count(data,value);
                System.out.println( r + " - " + value);
        }
}

Answer 1

通过一次传递两个对象，您对T 施加了太多约束。这“强制”编译器推断Object。幸运的是，有一个简单的解决方法——只传递一个对象。以下将产生预期的错误。

public static void main(String[] args) {
    Integer[] data = { 1, 2, 3, 4 };
    String value = "1";
    int r = count(value).in(data);
    System.out.println(r + " - " + value);
}

public static <T> Counter<T> count(T obj) {
    return new Counter<T>(obj);
}

public static class Counter<T> {
    private final T obj;

    Counter(T obj) {
        this.obj = obj;
    }

    public int in(T[] array) {
        return in(Arrays.asList(array));
    }

    public int in(Iterable<? extends T> iterable) {
        int count = 0;
        for (T element : iterable) {
            if (element == obj) {
                ++count;
            }
        }
        return count;
    }
}

Answer 2

如果您将呼叫更改为：

int r = Test.<Integer>count(data, value);

你会看到编译器抱怨。

Answer 3

在这种情况下，T 是无用的。您可以将签名更改为public static int count(Object[] x, Object y)，而不会对编译器允许它接受的参数产生任何影响。 （您可以看到Arrays.fill() 的签名将其用作签名。）

如果我们考虑更简单的情况，即您只有T 类型的参数，您可以看到，因为T 的任何实例也是其超类的实例，T 总是可以推断为是它的上限，它仍然会接受与以前相同的参数类型。因此我们可以去掉T，而使用它的上限（在本例中为Object）。

Java 中的数组工作方式相同：数组是协变的，这意味着如果S 是T 的子类，S[] 是T[] 的子类。因此，与上述相同的参数适用——如果您只有T 和T[] 类型的参数，T 可以替换为其上限。

（请注意，这不适用于非协变或逆变的泛型类型：List<S> 不是List<T> 的子类型。）

Answer 4

类型并没有太大的不同——它们都是 java.lang.Object 的子类。所以编译器在这种情况下假设 T 是 Object。

Answer 5

T 被强制向上转换为 Object。 Integer[] 可以向上转换为Object[]，String 可以向上转换为Object，并进行类型检查。