Mejoras de versión en el manejo de excepciones introducidas en Java SE 7

En este artículo, se han discutido las mejoras realizadas por Oracle en la versión 1.7 , junto con su implementación.

Como parte de la mejora de la versión 1.7, Oracle ha introducido los siguientes dos conceptos en Manejo de excepciones :

1. Prueba con los recursos .
2. Múltiples bloques de captura .

Prueba con recursos

Hasta la versión 1.6, se recomendaba escribir el bloque finalmente para cerrar todos los recursos que están abiertos como parte del bloque de prueba .

Por ejemplo:

// Java program to illustrate cleaning of
// resources before Java 7
  
import java.io.*;
import java.util.*;
  
class Resource {
    public static void main(String args[])
    {
        BufferedReader br = null;
        String str = " ";
  
        System.out.println(
            "Enter the file path");
        br
            = new BufferedReader(
                new InputStreamReader(
                    System.in));
  
        try {
  
            str = br.readLine();
  
            String s;
  
            // file resource
            br
                = new BufferedReader(
                    new FileReader(str));
  
            while ((s = br.readLine()) != null) {
                // print all the lines
                // in the text file
                System.out.println(s);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
  
        // This part was compulsory before Java 7
        // but with the introduction of
        // try with resource in Java 7
        // this part is optional now.
        finally {
            try {
                if (br != null)
  
                    // closing the resource
                    // in 'finally' block
                    br.close();
            }
            catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

Producción:

hello
java

Ventaja de probar con recursos:

1. La principal ventaja de probar con recursos es que los recursos que se abrieron como parte del bloque de prueba se cerrarán automáticamente una vez que el control alcance el final del bloque de prueba, ya sea de manera normal o anormal. Por lo tanto, no estamos obligados a cerrarlo explícitamente. Por lo tanto, se reducirá la complejidad de la programación.
2. Podemos declarar cualquier cantidad de recursos, pero todos estos recursos deben estar separados por punto y coma (;)

   try(R1;R2;R3)
   {
   - - - - - - -
   - - - - - - -
   }
   

3. Todos los recursos deben ser recursos autocerrables . Se dice que un recurso se puede cerrar automáticamente si y solo si la clase correspondiente
   implementa la interfaz java.lang.AutoCloseable, ya sea directa o indirectamente.
   Por ejemplo, todos los recursos relacionados con la base de datos, la red y el archivo IO ya implementaron la interfaz AutoCloseable.
4. Todas las variables de referencia de recursos son implícitamente finales y, por lo tanto, no podemos realizar reasignaciones dentro del bloque de prueba. Por ejemplo, en el siguiente código, estamos reasignando el valor de br para el cual obtenemos un error de tiempo de compilación .

   try (BufferedReader br = new BufferedReader(new FileReader("abc.txt"))) {     br = new BufferedReader(new FileReader("abc.txt")); }

5. Hasta la versión 1.6, try debe ir seguido de catch o finalmente, pero en la versión 1.7 solo podemos probar con recursos sin una instrucción catch o finalmente.

   try(R)
   {  //valid
   }
   

A continuación se muestra la implementación del bloque try-catch mejorado:

// Try opening a file
try (bufferedReader br = new BufferedReader(new FileReader("abc.txt"))) {
}
  
// Catch an exception
catch (IOException e) { // handling code }
  
// After the execution of try and catch is completed
// the file is closed automatically by Java

Múltiples bloques de captura :

Hasta la versión 1.6, si deseamos manejar múltiples excepciones para el mismo bloque try, teníamos que definir todas las excepciones en múltiples instrucciones catch.

Por ejemplo:

// For this try block
try {
    -------- - -------- -
}
  
// Catching Arithmetic Exception
catch (ArithmeticException e) {
    e.printStackTrace();
}
  
// Catching Nullpointer Exception
catch (e) {
    e.printStackTrace();
}
  
// Catching Class Cast Exception
catch (ClassCastException e) {
    System.out.println(e.getMessage());
}
  
// Catching IOException
catch (IOException e) {
    System.out.println(e.getMessage());
}

Para superar este problema, se introdujo el concepto de «Bloque de captura múltiple» en la versión 1.7. Por lo tanto, todas las excepciones se pueden manejar con una sola instrucción catch .

A continuación se muestra la implementación de la declaración de captura múltiple:

try {
    ------ - ------ -
}
catch (ArithmeticException | NullpointerException
       | ClassCastException | IOException e) {
    System.out.println(e.getMessage());
}

Nota: En el bloque de captura múltiple, no debe haber ninguna relación entre los tipos de Excepción (ya sea de niño a padre o de padre a hijo o del mismo tipo.