Imaginemos un escenario en el que queremos crear una lista en Java para almacenar Entero. Podríamos intentar escribir lo siguiente List list = new LinkedList(); list.add(new Integer(1)); Integer i = list.iterator().next(); Sorprendentemente, el compilador se quejará de la última línea. No sabe qué tipo de datos se devuelven. El compilador requerirá un casting explícito: Integer i = (Integer) list.iterator.next(); Ningún contrato podría garantizar que el tipo de retorno de la lista es un Integer. La lista definida podría contener cualquier objeto. Sólo sabemos que estamos recuperando una lista inspeccionando el contexto. Cuando se miran los tipos, sólo se puede garantizar que es un Object y por lo tanto se requiere un cast explícito para asegurar que el tipo es seguro. Este cast puede ser molesto – sabemos que el tipo de dato en esta lista es un Integer. El molde también está desordenando nuestro código. Puede causar errores en tiempo de ejecución relacionados con el tipo si un programador comete un error con la conversión explícita. Sería mucho más fácil si los programadores pudieran expresar su intención de utilizar tipos específicos y el compilador garantizara la corrección de dichos tipos. Esta es la idea central detrás de los genéricos. Modifiquemos la primera línea del fragmento de código anterior: List lista = new LinkedList<>(); Añadiendo el operador de diamante <> que contiene el tipo, restringimos la especialización de esta lista sólo al tipo Entero. En otras palabras, especificamos el tipo que contiene la lista. El compilador puede imponer el tipo en tiempo de compilación. En programas pequeños, esto puede parecer una adición trivial. Pero en programas más grandes, esto puede añadir una robustez significativa y hace que el programa sea más fácil de leer. Métodos genéricos ----------------- Escribimos métodos genéricos con una única declaración de método, y podemos llamarlos con argumentos de distintos tipos. El compilador garantizará la corrección del tipo que utilicemos. Estas son algunas propiedades de los métodos genéricos: * Los métodos genéricos tienen un parámetro de tipo (el operador rombo que encierra el tipo) antes del tipo de retorno de la declaración del método. * Los parámetros de tipo pueden estar acotados (explicaremos los límites más adelante en este artículo). * Los métodos genéricos pueden tener diferentes parámetros de tipo separados por comas en la firma del método. * El cuerpo de un método genérico es igual que el de un método normal. * He aquí un ejemplo de definición de un método genérico para convertir un array en una lista: public List arrayAList(T\[\] a) { return Arrays.stream(a).collect(Collectors.toList()); } El __ en la firma del método implica que el método tratará con el tipo genérico _T_. Esto es necesario incluso si el método devuelve void. Como se ha mencionado, el método puede tratar con más de un tipo genérico. En este caso, debemos añadir todos los tipos genéricos a la firma del método. Así es como modificaríamos el método anterior para tratar con el tipo T y el tipo G: public static List arrayAList(T\[\] a, Function mapperFunction) { return Arrays.stream(a) .map(mapperFunction) .collect(Collectors.toList()); } Estamos pasando una función que convierte un array con los elementos de tipo T a lista con elementos de tipo G. ### Extends en genéricos Recuerde que los parámetros de tipo pueden ser limitados. Limitado significa «restringido», y podemos restringir los tipos que acepta un método. Por ejemplo, podemos especificar que un método acepte un tipo y todas sus subclases (límite superior) o un tipo y todas sus superclases (límite inferior). Para declarar un tipo con límite superior, utilizamos la palabra clave extends después del tipo, seguida del límite superior que queremos utilizar: public List arrayAList(T\[\] a) { ... } Utilizamos la palabra clave extends para significar que el tipo T extiende el límite superior en el caso de una clase o implementa un límite superior en el caso de una interfaz. ### Multiples extensiones Un tipo también puede tener varios límites superiores: Si uno de los tipos que son extendidos por _T_ es una clase (por ejemplo, _Number_), tenemos que ponerlo primero en la lista de límites. De lo contrario, provocará un error de compilación. Uso de comodines con genéricos ------------------------------ Los comodines están representados por el signo de interrogación _?_ en Java, y los usamos para referirnos a un tipo desconocido. Los comodines son particularmente útiles con genéricos y pueden usarse como tipo de parámetro. Pero primero hay que considerar una nota importante. Sabemos que _Object_ es el supertipo de todas las clases de Java. Sin embargo, una colección de Objetos no es el supertipo de ninguna colección. Por ejemplo, List

Genéricos en JAVA