CJ02 – Técnicas avanzadas en java 1.4 y 5.0 Parte 2 - Novedades en java 5.0

Objetivos generales Generics Definición y uso Subtipos Wildcards Type erasure

GENERICS

Generics “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 En versiones de Java 5, cuando se introducían objetos en una colección estos se guardaban como objetos de tipo Object, aprovechando el polimorfismo Esto obligaba a hacer un casting al tipo original al obtener los elementos de la colección: import java.util.ArrayList;  import java.util.List;     public class Ejemplo {     public static void main(String[] args) {       List lista = new ArrayList();       lista.add("Hola mundo");         String cadena = (String) lista.get(0); //casting.       System.out.println(cadena);     }   }  En versiones posteriores, se introdujo el concepto de Generics, para evitar esta situación. De esta forma, Generics permite crear código seguro, ya que ya sabemos de que tipo son los objetos que colocamos en una lista.

Generics 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 Ver problemas: GenericsLab.java y GenericsLab2.java Como vemos, si se guardan objetos de distintos tipos en una misma lista, para acceder a ellos, debemos preguntarle a cada uno que tipo tiene, dado que si hiciéramos el casting a un objeto con el tipo erróneo, obtendríamos un error.

Generics – Definición y uso 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>(); En este ejemplo, se muestra cómo definir una lista tipada. LinkedList, sólo guardará objetos de tipo Integer. Ejemplo: import java.util.ArrayList;   import java.util.List;      public class Ejemplo {     public static void main(String[] args) {       List<String> lista = new ArrayList<String>();       lista.add("Hola mundo");       String cadena = lista.get(0);       System.out.println(cadena);     }   }   En este ejemplo, manejamos una lista de Strings.

Generics – Definición y uso (2) // Definición Interface List interface List<E>{ void add(E x); Iterator<E> iterator(); } // Uso con tipo concreto String List<String> ls = new ArrayList<String>(10); En este ejemplo, vemos la definición de la interfaz List, para el manejo de listas. Recordar, que una interfaz define un contrato, es decir un conjunto de funcionalidades.

Generics – Definición y uso (3) 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 En la versión 5 de Java, todas las colecciones fueron modificadas para que soporten Generics. Por lo tanto, ahora podemos usar vectores y listas con un tipo determinado.

Generics – Definición y uso (4) 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”); En este ejemplo, vemos la estructura HashMap. Un hashmap, es una doble lista, la cual posee una clave y un valor. Un claro ejemplo para este tipo es una agenda telefónica, en la cual la clave son las letras del abecedario y los valores, los teléfonos y nombres de las personas cuyo nombre comienza con la letra de la clave. Para el ejemplo, la clave es de tipo String y el valor asociado es de tipo Mammal.

Generics – Generics y subtipos 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 fallar ao.add(new Object()); Integer i = ai.get(0); // runtime ClassCastException En estos ejemplos, vemos que al querer asignar ArrayList<Object> ao = ai; , podemos obtener un error, dado que los tipos de ambos arraylist son distintos. En cuanto al segundo ejemplo, donde: Integer i = ai.get(0); , en este caso, se quiere obtener un objeto de Integer de una lista a la cual se le agregó un objeto de tipo Object. Recordar que al ser un Object, estamos en la raíz de la jerarquía de tipos, por lo que no podemos decir directamente que dicho objeto es un Integer. Por esta razón, obtenemos el error: ClassCastException, dado que el casting a Integer no es correcto.

Generics – Generics y subtipos (2) 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 En este ejemplo, se definieron varias estructuras con sus correspondientes tipos.

Generics – Generics y subtipos (3) 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. En el ejemplo anterior, al agregar tipos derivados de la clase Number, no se obtienen problemas, dado que se respeta el tipo de la estructura. Sin embargo, no sucede lo mismo cuando intentamos agregar un objeto de tipo String. En ese caso, obtenemos un error en tiempo de compilación, ya que el compilador sabe que el tipo de la lista es Number, mientras que el objeto que se intenta agregar es String.

Generics – Wildcard (Comodines) 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()); } public static void main(String[] args) { ArrayList<String> array = new ArrayList<String>(); printCollection(array); // error de compilación } En este ejemplo, vemos que el método printCollection, recibe una Collection de tipo Object.

Generics – Wildcard (2) 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()); } Ver ejemplo: Wildcard.java Como vemos, al no especificar el tipo de la collection, no obtenemos un error de tipos, dado que este es desconocido.

Generics – Type Erasure 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(); En versiones anteriores a Java , no se manejaban los Generics, por lo que al definir un ArrayList, una Collection, un Vector, no se especifica el tipo de la misma. Esta implementación, puede ser utilizada en Java 5.0.

Generics – Type Erasure 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? Dado que toda la información generada con Generics es eliminada luego de la compilación, al ejecutar dicho código, obtenemos el valor true. Ambas listas son de tipo ArrayList.

Generics – Definiendo Generics 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.

Generics – Definiendo Generics Ejemplo: public class Pair<F, S> { F first; S second; public Pair(F f, S s) { first = f; second = s; } F getFirst(){ return first; En este ejemplo, definimos la clase Pair, con dos tipos: F y S. Como vemos, los nombres de los tipos están en mayúsculas, definimos más de un solo tipo y los utilizamos como si fueran otro tipo mas.

Generics – Definiendo Generics 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 Como vemos, los tipos definidos, pueden heredar de distintas clases pero no impementar interfaces. Para el caso: Class Numero<E extends Number>{} Vemos que la clase Numero, tiene un tipo E, el cual hereda de la clase Number, por lo tanto, al utilizar dicha clase, el tipo utilizado debera si o si heredar de Number. Class Numero <Long>{} //ok Class Numero <String>{} // error, ya que String no es válido.

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

Bibliografía The Java Tutorial Trail de Generic http://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