Понимание верхней и нижней границ? в Java Generics

в первую очередь T или E или K или что-то не фиксированные имена. Это просто переменные типа, и вы сами решаете, как их назвать. T, E, K - это просто примеры, но вы можете назвать это Foo или что-то еще.

сейчас на ваш первый вопрос: после подстановки ? представляет тип "any and unknown", неуказанный, нет смысла объявлять класс generic над неуказанным типом. Полезно иметь подстановочный знак в параметров методов или переменных, когда вы не заботитесь о типе.

Теперь относительно вашего второго вопроса: нижняя граница дает еще большую гибкость вашим общим методам. оба!--8--> и super, напротив

• ? extends T: неизвестный тип, который является подтипом T
• ? super T: неизвестный тип, который является супер типа T

последнее может быть полезно, когда вы хотите принять тип это совместимо с T (так что T-это тот тип). Практический пример можно найти здесь.

начнем с самого начала.

строго говоря любой допустимый идентификатор java может использоваться как параметр универсального типа - это просто специальный тип переменной:

public static final class MyGenericClass<MyGenericType> {

}

является совершенно действительным Java.

Далее, вы можете использовать ? везде, где вы можете сделать заявление. Вы можете использовать подстановочный знак при объявлении переменных, но не при создать них:

public static final class MyGenericClass {
    private final Collection<? extends String> myThings;

    public MyGenericClass(Collection<? extends String> myThings) {
        this.myThings = myThings;
    }  

    public void doStuff(final Collection<? extends String> myThings) {

    }
}

снова все действительно, Вы не может этого:

final Collection<? extends String> myThings = new ArrayList<? extends String>();

когда дело доходит до extends vs super это называется co-дисперсия против contra-дисперсии. Он определяет, в каком направлении по иерархии классов типов могут путешествовать:

final Collection<? extends Runnable> example1 = new ArrayList<Runnable>();
final Collection<? extends Runnable> example2 = new ArrayList<TimerTask>();
final Collection<? super Runnable> example3 = new ArrayList<Runnable>();
final Collection<? super Runnable> example4 = new ArrayList<Object>();

первые два примера демонстрируют extends - плотно связаны, можно предположить, с Collection и Runnable как пользователь может пройти Collection что есть Runnable в его иерархии наследования.

вторые два примера демонстрируют super - плотно связаны, можно предположить, с Collection и Object как мы разрешаем все, что есть на иерархия наследования Runnable.

Хммм ваше заявление на super ( printAll(MyList<? super MyClass>) ) не понятно. Что это значит, если предположить, что Myclass расширяется Object вы можете printAll(MyList<MyClass>) и printAll(MyList<Object>) но ничего больше.... это означает, что общий тип MyList должен быть суперклассом (а не подклассом) MyClass. Это отличается от того, что ты сказал.

для первого вопроса: Вы не можете определить метод с ? в качестве параметра тип. Следующее не будет компилироваться:

void <?> foo() {}

? используется для привязки к другим дженерикам без указания параметра type. Вы можете написать для методов:

void foo(List<?> e) {}

и вы также можете писать на классы:

public class Bar<E extends List<?>> { }

использовать super:

public void printAll(MyList<? super MyClass>){
    // code code code
}

это не будет, как вы говорите, печатать список " если у него есть объекты Класса MyClass". Он может иметь объекты любого класса, который является подклассом класса, который является родителем MyClass. Компилятор не знает во время компиляции, какие объекты будут в списке в любом случае.

чтобы обойти это, рассмотрим простой пример с Number иерархия классов. Float и Integer дети Number. Вы можете написать свой метод так:

public void printAll(List<? super Float>){
    // code code code
}

тогда вы можете вызвать этот метод с помощью List<Number>:

List<Number> numbers = new ArrayList<>();
numbers.add(1); // actually only add an Integer
printAll(numbers); // compiles.

это возможно, было бы не очень полезно в этом случае. Где было бы полезно, например, когда вы хотите добавить Float в коллекцию, не желая, чтобы это был только список, например:

public void addFloat(List<? super Float> list){
    list.add(2.5);
}

? также может использоваться как метод return type

List<? extends Number> xxx() {
    ...
}

или как поле или переменную типа

List<? extends Number> xxx = ...
List<? super Nember> xxx = ...