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:

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.

Wat is het belangrijkste doel van geketende uitzonderingen in Java?

• A

  Om de hoofdoorzaak van een uitzondering te verbergen

• B

  Om de ene uitzondering met de andere te associëren

• C

  Om de codeprestaties te verbeteren

• D

  Om runtime-fouten automatisch te herstellen

Met gekoppelde uitzonderingen kunt u de ene uitzondering aan de andere koppelen om de hoofdoorzaak te achterhalen.

Welke methode wordt gebruikt om de oorzaak van een uitzondering vast te stellen?

• A

  ontvang bericht()

• B

  setException()

• C

  initCause()

• D

  initCause()

De methode initCause() stelt de onderliggende oorzaak van een uitzondering in.

Welk type uitzondering is in het voorbeeld ingesteld als oorzaak voor NumberFormatException?

• A

  IOUitzondering

• B

  Rekenkundige uitzondering

• C

  NullPointerException

• D

  RuntimeException

In het voorbeeld wordt een NullPointerException ingesteld als de oorzaak van de NumberFormatException.