En Java, una declaración de prueba puede estar dentro del bloque de otra prueba. Se llama bloque de prueba anidado. Cada vez que se ingresa una declaración de prueba, el contexto de esa excepción se coloca en la pila.

¿Por qué usar el bloque de prueba anidado?

A veces, puede surgir una situación en la que una parte de un bloque puede causar un error y el bloque completo puede causar otro error. En tales casos, los controladores de excepciones deben estar anidados.

Sintaxis

try {
   statement 1;
   statement 2;
   try {
      statement 1;
      statement 2;
   }
   catch(Exception e) {
      // catch the corresponding exception  
   }  
}
catch(Exception e) {
   // catch the corresponding exception
}
   .............

// An example of nested try statements.
class NestTry {
public static void main(String args[]) {
    try {
        int a = args.length;
        /* If no command-line args are present,
        the following statement will generate
        a divide-by-zero exception. */
        int b = 42 / a;
        System.out.println("a = " + a);
        try { // nested try block
            /* If one command-line arg is used,
            then a divide-by-zero exception
            will be generated by the following code. */
            if(a==1) a = a/(a-a); // division by zero
            /* If two command-line args are used,
            then generate an out-of-bounds exception. */
            if(a==2) {
                int c[] = { 1 };
                c[42] = 99; // generate an out-of-bounds exception
            }
        } catch(ArrayIndexOutOfBoundsException e) {
        System.out.println("Array index out-of-bounds: " + e);
        }
    } catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
    }
  }
}

Sin línea de comando: cuando ejecuta el programa sin argumentos de línea de comando, el bloque de prueba externo genera una excepción de división por cero.

Un argumento de línea de comando: la ejecución del programa con un argumento de línea de comando genera una excepción de división por cero desde dentro del bloque de prueba anidado. Dado que el bloque interno no detecta esta excepción, se pasa al bloque de prueba externo, donde se maneja.

Dos argumentos de línea de comandos : si ejecuta el programa con dos argumentos de línea de comandos, se genera una excepción de límite de matriz desde dentro del bloque de prueba interno. Aquí hay ejecuciones de muestra que ilustran cada caso:

C:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One
a = 1
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One Two
a = 2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException:42

Esto a veces es inevitable, especialmente si su código de recuperación puede generar una excepción. No es bonito, pero a veces no hay alternativas.

Notas al margen

• Si una declaración de prueba interna no tiene una declaración de captura coincidente para una excepción en particular, el control se transfiere a los siguientes controladores de captura de declaración de prueba que se esperan para una declaración de captura coincidente.
• Esto continúa hasta que una de las sentencias catch tiene éxito , o hasta que se completan todas las sentencias try anidadas .
• Si ninguna declaración catch coincide, entonces el sistema de tiempo de ejecución de Java manejará la excepción. Cada vez que un bloque de prueba no tiene un controlador de captura para una excepción en particular, los bloques de captura del bloque de prueba principal se inspeccionan en busca de esa excepción, si se encuentra una coincidencia con la ejecución de ese bloque de captura. Si ni el bloque de captura ni el bloque de captura principal manejan la excepción luego, el mensaje generado por el sistema en tiempo de ejecución se mostraría para la excepción, similar a lo que vemos cuando no manejamos la excepción.
• Cuando se utilizan bloques de prueba anidados , el bloque de prueba interno se ejecuta primero. Cualquier excepción lanzada en el bloque try interno se captura en el bloque catch correspondiente. Si no se encuentra un bloque catch coincidente, entonces se inspecciona el bloque catch del bloque try externo hasta que se agoten todas las sentencias try anidadas. Si no se encuentran bloques coincidentes, Java Runtime Environment maneja la ejecución.

// An example of nested try statements.
class NestTry {
public static void main(String args[]) {
try {
  int a = args.length;
  /* If no command-line args are present,
  the following statement will generate
  a divide-by-zero exception. */
  int b = 42 / a;
  System.out.println("a = " + a);
  try { // nested try block
    /* If one command-line arg is used,
    then a divide-by-zero exception
    will be generated by the following code. */
    if(a==1) a = a/(a-a); // division by zero
    /* If two command-line args are used,
    then generate an out-of-bounds exception. */
    if(a==2) {
      int c[] = { 1 };
      c[42] = 99; // generate an out-of-bounds exception
  }
  } catch(ArrayIndexOutOfBoundsException e) {
  System.out.println("Array index out-of-bounds: " + e);
}
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}

C:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One
a = 1
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One Two
a = 2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException:42

/* Try statements can be implicitly nested via
calls to methods. */
class MethNestTry {
static void nesttry(int a) {
  try { // nested try block
    /* If one command-line arg is used,
    then a divide-by-zero exception
    will be generated by the following code. */
    if(a==1) a = a/(a-a); // division by zero
    /* If two command-line args are used,
    then generate an out-of-bounds exception. */
    if(a==2) {
      int c[] = { 1 };
      c[42] = 99; // generate an out-of-bounds exception
  }
  } catch(ArrayIndexOutOfBoundsException e) {
      System.out.println("Array index out-of-bounds: " + e);
  }
}
public static void main(String args[]) {
  try {
    int a = args.length;
    /* If no command-line args are present,
    the following statement will generate
    a divide-by-zero exception. */
    int b = 42 / a;
    System.out.println("a = " + a);
    nesttry(a);
  } catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
  }
}
}

Gracias por leer. Feliz aprendizaje

Únete al grupo de WhatsApp de Mouad Oumous Java ÚNETE

Únete al canal Mouad Oumous Telegram ÚNETE

Apoya nuestra publicación siguiéndola