Download Presentación

JAVA 1.5
Fernando Almeida
Octubre 2004
Introducción
Java 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 datos
List<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
Clases Genéricas
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<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 / 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<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á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<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