Kædede undtagelser i Java tillader at associere en undtagelse med en anden, dvs. en undtagelse beskriver årsagen til en anden undtagelse.

• Overvej for eksempel en situation, hvor en metode kaster en Aritmetisk Undtagelse på grund af et forsøg på at dividere med nul.
• Men grundårsagen til fejlen var en I/O-fejl, der fik divisoren til at være nul.
• I sådanne tilfælde hjælper kædede undtagelser med at udbrede både de primære og underliggende årsager til fejlen.

Eksempel : Følgende eksempel viser, hvordan man bruger kædede undtagelser 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 

Note: Kædede undtagelser, også kendt som indlejrede undtagelser, giver os mulighed for at knytte en årsag til en undtagelse i Java. Dette er nyttigt, når vi ønsker at udbrede information om den oprindelige årsag til en undtagelse.

Konstruktører

• Kan kastes (årsag der kan kastes) : Hvor årsag er den undtagelse, der forårsager den aktuelle undtagelse.
• Kastbar (String msg Throwable årsag) : Hvor msg er undtagelsesmeddelelsen, og årsag er undtagelsen, der forårsager den aktuelle undtagelse.

Metoder til smidbare understøttende lænkede undtagelser

1. getCause() : Denne metode returnerer den faktiske årsag til en undtagelse.
2. initCause(Throwable cause) : Denne metode angiver årsagen til den kaldende undtagelse.

Eksempel: Brug af en brugerdefineret meddelelse med kædede undtagelser

I Java kan vi sammenkæde undtagelser ved hjælp af konstruktøren af ​​Throwable-klassen.

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

forårsstøvlearkitektur

Forklaring: I dette eksempel en matrix af heltal og sætter divisoren til 0.

• Inde i try-blokken forsøger den at dividere hvert element i arrayet med 0, hvilket kaster en ArithmeticException.
• Denne ArithmeticException er fanget i catch-blokken, hvor en ny RuntimeException oprettes med den oprindelige undtagelse, dvs. ArithmeticException som sin årsag.
• Da RuntimeException ikke fanges, hvilket viser stak-sporet inklusive RuntimeException og ArithmeticException.

Fordele ved kædede undtagelser:

Fordelene ved kædede undtagelser er anført nedenfor:

• Denne undtagelse hjælper med fejlretning ved at give detaljer om både primære og grundlæggende årsager.
• Det forenkler fejlhåndtering ved at aktivere udbredelse af fuldstændig undtagelseskontekst.
• Dette forbedrer sporbarheden af ​​fejl i komplekse applikationer.

Ulemper ved kædede undtagelser:

• Hvis det ikke bruges korrekt, kan det gøre stakken længere og sværere at læse.
• Overforbrug kan forårsage forvirrende fejlmeddelelser, hvis undtagelser er kædet unødigt.
• Udviklere skal sikre, at meningsfulde årsager er forbundet; ellers kan det vildlede under fejlfinding.