A Java láncolt kivételei lehetővé teszik az egyik kivétel társítását a másikkal, azaz az egyik kivétel egy másik kivétel okát írja le.

• Vegyünk például egy olyan helyzetet, amelyben egy metódus egy Aritmetikai kivétel nullával való osztási kísérlet miatt.
• De a hiba kiváltó oka egy I/O hiba volt, ami miatt az osztó nulla lett.
• Ilyen esetekben a láncolt kivételek segítenek a hiba elsődleges és mögöttes okainak terjesztésében.

Példa : A következő példa bemutatja a láncolt kivételek használatát a Java-ban.

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

Jegyzet: A láncolt kivételek, más néven beágyazott kivételek, lehetővé teszik számunkra, hogy egy okot a Java kivételével társítsunk. Ez akkor hasznos, ha információt akarunk terjeszteni a kivétel eredeti okáról.

Konstruktorok

• Eldobható (eldobható ok) : Ahol az ok a kivétel, amely az aktuális kivételt okozza.
• Dobható (karakterláncüzenet, dobás oka) : Ahol az msg a kivételüzenet, az ok pedig az aktuális kivételt okozó kivétel.

A dobható alátámasztó láncos kivételek módszerei

1. getCause() : Ez a módszer a kivétel tényleges okát adja vissza.
2. initCause (eldobható ok) : Ez a módszer beállítja a hívási kivétel okát.

Példa: Egyéni üzenet használata láncolt kivételekkel

Java-ban a kivételeket a Throwable osztály konstruktorával láncolhatjuk.

// 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);  }  } } 

Kimenet:

próbáld meg a catch blokkot java-ban

Magyarázat: Ebben a példában egy egész számokból álló tömb, és az osztót 0-ra állítja.

• A try blokkon belül megpróbálja elosztani a tömb minden elemét 0-val, ami ArithmeticException-t dob.
• Ez az ArithmeticException a fogási blokkba kerül, ahol egy új futásidejű kivétel jön létre az eredeti kivétellel, azaz az Aritmetikai kivétellel.
• Mivel a RuntimeException nem kerül rögzítésre, amely megjeleníti a verem nyomkövetését, beleértve a RuntimeException-t és az ArithmeticException-t.

A láncolt kivételek előnyei:

Az alábbiakban felsoroljuk a láncolt kivételek előnyeit:

• Ez a kivétel segít a hibakeresésben, mivel részleteket ad az elsődleges és a kiváltó okokról.
• Leegyszerűsíti a hibakezelést azáltal, hogy lehetővé teszi a teljes kivételkontextus terjesztését.
• Ez javítja a hibák nyomon követhetőségét az összetett alkalmazásokban.

• Ha nem megfelelően használják, meghosszabbíthatja és nehezebben olvashatóvá teheti a veremnyomot.
• A túlzott használat zavaró hibaüzeneteket okozhat, ha a kivételek szükségtelenül vannak láncolva.
• A fejlesztőknek biztosítaniuk kell az értelmes okok összekapcsolását; különben a hibakeresés során félrevezethet.