Java Generics: множественное наследование в параметрах ограниченного типа ‹T extends A & I›

Это не делает то, что вы ожидаете. T extends A & I указывает, что вызывающий может указать любой тип, который расширяет A и I, и вы вернете его.

Что касается второго вопроса:

Рассмотрим этот случай:

 class B extends A implements I {}
 class C extends A implements I {}

Теперь следующее использует вывод типа:

<T extends A & I> T newThing() {
  return (T) new B();
}

Итак, вы можете назвать это:

C c = F.newThing(); //T would be C here

Вы видите, что T может быть любым, расширяющим A и I, вы не можете просто вернуть экземпляр B. В приведенном выше случае приведение может быть записано как (C)new B(). Это явно приведет к исключению, и поэтому компилятор выдаст предупреждение: Unchecked cast from B to T - если вы не подавляете эти предупреждения.

Я думаю, что один из способов объяснить это — заменить параметр типа фактическим типом.

Параметризованная подпись методов:

public static <T extends A & B> T newThing(){
   return ...;
}

<T extends A & B> — это то, что называется параметром типа. Компилятор ожидает, что это значение фактически заменяется фактическим типом (называемым аргументом типа), когда вы фактически его используете.

В случае вашего метода фактический тип определяется посредством вывода типа. То есть <T extends A & B> следует заменить реально существующим типом, который расширяет A и реализует B.

Итак, допустим, что классы C и D расширяют A и реализуют B, тогда, если бы ваша подпись была такой:

public static <T extends A & B> T newThing(T obj){
   return obj;
}

Затем, путем вывода типа, ваш метод будет оцениваться следующим образом:

public static C newThing(C obj){
   return obj;
}

если вы вызываете с помощью newThing(new C()).

А будет следующим

public static D newThing(D obj){
   return obj;
}

если вы вызываете с помощью newThing(new D()).

Это будет скомпилировано просто отлично!

Однако, поскольку вы на самом деле не предоставляете какой-либо тип для проверки вывода типа в объявлении вашего метода, компилятор никогда не сможет быть уверен, каков фактический тип (аргумент типа) вашего параметра типа <T extends A & B>.

Вы можете ожидать, что на самом деле это C, но могут существовать тысячи различных классов, удовлетворяющих этим критериям. Какой из них компилятор должен использовать в качестве фактического типа вашего аргумента типа?

Предположим, что C и D — это два класса, которые расширяют A и реализуют B. Какой из этих двух фактических типов должен использовать компилятор в качестве аргумента типа для вашего метода?

Вы могли бы даже объявить аргумент типа, для которого нет даже существующего типа, который вы могли бы использовать, например сказать что-то, что расширяет Serializable и Closable, Comparable и Appendable.

И, может быть, во всем мире нет класса, удовлетворяющего этому.

Таким образом, вы должны понимать, что параметр типа здесь просто требуется компилятору для проверки фактического типа, который вы используете, заполнитель для фактического типа; и этот фактический тип должен существовать в конце, и компилятор будет использовать его для замены появления T. Следовательно, фактический тип (аргумент типа) должен быть выведен из контекста.

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

Таким образом, вы можете реализовать свой метод, используя вывод типа следующим образом:

   public static <T extends A & B> T newThing(Class<T> t) throws Exception{
    return t.newInstance();
}

Таким образом, вы фактически сообщаете компилятору, какой фактический аргумент типа следует использовать.

Учтите, что при генерации байт-кода компилятор должен подставить T вместо реального типа. Невозможно написать такой метод на Java

public static A & B newThing(){ return ... }

Правильно?

Надеюсь, я объяснил себя! Это не просто объяснить.

Самое простое решение - создать абстрактный базовый класс, который расширяет и реализует любой класс и интерфейсы, которые вы хотите, и возвращает этот тип. Неважно, что вы ограничиваете возвращаемый тип расширением этого базового класса, поскольку вы уже ограничивали возвращаемый тип его суперклассом.

eg.

class C {}
interface I {}

abstract class BaseClass extends C implements I {}
// ^-- this line should never change. All it is telling us that we have created a
// class that combines the methods of C and I, and that concrete sub classes will
// implement the abstract methods of C and I    


class X extends BaseClass {}
class Y extends BaseClass {}

public class F {

    public static BaseClass newThing() {
        return new X();
    }


    public static void main(String[] args) {
        C c = F.newThing();
        I i = F.newThing();
    }
}