¿Entendiendo los límites superior e inferior? en Java Generics

En primer lugar T o E o K o lo que sea no son nombres fijos. Son solo variables de tipo, y usted decide el nombre para ellos. T, E, K son solo ejemplos, pero se podría llamar Foo o lo que sea.

Ahora vamos a tu primera pregunta: dado que el comodín ? representa el tipo "cualquiera y desconocido", el no especificado, no tiene ningún sentido declarar una clase genérica sobre un tipo no especificado. Es útil tener comodín en parámetros de métodos o en variables cuando no te importa el tipo.

Ahora con respecto a su segunda pregunta: el límite inferior da aún más flexibilidad a sus métodos genéricos. tanto extends como super son lo contrario:

• ? extends T: un tipo desconocido que es un subtipo de T
• ? super T: un tipo desconocido que es un supertipo de T

Este último puede ser útil cuando se quiere aceptar un tipo que es compatible con T (de modo que T es-a ese tipo). Un ejemplo práctico puede se encuentra aquí.

Comencemos desde el principio.

Estrictamente hablando cualquier identificador java válido se puede usar como un parámetro de tipo genérico , es solo un tipo especial de variable:

public static final class MyGenericClass<MyGenericType> {

}

Es Java perfectamente válido.

A continuación, puede usar ? en cualquier lugar donde pueda hacer una declaración. Puedes usar el comodín cuando declaras variables pero no cuando instancias:

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) {

    }
}

Es de nuevo todo válido, usted no puede hacer esto:

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

Cuando se trata de extends vs super esto se llama covarianza vs contra-varianza. Determina qué dirección a lo largo de la jerarquía de clases a los tipos suministrados se les permite viajar:

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>();

Los dos primeros ejemplos demuestran extends - el límite más ajustado que se puede asumir de Collection es Runnable ya que el usuario puede pasar un Collection de cualquier cosa que tenga Runnable en su jerarquía de herencia.

Los dos segundos ejemplos demuestran super - el límite más apretado que puede asumir desde el Collection es Object como permitimos cualquier cosa que es en la jerarquía de herencia de Runnable.

Hmmmm su declaración en super ( printAll(MyList<? super MyClass>) ) no está claro. Lo que significa, suponiendo que Myclass se extiende Object es que puedes printAll(MyList<MyClass>) y puedes printAll(MyList<Object>) pero nada más.... esto significa que el tipo genérico de myList tiene que ser una superclase (no una subclase) de MyClass. Esto es diferente a lo que dijiste.

En cuanto a la T, E, K, V, o N, bueno, estos son nombres sin sentido en sí mismos. Puedes usar lo que quieras. Sin embargo, la convención sugiere valores en mayúsculas de una sola letra, y T es a menudo usado para métodos genéricos, y E para clases....

Para la primera pregunta: tampoco se puede definir un método con ? como parámetro de tipo. Lo siguiente no compilará:

void <?> foo() {}

? se utiliza para enlazar a otros genéricos sin proporcionar el parámetro type. Puedes escribir para métodos:

void foo(List<?> e) {}

Y también puedes escribir para las clases:

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

Para el uso de super:

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

Esto no imprimirá como usted dice la lista "si tiene objetos de MyClass". Puede tener objetos de cualquier clase que sea un subclase de una clase que es un padre de MyClass. El compilador no sabe en tiempo de compilación cuáles son los objetos que estarán en la lista de todos modos.

Para entenderlo, considere un ejemplo simple con la jerarquía de clases Number. Float y Integer son hijos de Number. Puedes escribir tu método así:

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

Entonces puedes llamar a ese método con un List<Number>:

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

Esto es posible no sería super útil en ese caso. Donde sería útil para un ejemplo es cuando desea agregar Float a una colección sin querer que sea solo una Lista, como:

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

? también se puede utilizar como método return type

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

O como campo o tipo variable

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