Le eccezioni concatenate in Java consentono di associare un'eccezione a un'altra, ovvero un'eccezione descrive la causa di un'altra eccezione.

• Ad esempio, considera una situazione in cui un metodo lancia un ArithmeticException a causa del tentativo di dividere per zero.
• Ma la causa principale dell'errore era un errore I/O che faceva sì che il divisore fosse zero.
• In questi casi le eccezioni concatenate aiutano a propagare sia la causa primaria che quella sottostante dell'errore.

Esempio : L'esempio seguente dimostra come utilizzare le eccezioni concatenate in Java.

// Working of chained exceptions public class Geeks {  public static void main(String[] args) {  try {    // Creating an exception  NumberFormatException ex = new NumberFormatException('Primary Exception');  // Setting the cause of the exception  ex.initCause(new NullPointerException('Root cause of the exception'));  // Throwing the exception with a cause  throw ex;  }   catch (NumberFormatException ex) {    // Displaying the primary exception  System.out.println('Caught Exception: ' + ex);  // Displaying the root cause of the exception  System.out.println('Cause of Exception: ' + ex.getCause());  }  } } 

Caught Exception: java.lang.NumberFormatException: Primary Exception Cause of Exception: java.lang.NullPointerException: Root cause of the exception 

Nota: Le eccezioni concatenate, note anche come eccezioni nidificate, ci consentono di associare una causa a un'eccezione in Java. Ciò è utile quando vogliamo propagare le informazioni sulla causa originale di un'eccezione.

Costruttori

• Gettabile (causa gettabile) : dove causa è l'eccezione che causa l'eccezione corrente.
• Throwable (causa stringa messaggio lanciabile) : Dove msg è il messaggio di eccezione e causa è l'eccezione che causa l'eccezione corrente.

Metodi di supporto lanciabile per eccezioni concatenate

1. getCausa() : questo metodo restituisce la causa effettiva di un'eccezione.
2. initCause(Causa lanciabile) : questo metodo imposta la causa dell'eccezione di chiamata.

Esempio: Utilizzo di un messaggio personalizzato con eccezioni concatenate

In Java possiamo concatenare eccezioni utilizzando il costruttore della classe Throwable.

// Use a custom message with chained exception public class Geeks {  public static void main(String[] args) {  try {    // Code that might throw an exception  int[] n = new int[5];  int divisor = 0;  for (int i = 0; i < n.length; i++) {  int res = n[i] / divisor;  System.out.println(res);  }  }   catch (ArithmeticException e) {    // Creating a new exception with   // the original as the cause  throw new RuntimeException  ('Error: Division by zero occurred' e);  }  } } 

Produzione:

javatable

Spiegazione: In questo esempio un array di numeri interi e imposta il divisore su 0.

• All'interno del blocco try tenta di dividere ogni elemento dell'array per 0, generando un'ArithmeticException.
• Questa ArithmeticException viene catturata nel blocco catch in cui viene creata una nuova RuntimeException con l'eccezione originale, ovvero ArithmeticException come causa.
• Poiché non viene rilevata RuntimeException, viene visualizzata la traccia dello stack che include RuntimeException e ArithmeticException.

Vantaggi delle eccezioni concatenate:

I vantaggi delle eccezioni concatenate sono elencati di seguito:

• Questa eccezione aiuta nel debug fornendo dettagli sia sulle cause primarie che su quelle radice.
• Semplifica la gestione degli errori consentendo la propagazione del contesto completo dell'eccezione.
• Ciò migliora la tracciabilità degli errori nelle applicazioni complesse.

Svantaggi delle eccezioni concatenate:

• Se non utilizzato correttamente può rendere l'analisi dello stack più lunga e più difficile da leggere.
• Un utilizzo eccessivo può causare messaggi di errore confusi se le eccezioni vengono concatenate inutilmente.
• Gli sviluppatori devono garantire che le cause significative siano collegate; altrimenti può trarre in inganno durante il debug.