JAVA 1.5

Fernando Almeida

Octubre 2004

IntroducciónJava 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<Integer> stack = Stack<Integer>(); 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 datosList<List<String>> list = new LinkedList<List<String>>(); list.add(new LinkedList<String>()); 

// 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<Integer, String> meses = new HashMap<Integer,String>(); 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<String> dias = new ArrayList<String>(); 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<String> comparator =

new Comparator<String>() {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

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<T1, T2> { 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<Integer, String> ene; ene = new Par<Integer, String>(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<T extends Number> extends java.util.ArrayList<T> {

public double sum() { .... }

public double average() { .... } }

Continuación MyNumberList

Las siguientes declaraciones son legales:

MyNumberList<Double> myNumberList = new MyNumberList<Double>();

MyNumberList<Integer> myNumberList2 = new MyNumberList<Integer>();

Pero las siguientes declaraciones no lo son:

MyNumberList<String> myStringList = new MyNumberList<String>();

MyNumberList<Boolean> myBooleanList = new MyNumberList<Boolean>();

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 <T extends Comparable> void mySortRoutine(Collection<T> collection);

Autoboxing / UnboxingList 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<Integer> intList = new ArrayList<Integer>();

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 = 6.02214199e23; public static final double BOLTZMANN_CONSTANT = 1.3806503e-23; public static final double ELECTRON_MASS = 9.10938188e-31;}  public class Guacamole implements Physics { public static void main(String[] args) { double moles = ...; double molecules = AVOGADROS_NUMBER * moles; ... }}

Importación estáticaLa 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<TimerTask> c) { for (TimerTask task : c) task.cancel();}

Links

http://java.sun.com/j2se/1.5.0/index.jsp

http://java.sun.com/j2se/1.5.0/download.jsp

Fin de la presentación de JAVA 1.5