Generics Definición y uso Subtipos Wildcards Type erasure

“Generics” permite abstraerse sobre los tipos Clases, interfaces y métodos pueden ser parametrizadas como Tipos.

Permite crear código seguro. ₋ Si el código compila sin errores o warnings

entonces no lanzará excepciones de ClassCastException en tiempo de ejecución.

Permite crear código más simple y legible

Problemas:₋ El compilador no puede chequear tipos en

tiempo de compilación.₋ Imposibilidad de definir listas de

determinados tipos

Ventajas:₋ Decirle al compilador el tipo que maneja la

colección₋ El compilador realiza el casting

Definición:LinkedList<E>₋ Parametro E representa el tipo de elementos

guardados en la lista.

Uso₋ Reemplazar el parametro <E> por el tipo

concreto, ejemplo: <Integer>₋ Solo guardará elementos Integer en la lista

LinkedList<Integer> li = new LinkedList<Integer>();

// Definición Interface Listinterface List<E>{

void add(E x);Iterator<E> iterator();

}

// Uso con tipo concreto StringList<String> ls = new ArrayList<String>(10);

En J2SE 5.0, todas las colecciones se reescribieron para ser clases Generics

Vector<String> vs = new Vector<String>();vs.add(new Integer(5)); // Compile error!vs.add(new String(“hello”));String s = vs.get(0); // No casting needed

Clases generics pueden tener múltiples parámetros.

HashMap<String, Mammal> map =new HashMap<String, Mammal>();map.put(“wombat”, new Mammal("wombat"));Mammal w = map.get(“wombat”);

Casting de tipos:₋ Object o = new String(“pepe”); //Correcto

El siguiente código es incorrecto. Puede existir un error en tiempo de ejecución al generalizar.

ArrayList<Integer> ai = new ArrayList<Integer>();

ArrayList<Object> ao = ai; // puede fallarao.add(new Object());Integer i = ai.get(0); // runtime

ClassCastException

El siguiente código funciona:

ArrayList<Integer> ai = new ArrayList<Integer>();

List<Integer> li = new ArrayList<Integer>();Collection<Integer> ci = new

ArrayList<Integer>();Collection<String> cs = new Vector<String>(4);

Si existen relaciones de herencia entre las clases generics

El siguiente código funciona:

ArrayList<Number> an = new ArrayList<Number>();

an.add(new Integer(5));an.add(new Long(1000L));an.add(new String(“hello”)); // compile error

Entradas en una colección mantienen relación de herencia.

Problema. Escribir el código que imprima el contenido de cualquier colección.

Primera implementación:

static void printCollection(Collection<Object> cols){

Iterator iter = cols.iterator(); while (iter.hasNext()) { System.out.println(iter.next()); }}

Solución – usar un comodin como tipo de argumento <?>

Collection<?> significa: colección de tipo desconocido

static void printCollection(Collection<?> cols){ Iterator iter = cols.iterator(); while (iter.hasNext()) { System.out.println(iter.next()); } }

Puedo instanciar una clase definida con generics sin utilizar ningún parámetro.

Código escrito en versiones previas a J2SE 5.0 sigue compilando sobre la JVM J2SE 5.0.

₋ ArrayList<String> a = new ArrayList<String>();₋ ArrayList a = new ArrayList();

Toda la información generada con Generics es eliminada luego de la compilación.

La información de generics no existe en tiempo de ejecución

ArrayList<Integer> ai = new ArrayList<Integer>();ArrayList<String> as = new ArrayList<String>();System.out.println(ai.getClass() == as.getClass());

¿Que devuelve?

Agregar en la definición de la clase los tipos de parametros

₋ Puedo definir mas de un tipo₋ Class XXX<A,B,C>

Por estandarización, utilizar letras mayusculas para definir los tipos.

Utilizar dentro de la clase los tipos de parametros definidos en el encabezado como un tipo más.

Ejemplo:

public class Pair<F, S> {F first; S second;public Pair(F f, S s) {

first = f; second = s;}F getFirst(){

return first;}

}

Se pueden definir especificaciones sobre tipos generics al utilizar comodines <?>

₋ Class Numero<E extends Number>{}₋ Void metodo(Numero<? extends Integer>

num){}

No se puede indicar que un tipo generics implementa una interface.

₋ Class Numero<E implements Interface>{} //error de compilación

₋ Void metodo(Numero<? implements Interface > num){} //error de compilación

Generics: qué son? Cómo se usan? Definición y uso Subtipos: como se aplica? Wildcards: ejemplos. Type erasure: ejemplos.

The Java TutorialTrail de Generichttp://java.sun.com/docs/books/tutorial/extra/generics/index.html

Documentación online Java SE 5 http://java.sun.com/j2se/1.5.0/docs/

Especificación de la API Java SE 5 http://java.sun.com/j2ee/1.5.0/docs/api