Cattura più eccezioni in Java

Feb 17 2023

Per gestire più eccezioni in java possiamo: Più blocchi catch In Java, un singolo blocco try può avere più blocchi catch. Perché abbiamo bisogno di più blocchi catch in Java? Più blocchi catch in Java vengono utilizzati per gestire diversi tipi di eccezioni.

Per gestire più eccezioni in Java possiamo:

Usa più blocchi catch: qui puoi gestire più eccezioni sotto più blocchi catch per un blocco try corrispondente. Il flusso del programma arriverà automaticamente al blocco catch uno per uno e quindi il blocco catch corrispondente verrà trovato secondo l'eccezione e verrà gestito di conseguenza.
Usa più istruzioni Catch negli argomenti di un blocco Catch: questa funzionalità proviene da Java 7. Qui puoi gestire più eccezioni in un singolo blocco catch (separato dal segno pipe) per un blocco try corrispondente. Il flusso del programma arriverà automaticamente al blocco catch e quindi, l'eccezione corrispondente all'interno degli argomenti del blocco catch viene trovata per il blocco try e verrà gestita di conseguenza.

Blocchi di cattura multipli

In Java, un singolo blocco try può avere più blocchi catch.

Perché abbiamo bisogno di più blocchi catch in Java?

Più blocchi catch in Java vengono utilizzati per gestire diversi tipi di eccezioni. Quando le istruzioni in un singolo blocco try generano più eccezioni, abbiamo bisogno di più blocchi catch per gestire diversi tipi di eccezioni. Questo meccanismo è chiamato blocco multi-catch in java .

Un blocco try può essere seguito da uno o più blocchi catch. Ogni blocco catch deve contenere un gestore di eccezioni diverso. È possibile rilevare eccezioni diverse in blocchi catch diversi se contiene un gestore di eccezioni diverso. Quando si verifica un'eccezione nel blocco try, viene eseguito il blocco catch corrispondente che gestisce quella particolare eccezione. Quindi, se devi eseguire attività diverse al verificarsi di diverse eccezioni, puoi utilizzare il multi-try catch in Java.

Sintassi

La sintassi per l'utilizzo di un singolo try con più di un blocco catch in java è la seguente:

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

Nel caso in cui l'oggetto eccezione generato non corrisponda al primo blocco catch, il secondo blocco catch controllerà e così via.

Alla volta si verifica solo un'eccezione e alla volta viene eseguito solo un blocco catch. Tutti i blocchi catch devono essere disposti in modo tale che l'eccezione debba provenire dalla prima sottoclasse e poi dalla superclasse, ad esempio catch per ArithmeticException deve venire prima di catch per Exception.

Diagramma di flusso del blocco multi-cattura

Esempi

Esempio 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 perché stiamo cercando di dividere un numero per 0.
ArrayIndexOutOfBoundException perché abbiamo dichiarato un nuovo array di interi con limiti di array da 0 a 9 e stiamo cercando di assegnare un valore all'indice 10.

L'associatività dell'operatore di assegnazione = è da destra a sinistra, quindi viene generata prima un'eccezione ArithmeticException con il messaggio / per zero.

Esempio 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...

Catturare più di un tipo di eccezione con un gestore di eccezioni

In Java 7 e versioni successive, il blocco catch è stato migliorato per gestire più eccezioni in un singolo blocco catch . Se stai rilevando più eccezioni e hanno un codice simile.

Un singolo blocco catch ha la possibilità di gestire (catturare) più eccezioni separandole ciascuna con | (simbolo tubo) nel blocco di cattura .

Questa funzione può ridurre la duplicazione del codice e aumenta l'efficienza, inoltre riduce la tentazione di rilevare un'eccezione eccessivamente ampia. Il bytecode generato durante la compilazione di questo programma sarà più piccolo del programma con più blocchi di cattura in quanto non vi è ridondanza del codice.

Considera il seguente esempio, che contiene codice duplicato in ciascuno dei blocchi catch :

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

In Java SE 7 e versioni successive, possiamo eliminare il codice duplicato utilizzando questo approccio

Sintassi

Nella catchclausola, specifica i tipi di eccezioni che il blocco può gestire e separa ciascun tipo di eccezione con una barra verticale ( |):

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

Esempi

Esempio 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

Il bytecode generato durante la compilazione di questo programma sarà più piccolo del programma con più blocchi catch in quanto non vi è ridondanza del codice.

Nota : se un blocco catch gestisce più di un tipo di eccezione, il parametro catch è implicitamente final . In questo esempio, il parametro catch ex è final e pertanto non è possibile assegnargli alcun valore all'interno del blocco catch .

Questo approccio viene solitamente utilizzato se si rilevano più eccezioni e hanno un codice simile. ma possiamo anche usarlo come più ci piace.

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

Quando si rilevano più eccezioni in un singolo blocco catch , la regola viene generalizzata in specializzata.

Ciò significa che se esiste una gerarchia di eccezioni nel blocco catch , possiamo catturare solo l'eccezione di base invece di catturare più eccezioni specializzate.

Facciamo un esempio.

Esempio 1: catturare solo la classe di eccezione di 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

Se la classe di eccezione di base è già stata specificata nel blocco catch , non utilizzare le classi di eccezione figlio nello stesso blocco catch . Altrimenti, otterremo un errore di compilazione.

Facciamo un esempio.

Esempio 2: acquisizione di classi base e child exception

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

Programma

In alcuni casi, più di un'eccezione potrebbe essere sollevata da un singolo pezzo di codice. Per gestire questo tipo di situazione, puoi specificare due o più clausole catch, ognuna delle quali cattura un diverso tipo di eccezione. Quando viene generata un'eccezione, ogni istruzione catch viene ispezionata in ordine e viene eseguita la prima il cui tipo corrisponde a quello dell'eccezione. Dopo l'esecuzione di un'istruzione catch, le altre vengono ignorate e l'esecuzione continua dopo il blocco try/catch. L'esempio seguente intercetta due diversi tipi di eccezione: