Nuevas Características de Lenguaje en J2SE 5.0

Gonzalo Mena Mendoza

Protocolos Avanzados de Redes

Maestría en Ingeniería de Software Distribuido

Universidad Autónoma de Querétaro

Artículo Original

Programming with the New Language Features in J2SE 5.0

Qusay H. Mahmoud

Sun Developer Network

Junio 2004

Introducción

• Java 2 Platform, Standard Edition version 5.0 (J2SE 5.0):
• Version externa: 5.0
• Version interna: 1.5
• Nombre del lanzamiento: Tiger
• Nuevas características desarrolladas bajo Java Community Process (JCP).
• Facilidad de desarrollo es uno de los temas principales.

Nuevas Características del Lenguaje

Genéricos
Bucle for aumentado
Autoempacado/desempacado
Enumeraciones de tipo seguro
Importación estática
Metadatos
Argumentos variables
Salida formateada
Entrada mejorada
Sincronización

Genéricos

• También conocidos como tipos parametrizados.
• La interfaz Collection considera sólo miembros de clase Object durante ejecución.
• Proporcionan seguridad de tipos durante compilación.
• Eliminan las molestias del "vaciado" (casting).

Genéricos (antes)

Esto compila correctamente:

  import java.util.*;

  public class Ej1 {
    public static void main(String args[]) {

      List lista = new ArrayList();
      lista.add(new String("¡Hola!"));
      lista.add(new String("¡Adiós!"));
      lista.add(new Integer(95));

      Iterator i = c.iterator();
      while(i.hasNext()) {
        String item = (String) i.next();
        System.out.println("Artículo: " + item);
      }
      
    }
  }
  

Genéricos (problema)

Pero falla al ejecutarse:

  Artículo: ¡Hola!
  Artículo: ¡Adiós!
  Exception in thread "main" java.lang.ClassCastException: java.lang.Integer
          at Ej1.main(Ej1.java:14)
  

Genéricos (ahora)

Problemas detectados durante compilación:

  import java.util.*;

  public class Ej2 {
    public static void main(String args[]) {

      List<String> lista = new ArrayList<String>();
      lista.add(new String("¡Hola!"));
      lista.add(new String("¡Adiós!"));
      lista.add(new Integer(95)); // error

      Iterator<String> i = c.iterator();
      while(i.hasNext()) {
        String item = i.next();
        System.out.println("Artículo: " + item);
      }
      
    }
  }
  

Bucle for aumentado (definición)

• Bucle actual no optimizado para iterar sobre colecciones, Iterator necesario.
• Nuevo bucle itera sobre arreglos o colecciones sin requerir iteradores o variables de incremento.
• Nueva sintaxis:
  for (ParámetroFormal : Expresión) Sentencia
  • La expresión es un arreglo o una instancia de la interfaz java.lang.Iterable
  • java.util.Collection extiende java.lang.Iterable
• ¿Por qué no foreach (Elemento in Colección)?

Bucle for aumentado (colección)

• Antes:

  
      // Asume una instancia de StringBuffer "sb"
      public void viejoFor(Collection c) {
        for(Iterator i = c.iterator(); i.hasNext(); ) {
          String str = (String) i.next();
          sb.append(str);
        }
      }
      

• Ahora:

  
      // Asume una instancia de StringBuffer "sb"
      public void nuevoFor(Collection<String> c) {
        for(String str : c) {
          sb.append(str);
        }
      }
      

Bucle for aumentado (arreglo)

• Antes:

  
      public int viejaSuma(int arreglo[]) {
        int suma = 0;
        for(int i = 0; i < arreglo.length; i++) {
          suma += arreglo[i];
        }
        return suma;
      }
      

• Ahora:

  
      public int nuevaSuma(int arreglo[]) {
        int suma = 0;
        for(int i : arreglo) {
          suma += i;
        }
        return suma;
      }
      

Autoempacado/Desempacado

• Antes: conversión manual entre tipo primitivo (p.e. int) y objeto "envoltura" (p.e. Integer) al utilizar colecciones:

  
      List list = new ArrayList();
      list.add(0, new Integer(59));
      int n = ( (Integer) (list.get(0)) ).intValue();
      

• Ahora:

  
      List<Integer> list = new ArrayList<Integer>();
      list.add(0, 59);
      int n = list.get(0);
      

• Cuidado:
  • Diferencia entre valor matemático y referencia.
  • Los tipos primitivos no pueden tener valor nulo.

Enumeraciones de Tipo Seguro (problema)

• Una enumeración consiste en un conjunto fijo de constantes.
• Patrón común:

  
      public class MenúPrincipal {
        public static final int MENÚ_ARCHIVO = 0;
        public static final int MENÚ_EDICIÓN = 1;
        public static final int MENÚ_FORMATO = 2;
      }
      

• Problemas:
  1. Tipo inseguro.
  2. Recompilación de clientes necesaria si se añaden constantes.
  3. Carece de espacio de nombres, las constantes requieren de prefijo.
  4. Sin manera fácil de convertir constantes en valores identificables al imprimir.

Enumeraciones de Tipo Seguro (nueva sintaxis)

