Captura múltiples excepciones en Java

Feb 17 2023

Para manejar múltiples excepciones en Java podemos: Múltiples bloques catch En Java, un solo bloque try puede tener múltiples bloques catch. ¿Por qué necesitamos múltiples bloques catch en Java? Se utilizan múltiples bloques catch en Java para manejar diferentes tipos de excepciones.

Para manejar múltiples excepciones en Java podemos:

Use Multiple Catch Blocks: Aquí puede manejar múltiples excepciones bajo múltiples bloques catch para un bloque try correspondiente. El flujo del programa llegará automáticamente al bloque catch uno por uno y luego, el bloque catch correspondiente se encuentra según la excepción y se manejará en consecuencia.
Use múltiples declaraciones de captura en argumentos de un bloque de captura: esta función proviene de Java 7. Aquí puede manejar múltiples excepciones en un solo bloque de captura (separado por un signo de canalización) para un bloque de prueba correspondiente. El flujo del programa llegará automáticamente al bloque catch y luego, la excepción correspondiente dentro de los argumentos del bloque catch se encuentra para el bloque try y se manejará en consecuencia.

Múltiples bloques de captura

En Java, un solo bloque de prueba puede tener varios bloques de captura.

¿Por qué necesitamos múltiples bloques catch en Java?

Se utilizan múltiples bloques catch en Java para manejar diferentes tipos de excepciones. Cuando las declaraciones en un solo bloque de prueba generan múltiples excepciones, necesitamos múltiples bloques catch para manejar diferentes tipos de excepciones. Este mecanismo se llama bloque de captura múltiple en java .

Un bloque try puede ir seguido de uno o más bloques catch. Cada bloque catch debe contener un controlador de excepción diferente. Puede capturar diferentes excepciones en diferentes bloques catch si contiene un controlador de excepciones diferente. Cuando ocurre una excepción en el bloque try, se ejecuta el bloque catch correspondiente que maneja esa excepción en particular. Por lo tanto, si tiene que realizar diferentes tareas en caso de diferentes excepciones, puede usar la captura de intentos múltiples en Java.

Sintaxis

La sintaxis para usar un solo intento con más de un bloque catch en Java es la siguiente:

try 
{ 
  statements; 
} 
catch(ExceptionType1 e1) 
{ 
  statements; 
} 
catch(ExceptionType2 e2) 
{ 
  statements; 
}

En caso de que el objeto de excepción lanzado no coincida con el primer bloque catch, el segundo bloque catch verificará, y así sucesivamente.

A la vez solo ocurre una excepción y a la vez solo se ejecuta un bloque catch. Todos los bloques catch deben organizarse de tal manera que la excepción debe provenir de la primera subclase y luego de la superclase, es decir, catch para ArithmeticException debe venir antes que catch para Exception.

Diagrama de flujo del bloque de captura múltiple

Ejemplos

Ejemplo 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException e) {
      System.out.println(e.getMessage());
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    } 
  }
}

/ by zero

ArithmeticException porque estamos tratando de dividir un número por 0.
ArrayIndexOutOfBoundException porque hemos declarado una nueva matriz de enteros con límites de matriz de 0 a 9 y estamos tratando de asignar un valor al índice 10.

La asociatividad del operador de asignación = es de derecha a izquierda, por lo que primero se lanza una ArithmeticException con el mensaje / por cero.

Ejemplo 2

class Example2{
   public static void main(String args[]){
     try{
         int a[]=new int[7];
         a[4]=30/0;
         System.out.println("First print statement in try block");
     }
     catch(ArithmeticException e){
        System.out.println("Warning: ArithmeticException");
     }
     catch(ArrayIndexOutOfBoundsException e){
        System.out.println("Warning: ArrayIndexOutOfBoundsException");
     }
     catch(Exception e){
        System.out.println("Warning: Some Other exception");
     }
   System.out.println("Out of try-catch block...");
  }
}

Warning: ArithmeticException
Out of try-catch block...

Captura de más de un tipo de excepción con un controlador de excepciones

En Java 7 y versiones posteriores, el bloque catch se ha mejorado para manejar múltiples excepciones en un único bloque catch . Si detecta varias excepciones y tienen un código similar.

Un solo bloque catch tiene la posibilidad de manejar (atrapar) múltiples excepciones separando cada una con | (símbolo de tubería) en el bloque catch .

Esta función puede reducir la duplicación de código y aumentar la eficiencia, además de disminuir la tentación de capturar una excepción demasiado amplia .

Considere el siguiente ejemplo, que contiene código duplicado en cada uno de los bloques catch :

catch (IOException ex) {
     logger.log(ex);
     ex.printStackTrace();
catch (SQLException ex) {
     logger.log(ex);
     ex.printStackTrace();
}

En Java SE 7 y posterior, podemos eliminar el código duplicado usando este enfoque

Sintaxis

En la catchcláusula, especifique los tipos de excepciones que puede manejar el bloque y separe cada tipo de excepción con una barra vertical ( |):

try {
  // code
} catch (ExceptionType1 | Exceptiontype2 ex) { 
  // catch block
}

Ejemplos

Ejemplo 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

El código de bytes generado al compilar este programa será más pequeño que el programa que tiene múltiples bloques catch ya que no hay redundancia de código.

Nota : si un bloque catch maneja más de un tipo de excepción, entonces el parámetro catch es implícitamente final . En este ejemplo, el parámetro catch ex es definitivo y, por lo tanto, no puede asignarle ningún valor dentro del bloque catch .

Este enfoque generalmente se usa si detecta varias excepciones y tienen un código similar. pero también podemos usarlo como queramos.

Ejemplo 2

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException|ArrayIndexOutOfBoundsException e) {
      if (e instanceof ArithmeticException)
          System.out.println("ArithmeticException");
      else
          System.out.println("ArrayIndexOutOfBoundsException");
    }
  }
}

Cuando se capturan varias excepciones en un solo bloque catch , la regla se generaliza a especializada.

Esto significa que si hay una jerarquía de excepciones en el bloque catch , podemos capturar solo la excepción base en lugar de capturar varias excepciones especializadas.

Tomemos un ejemplo.

Ejemplo 1: capturar solo la clase de excepción base

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

Si la clase de excepción base ya se especificó en el bloque catch , no use clases de excepción secundarias en el mismo bloque catch . De lo contrario, obtendremos un error de compilación.

Tomemos un ejemplo.

Ejemplo 2: captura de clases de excepción base y secundaria

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

Main.java:6: error: Alternatives in a multi-catch statement cannot be related by subclassing

Programa

En algunos casos, una sola pieza de código podría generar más de una excepción. Para manejar este tipo de situación, puede especificar dos o más cláusulas catch, cada una de las cuales detecta un tipo diferente de excepción. Cuando se lanza una excepción, cada instrucción catch se inspecciona en orden y se ejecuta la primera cuyo tipo coincida con el de la excepción. Después de que se ejecuta una instrucción catch, las demás se omiten y la ejecución continúa después del bloque try/catch. El siguiente ejemplo atrapa dos tipos de excepciones diferentes: