¿Cuál es la diferencia entre ‘E’, ‘T’ y ‘?’ para los genéricos de Java?

Buscamos en diferentes espacios para así traerte la solución para tu duda, si tienes alguna difcultad puedes dejar la inquietud y contestaremos con mucho gusto, porque estamos para servirte.

Solución:

Bueno, no hay diferencia entre los dos primeros, solo usan nombres diferentes para el parámetro de tipo (E o T).

La tercera no es una declaración válida – ? se utiliza como un comodín que se utiliza cuando se proporciona un tipo argumentop.ej List foo = ... significa que foo se refiere a una lista de algún tipo, pero no sabemos qué.

todo esto es genéricos, que es un tema bastante amplio. Es posible que desee obtener información al respecto a través de los siguientes recursos, aunque hay más disponibles, por supuesto:

• Tutorial de Java sobre genéricos
• guía de idioma a los genéricos
• Genéricos en el lenguaje de programación Java
• Preguntas frecuentes sobre Java Generics de Angelika Langer (masivas y completas; más como referencia, sin embargo)

Es más una convención que otra cosa.

• T está destinado a ser un tipo
• E está destinado a ser un elemento (List: una lista de Elementos)
• K es clave (en un Map)
• V es valor (como valor de retorno o valor asignado)

Son totalmente intercambiables (a pesar de los conflictos en la misma declaración).

Las respuestas anteriores explican los parámetros de tipo (T, E, etc.), pero no explican el comodín, “?”, o las diferencias entre ellos, así que lo abordaré.

Primero, para que quede claro: los parámetros comodín y tipo no son los mismos. Donde los parámetros de tipo definen un tipo de variable (p. ej., T) que representa el tipo para un ámbito, el comodín no lo hace: el comodín simplemente define un conjunto de tipos permitidos que puede usar para un tipo genérico. Sin ningún límite (extends o super), el comodín significa “usar cualquier tipo aquí”.

El comodín siempre viene entre paréntesis angulares y solo tiene significado en el contexto de un tipo genérico:

public void foo(List listOfAnyType) ...  // pass a List of any type

Nunca

public  ? bar(? someType) ...  // error. Must use type params here

o

public class MyGeneric ?       // error
    public ? getFoo()  ...    // error
    ...

Se vuelve más confuso donde se superponen. Por ejemplo:

List fooList;  // A list which will be of type T, when T is chosen.
                  // Requires T was defined above in this scope
List barList;  // A list of some type, decided elsewhere. You can do
                  // this anywhere, no T required.

Hay mucha superposición en lo que es posible con las definiciones de métodos. Los siguientes son, funcionalmente, idénticos:

public  void foo(List listOfT) ...
public void bar(List listOfSomething)  ...

Entonces, si hay superposición, ¿por qué usar uno u otro? A veces, honestamente es solo estilo: algunas personas dicen que si no necesitar un parámetro de tipo, debe usar un comodín solo para hacer que el código sea más simple/más legible. Una diferencia principal que expliqué anteriormente: los parámetros de tipo definen una variable de tipo (por ejemplo, T) que puede usar en cualquier otro lugar del alcance; el comodín no. De lo contrario, hay dos grandes diferencias entre los parámetros de tipo y el comodín:

Los parámetros de tipo pueden tener múltiples clases delimitadoras; el comodín no puede:

public class Foo  & Cloneable> ...

El comodín puede tener límites inferiores; los parámetros de tipo no pueden:

public void bar(List list) ...

En lo anterior el List define Integer como un límite inferior en el comodín, lo que significa que el tipo de Lista debe ser Entero o un supertipo de Entero. El límite de tipo genérico está más allá de lo que quiero cubrir en detalle. En resumen, le permite definir que tipos un tipo genérico puede ser. Esto hace posible tratar los genéricos polimórficamente. Por ejemplo, con:

public void foo(List numbers) ...

Puedes pasar un List, List, Listetc para numbers. Sin límite de tipo, esto no funcionará; así son los genéricos.

Finalmente, aquí hay una definición de método que usa el comodín para hacer algo que no creo que puedas hacer de otra manera:

public static  void adder(T elem, List numberSuper) 
    numberSuper.add(elem);

numberSuper puede ser una Lista de Números o cualquier supertipo de Número (p. ej., List