• En J2SE 5.0:

  
      public enum MenúPrincipal {ARCHIVO, EDICIÓN, FORMATO};
      

• Ventajas:
  1. Fuerte seguridad de tipo durante compilación.
  2. Se pueden agregar o quitar valores sin recompilar clientes.
  3. Espacio de nombres para cada enumeración, prefijo innecesario.
  4. Valores impresos informativos en lugar de números.
  5. Utilizables dondequiera se usen objetos.
• La declaración enum genera una clase (MenúPrincipal):
  • Implementa Comparable<MenúPrincipal> y Serializable.
  • Variables estáticas ARCHIVO, EDICIÓN y FORMATO.
  • Método estático values() regresa un arreglo de constantes.
  • Método estático valueOf(String) regresa constante a partir de nombre.
  • Sobrecarga equals(), hasCode(), toString(), y compareTo().

Enumeraciones de Tipo Seguro (ejemplos)

• Declara una enumeración e imprime los valores:

  
      public class Ejemplo {
        public enum MenúPrincipal {ARCHIVO, EDICIÓN, FORMATO};
  
        public static void main(String[] args) {
          for (MenúPrincipal menú : MenúPrincipal.values())
            System.out.println(menú);
        }
      }
      

• Utilización de switch:

  
      for (MenúPrincipal menú : MenúPrincipal.values()) {
        switch(menú) {
          case ARCHIVO:
            System.out.println("archivo");    break;
          case EDICIÓN:
            System.out.println("edición");    break;
          case FORMATO:
            System.out.println("formato");    break;
        }
      }
      

Importación Estática (antes)

• Supongamos una interfaz con dos constantes:

  
      interface XYZ {
        public static final int    Constante1 = 123;
        public static final String Constante2 = "ABC";
      }
      

• Antes: necesario implementar interfaz para utilizar constantes sin cualificarlas

  
      public class MiClase implements XYZ {
        ....
        int valor = 2 * Constante1;
        ...
      }
      

Importación Estática (ahora)

• Ahora la herencia no se "ensucia":

  
      import static XYZ.*;
  
      public class MiClase {
        ....
        int valor = 2 * Constante1;
        ...
      }
      

• También para métodos:

  
      import static java.lang.Math.*;
      import static java.lang.System.*;
  
      public class Ejemplo {
        public static void main(String[] args) {
          out.println("cos(0)=" + cos(0))
        }
      }
      

Metadatos

• Permite anotar el código para que las herramientas generen código repetitivo.
• Por ejemplo, para RMI (Remote Method Invocation):
  • Antes:

    
            public interface PingIF extends Remote {
              public void ping() throws RemoteException;
            }
    
            public class Ping implements PingIF {
              public void ping() {
              }
            }
            

  • Antes:

    
            public class Ping {
              public @remote void ping() {
              }
            }
            

Argumentos Variables

• Antes:

  
      void miMétodo(String arg0)              { miMétodo(new String[] {arg0}) }
      void miMétodo(String arg0, String arg1) { miMétodo(new String[] {arg0, arg1}) }
      void miMétodo(String[] args)            {
        for (int i = 0; i < args.length; ++i) System.out.println(args[i]);
      }
  
      void prueba() {
        miMétodo("1", "2");
        miMétodo(new String[] {"1", "2", "3", "4", "5"});
      }
      

• Ahora:

  
      void miMétodo(String ... args) {
        for (String a : args) System.out.println(a);
      }
  
      void prueba() {
        miMétodo("1", "2");
        miMétodo("1", "2", "3", "4", "5");
      }
      

Salida y Entrada

• Salida Formateada:
  • Similar al printf de C:

    
        System.out.printf("%s %3d", nombre, edad);
        

• Entrada Mejorada:
  • Antes:

    
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        int n = Integer.parseInt(str);
          

  • Ahora:

    
        Scanner reader = new Scanner(System.in);
        int n = reader.nextInt();
          

  • java.util.Formatter proporciona algoritmos de reconocimiento de patrones

Sincronización

• java.util.concurrent, biblioteca de sincronización de alto nivel:
  • Hilos
  • Colas
  • Colecciones concurrentes
  • Seguros de propósito especial
  • Barreras

Conclusión

• El lanzamiento de Tiger proporciona nuevas características y mejoras para facilitar el desarrollo de Java.
• Ejemplos que ilustran las nuevas características y hacen el código más legible.
• Aunque algunas características ya existen en otros lenguajes, Java verifica los tipos durante la compilación.

Mas Información

• Descarga de J2SE 5.0, http://java.sun.com/j2se/5.0/download.jsp
• Cambios de nombre y version en J2SE 5.0, http://java.sun.com/j2se/j2se-namechange.html
• Contenido del Lanzamiento J2SE 5.0 (Tiger), http://www.jcp.org/en/jsr/detail?id=176
• Nuevas Características y Mejoras en J2SE 5.0, http://java.sun.com/j2se/5.0/docs/relnotes/features.html
• J2SE 5.0 en Pocas Palabras, http://java.sun.com/developer/technicalArticles/releases/j2se15
• Conversación con Joshua Bloch, http://java.sun.com/features/2003/05/bloch_qa.html