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

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 。 可以将Integer[]上传到Object[] ，并将String上传到Object ，并进行类型检查。

Answer 2

在这种情况下， 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 3

如果您将通话更改为：

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

你会看到编译器抱怨。

Answer 4

通过一次传递两个对象，你对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 5

类型没有那么不同 - 都是java.lang.Object的子类。 因此编译器假设在这种情况下T是Object。