JAVA 1.5 Fernando Almeida Octubre 2004

Introducción Java Specification Request (JSR) 14Java Specification Request (JSR) 14 propone introducir tipos y métodos genéricos en el lenguaje de programación JAVA. Desde los comienzos de JAVA, los desarrolladores han intentado agregarle los tipos genéricos al lenguaje. Los tipos genéricos han sido usados por años en otros lenguajes de programación y ahora serán parte de Java 1.5.

Mejoras generales de JAVA 1.5 Incorporación de Tipos Genéricos (Generics). Autoencapsulamiento y Desencapsulamiento. Importación estática. Sentencia FOR mejorada.

Tipos Genéricos Probablemente sea más conocido por parameterized types (tipos-parametrizados) ó templates (plantillas). Los dos mayores beneficios de los tipos genéricos in JAVA son: 1- Reducir en número de conversiones (casts) en el programa, así reduciendo el número de posibles errores. 2- Mejorar la claridad del código.

Ejemplo 1 : Reducción de Casts class DangerousCast { public static void main(String[] args) { Stack stack = new Stack(); stack.push(new Integer(1)); stack.push("2"); stack.push(new Integer(3)); while(!stack.isEmpty()) { Integer integer = (Integer) stack.pop();.... } } }

Ejemplo1 : Reducción de Casts (Generics) class CompilerSavesTheDay { public static void main(String[] args) { Stack stack = Stack (); stack.push(new Integer(1)); stack.push("2"); //Error de compilación. stack.push(new Integer(3)); while(!stack.isEmpty()) { Integer integer = stack.pop();.... }

Mejorar la claridad del código // Instancia de la estructura de datos List list = new LinkedList(); list.add(new LinkedList()); // Agregando un valor ((List) list.get(0)).add("value"); // Obteniendo un valor String value = (String) ((List) list.get(0)).get(0);

Mejorar la claridad del código (Generics) // instancia de la estructura de datos List > list = new LinkedList >(); list.add(new LinkedList ()); // Agregando un valor list.get(0).add("value"); // Obteniendo un valor String value = list.get(0).get(0);

Ejemplo de colecciones con Generics // Declaración de Map que acepta Integers y Strings. Map meses = new HashMap (); months.put(1, "Enero"); months.put(2, "Febrero"); months.put(3, "Marzo");.... // retorna "Enero“ String month = meses.get(1); // Declaración de una Lista de Strings List dias = new ArrayList (); days.add("Domingo"); days.add("Lunes"); days.add("Martes");

Ejemplo de colecciones con Generics // Definición de un Comparator para ordenar descendentemente // Strings en una rutina de sort. Comparator comparator = new Comparator () { public int compare(String s1, String s2) { return -s1.compareTo(s2); } }; // Ordenar los días en orden descendente Collections.sort(dias, comparator); // retorna Martes String dia = dias.get(0);

Colección sin utilizar Generics (Advertencia del compilador) // El siguiente código funciona pero genera una // advertencia de compilación. List diasNoSeleccionados = new ArrayList(); diasNoSeleccionados.add("Domingo"); diasNoSeleccionados.add("Lunes"); diasNoSeleccionados.add("Martes"); String diaNoSeleccionado ; diaNoSeleccionado = (String) diasNoSeleccionados.get(0);

public class Par { private Object primero; private Object segundo; public Par(Object primero, Object segundo) { this.primero = primero; this.segundo = segundo; } public Object getPrimero() { return this.primero; } Clases Genéricas

public Object getSegundo() { return this.segundo; } public static void main(String[] args) { // Par de número - mes Par ene = new Par(new Integer(1), "Enero"); int numMes ; numMes= ((Integer)ene.getPrimero()).intValue(); String nombreMes = (String) ene.getSegundo(); }

Clases Genéricas (Generics) public class Par { private T1 primero; private T2 segundo; public Pair(T1 primero, T2 segundo) { this.primero = primero; this.segundo = segundo; } public T1 getPrimero() { return this.primero; }

Clases Gnéricas (Generics) public T2 getSegundo() { return this.segundo; } public static void main(String[] args) { // Par número – mes Par ene; ene = new Par (1, "Enero"); int numMes = ene.getPrimero(); String nombreMes = ene.getSegundo(); }

Implementar una extensión de java.util.ArrayList que solo acepte tipos Number. public class MyNumberList extends java.util.ArrayList { public double sum() {.... } public double average() {.... } }

Continuación MyNumberList Las siguientes declaraciones son legales: MyNumberList myNumberList = new MyNumberList (); MyNumberList myNumberList2 = new MyNumberList (); Pero las siguientes declaraciones no lo son: MyNumberList myStringList = new MyNumberList (); MyNumberList myBooleanList = new MyNumberList ();

Métodos Genericos Así como las Clases e interfaces pueden ser genéricas, los métodos también pueden recibir parámetros genéricos. Veamos un ejemplo para una rutina de ordenamiento que funcionaría para una Collection de Objetos Comparable. public static void mySortRoutine(Collection collection);

Autoboxing / Unboxing List intList = new ArrayList(); for (int i=0; i < 10; i++) { // Ahora debemos encapsular todo int como Integer intList.add(new Integer(i)); } int sum = 0; for (int i=0; i < intList.size(); i++) { // Precisamos castear a Integer y utilizar intValue() // para obtener un int. int num = ((Integer) intList.get(i)).intValue(); sum += num; }

Autoboxing / Unboxing (Generics) List intList = new ArrayList (); for (int i=0; i < 10; i++) { // No es necesario encapsular los ints intList.add(i); } int sum = 0; for (int i=0; i < intList.size(); i++) { // Se puede obtener el int directamente sum += intList.get(i); }

Importación estática // "Constant Interface" antipattern – No usar! public interface Physics { public static final double AVOGADROS_NUMBER = e23; public static final double BOLTZMANN_CONSTANT = e-23; public static final double ELECTRON_MASS = e -31; } public class Guacamole implements Physics { public static void main(String[] args) { double moles =...; double molecules = AVOGADROS_NUMBER * moles;... }

Importación estática La idea de implementar una interfaz es de proveer un comportamiento y no de proveer constantes. La importación estática es una alternativa bastante clara, es análoga a la importación de paquete, excepto que esta solo importa los miembros estáticos. import static org.iso.Physics.*; class Guacamole { public static void main(String[] args) { double molecules = AVOGADROS_NUMBER * moles;... }

Iteración For con Colecciones void cancelAll(Collection c) { for (Iterator i = c.iterator(); i.hasNext(); ) { TimerTask tt = (TimerTask) i.next(); tt.cancel(); }

Iteración For con Colecciones void cancelAll(Collection c) { for (Object o : c) ((TimerTask)o).cancel(); } Aún mejor con el uso de tipos genéricos (Generics). void cancelAll(Collection c) { for (TimerTask task : c) task.cancel(); }

Links

Fin de la presentación de JAVA 1.5