In Java, un'istruzione try può trovarsi all'interno del blocco di un altro try. Viene chiamato blocco try annidato. Ogni volta che viene immessa un'istruzione try, il contesto di tale eccezione viene inserito nello stack.

Perché usare il blocco try nidificato

A volte può verificarsi una situazione in cui una parte di un blocco può causare un errore e l'intero blocco stesso può causare un altro errore. In tali casi, i gestori di eccezioni devono essere nidificati.

Sintassi

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);
    }
  }
}

Nessuna riga di comando: quando si esegue il programma senza argomenti della riga di comando, viene generata un'eccezione di divisione per zero dal blocco try esterno.

Un argomento della riga di comando : l'esecuzione del programma con un argomento della riga di comando genera un'eccezione di divisione per zero dall'interno del blocco try nidificato. Poiché il blocco interno non rileva questa eccezione, viene passata al blocco esterno try, dove viene gestita.

Due argomenti della riga di comando : se si esegue il programma con due argomenti della riga di comando, viene generata un'eccezione al limite dell'array dall'interno del blocco try interno. Ecco alcuni esempi che illustrano ciascun 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

Questo a volte è inevitabile, soprattutto se il codice di ripristino potrebbe generare un'eccezione. Non carino, ma a volte non ci sono alternative.

Note a margine

• Se un'istruzione try interna non dispone di un'istruzione catch corrispondente per una particolare eccezione, il controllo viene trasferito ai gestori catch dell'istruzione try successiva previsti per un'istruzione catch corrispondente.
• Ciò continua fino a quando una delle istruzioni catch ha esito positivo o fino a quando tutte le istruzioni try nidificate non vengono eseguite.
• Se nessuna istruzione catch corrisponde, il sistema di runtime Java gestirà l'eccezione. Ogni volta che un blocco try non ha un gestore catch per una particolare eccezione , i blocchi catch del blocco try genitore vengono ispezionati per quell'eccezione, se viene trovata una corrispondenza che quel blocco catch viene eseguito. Se né il blocco catch né il blocco catch genitore gestiscono l'eccezione quindi il messaggio generato dal sistema in fase di esecuzione verrebbe mostrato per l'eccezione, simile a quello che vediamo quando non gestiamo l'eccezione.
• Quando vengono utilizzati i blocchi try nidificati , il blocco try interno viene eseguito per primo. Qualsiasi eccezione generata nel blocco try interno viene rilevata nel blocco catch corrispondente. Se non viene trovato un blocco catch corrispondente, il blocco catch del blocco try esterno viene ispezionato finché tutte le istruzioni try nidificate non vengono esaurite. Se non vengono trovati blocchi corrispondenti, Java Runtime Environment gestisce l'esecuzione.

// 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);
  }
}
}

Grazie per aver letto. Buon apprendimento

Unisciti al gruppo Mouad Oumous Java WhatsApp ISCRIVITI

Unisciti al canale Telegram di Mouad Oumous ISCRIVITI

Sostieni la nostra pubblicazione seguendola