Общий метод с параметрами по сравнению с неуниверсальным методом с подстановочными знаками

Ну, судя по спецификации, ни один из вызовов не является законным. Но почему первый тип проверяет, а второй нет?

Разница заключается в том, как методы проверяются на применимость (см. §15.12.2 и §15.12.2.2, в частности).

• Для применения простого неуниверсального g аргумент Class<ArrayList> должен быть подтипом Class<? extends Iterable<?>>. Это означает, что ? extends Iterable<?> необходимо содержать ArrayList, записанное ArrayList <= ? extends Iterable<?>. Правила 4 и 1 может применяться транзитивно, поэтому ArrayList должен быть подтипом Iterable<?>.

  Переходим по §4.10.2 любая параметризация C<...> является (прямым) подтипом необработанного типа C. Таким образом, ArrayList<?> является подтипом ArrayList, а не наоборот. Переходно, ArrayList не является подтипом Iterable<?>.

  Таким образом, g не применяется.

• f является общим, для простоты предположим, что аргумент типа ArrayList указан явно. Чтобы проверить применимость f, Class<ArrayList> должен быть подтипом Class<T> [T=ArrayList] = Class<ArrayList>. Поскольку подтипирование является рефлексивным, это верно.

  Также для применения f аргумент типа должен быть в его пределах. Это не потому, что, как мы показали выше, ArrayList не является подтипом Iterable<?>.

Так почему же он все равно компилируется?

Это ошибка. После отчета об ошибке и последующее исправление компилятор JDT явно исключает первый случай (включение аргумента типа). Второй случай по-прежнему счастливо игнорируется, потому что JDT считает ArrayList подтипом Iterable<?> (TypeBinding.isCompatibleWith(TypeBinding)).

Я не знаю, почему javac ведет себя так же, но я предполагаю, что по тем же причинам. Вы заметите, что javac также не выдает непроверенное предупреждение при назначении необработанного ArrayList для Iterable<?>.

Если параметр типа был типом с подстановочными знаками, проблема не возникает:

Class<ArrayList<?>> foo = null;
f(foo);
g(foo);

Я думаю, что это почти наверняка странный случай, возникающий из-за того, что тип литерала класса Class<ArrayList>, поэтому параметр типа в этом случае (ArrayList) является необработанным типом, а отношение подтипа между необработанным ArrayList и подстановочным знаком- параметризованный ArrayList<?> сложен.

Я не читал внимательно спецификацию языка, поэтому я не совсем уверен, почему подтипирование работает в случае явного параметра типа, но не в случае подстановочного знака. Это также вполне может быть ошибкой.

Угадай: что представляет собой первое ? (ArrayList) не «реализует» ArrayList<E> (в силу двойного вложенного подстановочного знака). Я знаю, это звучит смешно, но....

Рассмотрим (для исходного списка):

 void g(Class<? extends Iterable<Object> x) {} // Fail
 void g(Class<? extends Iterable<?> x) {}  // Fail
 void g(Class<? extends Iterable x) {}  // OK

И

// Compiles
public class Test{
    <T extends Iterable<?>> void f(ArrayList<T> x) {}
    void g(ArrayList<? extends Iterable<?>> x) {}

    void d(){
        ArrayList<ArrayList<Integer>> d = new ArrayList<ArrayList<Integer>>();
        f(d);
        g(d);
    }
}

Этот

// Does not compile on g(d)
public class Test{
    <T extends Iterable<?>> void f(ArrayList<T> x) {}
    void g(ArrayList<? extends Iterable<?>> x) {}

    void d(){
        ArrayList<ArrayList> d = new ArrayList<ArrayList>();
        f(d);
        g(d);
    }
}

Это не совсем то же самое:

<T extends Iterable<?>> void f(Class<T> x) {}
void g(Class<? extends Iterable<?>> x) {}

Разница в том, что g принимает "класс неизвестного, который реализует Iterable of unknown", но ArrayList<T> ограничен реализацией Iterable<T>, а не Iterable<?>, поэтому он не совпадает.

Чтобы было понятнее, g примет Foo implements Iterable<?>, но не AraryList<T> implements Iterable<T>.