Geketende uitzonderingen in Java maken het mogelijk om de ene uitzondering met de andere te associëren, dat wil zeggen dat één uitzondering de oorzaak van een andere uitzondering beschrijft.

• Beschouw bijvoorbeeld een situatie waarin een methode een werpt Rekenkundige uitzondering vanwege een poging om door nul te delen.
• Maar de hoofdoorzaak van de fout was een I/O-fout waardoor de deler nul werd.
• In dergelijke gevallen helpen geketende uitzonderingen zowel de primaire als de onderliggende oorzaken van de fout te verspreiden.

Voorbeeld : In het volgende voorbeeld ziet u hoe u gekoppelde uitzonderingen in Java kunt gebruiken.

// 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 

Opmerking: Geketende uitzonderingen, ook wel geneste uitzonderingen genoemd, stellen ons in staat een oorzaak aan een uitzondering in Java te koppelen. Dit is handig als we informatie willen doorgeven over de oorspronkelijke oorzaak van een uitzondering.

Constructeurs

• Gooibaar (werpbare oorzaak) : Waarbij oorzaak de uitzondering is die de huidige uitzondering veroorzaakt.
• Throwable(String bericht Throwable oorzaak) : Waarbij bericht het uitzonderingsbericht is en oorzaak de uitzondering is die de huidige uitzondering veroorzaakt.

Methoden voor het ondersteunen van geketende uitzonderingen

1. getCause() : deze methode retourneert de werkelijke oorzaak van een uitzondering.
2. initCause(werpbare oorzaak) : Met deze methode wordt de oorzaak voor de aanroepende uitzondering ingesteld.

Voorbeeld: Een aangepast bericht gebruiken met gekoppelde uitzonderingen

In Java kunnen we uitzonderingen aan elkaar koppelen met behulp van de constructor van de klasse 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);  }  } } 

Uitgang:

lees het csv-bestand in Java

Uitleg: In dit voorbeeld wordt een array van gehele getallen gebruikt en wordt de deler op 0 gezet.

• Binnen het try-blok probeert het elk element van de array door 0 te delen, wat een ArithmeticException genereert.
• Deze ArithmeticException wordt opgevangen in het catch-blok waar een nieuwe RuntimeException wordt gemaakt met de oorspronkelijke uitzondering, d.w.z. ArithmeticException als oorzaak.
• Omdat de RuntimeException niet wordt opgevangen, wordt de stacktrace weergegeven, inclusief de RuntimeException en de ArithmeticException.

Voordelen van geketende uitzonderingen:

De voordelen van geketende uitzonderingen worden hieronder opgesomd:

• Deze uitzondering helpt bij het opsporen van fouten door details te verstrekken over zowel de primaire als de hoofdoorzaken.
• Het vereenvoudigt de foutafhandeling door de verspreiding van de volledige uitzonderingscontext mogelijk te maken.
• Dit verbetert de traceerbaarheid van fouten in complexe applicaties.

Nadelen van geketende uitzonderingen:

• Als het niet op de juiste manier wordt gebruikt, kan het de stacktracering langer en moeilijker leesbaar maken.
• Overmatig gebruik kan verwarrende foutmeldingen veroorzaken als uitzonderingen onnodig aan elkaar worden gekoppeld.
• Ontwikkelaars moeten ervoor zorgen dat betekenisvolle oorzaken met elkaar verbonden zijn; anders kan het tijdens het debuggen misleidend zijn.