Java 5, 6…7!

13 Sep

Desde el pasado julio de 2011, Oracle ha puesto en disponibilidad la versión 7 de Java luego de aproximadamente 5 años de trabajo no solo de ingenieros de Oracle sino también de miembros de la comunidad Java mundial  a través del proyecto OpenJDK.

En este post les quiero presentar algunas de los cambios que nos acompañan en esta nueva versión.

Inferencia de Generics: el operador Diamante (<>)

Un diamante <> es utilizado cuando construimos un objeto cuyo tipo es una instancia de un tipo genérico.  Veamos un ejemplo:

Map<String, List<String>> myMap = new HashMap<String, List<String>>();

En este fragmento de código vemos como para crear un objeto HashMap, debemos indicar explícitamente que tipo de dato debe tener la Key (String) y el Value (List<String>). En Java 7 podemos simplificar dicho código haciendo lo siguiente:

Map<String, List<String>> myMap = new HashMap< >();

Aquí entonces el compilador infiere el tipo de dato del objeto del lado izquierdo del igual a partir de la definición realizada en el lado derecho.

Underscores en literales numéricos

En muchas oportunidades nos encontramos con la necesidad de definir literales numéricos muy grandes, de muchos números. El inconveniente que existía hasta la versiones 6 de Java era el no contar con una forma que permita clarificar la lectura de dichos literales. Veamos el ejemplo:

int numero = 59234412;

Aquí, de un primer vistazo, es difícil identificar ante que numero estamos verdaderamente. Con Java 7 podemos clarificarlo de la siguiente manera:

int numero = 59_234_412;

Los guiones bajos son ignorados por el compilador pero agregan claridad en la definición de valores literales numéricos grandes.

Esta mejora, aunque parezca menor, es importante ya que contribuye a favorecer la legibilidad del código y disminuir la posibilidad de errores.

Sentencia Try With Resources (TWR)

Esta incorporación es una de las más esperadas.  Fue una de las más solicitadas por el amplio y popular espectro de desarrolladores Java en todo el mundo.  El reclamo era disponer de una manera que permita cerrar los recursos abiertos sin problemas. La sentencia Try With Resources automatiza el proceso de cerrar recursos y lo hace de una forma muy elegante.

Veamos un ejemplo. Supongamos que tenemos que abrir, usar y cerrar un archivo. Antes de Java 7, deberíamos hacer algo como lo siguiente:

FileInputStream fIn = null;
try {

  fIn = new FileInputStream("somefilename");
  // Access the file ...
} catch(IOException e) {
  // ...
} finally {
  // Close file.

  try {
    if(fIn != null) fIn.close();
  } catch(IOException e) {
    // ...
  }
}

Este código refleja la apertura, uso y cierre de un archivo. En el bloque finally, se haya podido usar el archivo o haya ocurrido una excepción, se procede a cerrarlo y de forma explícita.

Con la sentencia TWR podemos declarar e inicializar un recurso como un file stream y luego cuando el bloque finaliza el recurso automáticamente se cierra. En el caso del archivo, esto significa que no necesitamos invocar a close(). Veamos como luce esta nueva sentencia:

try(FileInputStream fIn = new FileInputStream("somefilename")) {
  // Access the file ...
} catch(IOException e) {
  // ...
}

Literales Binarios

Otro de los cambios menores pero muy útiles ha sido la incorporación de literales binarios. Esto permite lograr mayor legibilidad en los valores binarios y disminuir o hasta evitar la probabilidad de errores.

Expresiones como la siguiente son válidas:

byte mypattern = 0b01101101;

Con este ejemplo vemos que la especificación de un valor binario es directa. En versiones anteriores de Java deberiamos haber hecho algo como:

Byte.parseByte("01101101",2);

Un plus extra. Podemos combinar literales binarios con underscores:

byte mypattern = 0b0110_1101;

Multi catchs

Java 7 nos permite capturar diferentes tipos de Excepciones, sin necesidad que se encuentren relacionadas en una jerarquía de herencias, mediante un solo bloque catch.

Veamos el siguiente código:

try{
               // Some code that throws ServiceException and WebsiteException
}

catch(ServiceException exception) {
                Logger.Log(exception);
                throw ApplicationException(exception);
}

catch(WebsiteException exception){
                Logger.Log(exception);
                throw ApplicationException(exception);
}

Aquí, si para ambos tipos  de excepciones el manejo de las mismas es igual, entonces podremos optimizar el código de la siguiente forma:

try
{ // Some code that throws ServiceException and WebsiteException 
} 
catch(WebsiteException | ServiceException exception) 
{ 
 Logger.Log(exception); 
 throw ApplicationException(exception); 
}

De esta manera, no solo que eliminamos código duplicado sino que también hacemos nuestro código mas legible y menos propenso a errores.

Conclusión

Java continua creciendo. Hay 1 billón de descargas anuales del JDK y 9 millones de desarrolladores en todo el mundo. Así de simple, así de contundente.

Saludos para todos, Gastón.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: