Java 7 está en la calle. Muchos todavía no sabemos que novedades trae con respecto al lenguaje y sintaxis.

En este pequeño artículo veremos algunas de las novedades de esta nueva versión:

* String en Switch.
* Inferencia de tipo genérico(Diamond Operator)
* Multi Catch blocks
* Binary Integral literals and underscores en literales numéricos.

String en Swicht

Antes de Java 7, no teníamos la opción de utilizar cadenas en Switch. Un enfoque alternativo es usar las enumeraciones en la sentencia switch:

public class PreJava7 {
enum GRADE{
A,B,C,D;
}

public static void main(String[] args){

GRADE choice = GRADE.A;

switch (choice){
case A:
System.out.println("A chosen");
break;
case B:
System.out.println("B chosen");
break;
case C:
System.out.println("C chosen");
break;
}
}
}

Ahora, en Java 7:

String choice = "A";

switch (choice){
  case "A":
    System.out.println("A chosen");
    break;
  case "B":
    System.out.println("B chosen");
    break;
  case "C":
    System.out.println("C chosen");
    break;
}

Inferencia de tipo genérico(Diamond Operator)

Antes de Java 7,para mapear una lista genérica de tipo String, List<> teniamos:

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

O también:

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

Pero en que el código anterior, el compilador emitirá una advertencia:

Note: Java7FeatureDemo.java uses unchecked or unsafe operations.

Con Java 7, la anterior es equivalente a:

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

El compilador ahora sería el tipo de inferencia basado en la declaración de la izquierda.

Multi Catch blocks
Si un bloque de código lanza varias excepciones, y desea que todos los bloques catch hagan la misma operación, por ejemplo el registro de la excepción, teniamos que escribir algo como:

public class PreJava7 {
  public static void main(String[] args){
    try {
      exceptionMethod1();
      exceptionMethod2();
    } catch (IOException e) {
      e.printStackTrace();
    } catch (NoSuchFieldException e) {
      e.printStackTrace();
    }

  }
  static void exceptionMethod1() throws IOException{}
  static void exceptionMethod2() throws NoSuchFieldException{}
}

Ver la redundancia de código en los bloques catch. Con la introducción de bloques multicatch, el bloque mismo puede ser utilizado para capturar varias excepciones lo que conduce a la reutilización de código.
Así el código modificado sería el siguiente:

try {
exceptionMethod1();
exceptionMethod2();
} catch (IOException | NoSuchFieldException e) {
e.printStackTrace();
}

Binary Integral literals y underscores en literales numéricos.

Los literales binarios ahora se pueden representar por medio de b o B, al igual que la forma en que solíamos usar x para los literales hexadecimales.


int binary1 = 0b011;
int binary2 = 0B111;

System.out.println(binary1);
System.out.println(binary2);

Underscores en literales numéricos:

Pre Java 7, podríamos haber escrito algo como:

int hugeNumber = 1000000000;

En Java 7 podemos hacer esto:

int hugeNumber2 = 1_000_000_000;
System.out.println(hugeNumber == hugeNumber2);//SON IGUALES, es TRUE

Por lo tanto, ven lo fácil que es ahora contar el número de ceros?

En otra ocasión extenderemos este artículo para ver otras novedades importantes.

Original.

Anuncios