Chained Exceptions i Java tillåter att associera ett undantag med ett annat, dvs ett undantag beskriver orsaken till ett annat undantag.

• Tänk till exempel på en situation där en metod kastar en ArithmeticException på grund av ett försök att dividera med noll.
• Men grundorsaken till felet var ett I/O-fel som gjorde att divisorn var noll.
• I sådana fall hjälper kedjade undantag att sprida både de primära och underliggande orsakerna till felet.

Exempel : Följande exempel visar hur man använder kedjade undantag i 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 

Notera: Med kedjade undantag, även kända som kapslade undantag, kan vi associera en orsak med ett undantag i Java. Detta är användbart när vi vill sprida information om den ursprungliga orsaken till ett undantag.

Konstruktörer

• Kastbar (kastbar orsak) : Där orsak är undantaget som orsakar det aktuella undantaget.
• Kastbar (String msg Kastbar orsak) : Där msg är undantagsmeddelandet och orsak är undantaget som orsakar det aktuella undantaget.

Metoder för kastbara stödjande kedjade undantag

1. getCause() : Denna metod returnerar den faktiska orsaken till ett undantag.
2. initCause(Uppkastbar orsak) : Den här metoden anger orsaken till det anropande undantaget.

Exempel: Använda ett anpassat meddelande med kedjade undantag

I Java kan vi kedja undantag med hjälp av konstruktorn för klassen 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);  }  } } 

Produktion:

hur man får aktuellt datum i java

Förklaring: I det här exemplet en matris med heltal och sätter divisorn till 0.

• Inuti försöksblocket försöker den dela varje element i arrayen med 0 vilket ger ett ArithmeticException.
• Detta ArithmeticException fångas i catch-blocket där ett nytt RuntimeException skapas med det ursprungliga undantaget, dvs ArithmeticException som orsak.
• Eftersom RuntimeException inte fångas upp som visar stackspåret inklusive RuntimeException och ArithmeticException.

Fördelar med kedjade undantag:

Fördelarna med kedjade undantag listas nedan:

• Detta undantag hjälper till vid felsökning genom att tillhandahålla information om både primära och rotorsaker.
• Det förenklar felhanteringen genom att möjliggöra spridning av fullständig undantagskontext.
• Detta förbättrar spårbarheten av fel i komplexa applikationer.

Nackdelar med kedjade undantag:

• Om den inte används på rätt sätt kan den göra stacken längre och svårare att läsa.
• Överanvändning kan orsaka förvirrande felmeddelanden om undantag är kedjade i onödan.
• Utvecklare måste se till att meningsfulla orsaker är kopplade; annars kan det vilseleda under felsökning.