Exceções encadeadas em Java permitem associar uma exceção a outra, ou seja, uma exceção descreve a causa de outra exceção.

• Por exemplo, considere uma situação em que um método lança um Exceção Aritmética por causa de uma tentativa de dividir por zero.
• Mas a causa raiz do erro foi uma falha de E/S que fez com que o divisor fosse zero.
• Nesses casos, as exceções encadeadas ajudam a propagar as causas primárias e subjacentes do erro.

Exemplo : o exemplo a seguir demonstra como usar exceções encadeadas em 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 

Observação: Exceções encadeadas, também conhecidas como exceções aninhadas, nos permitem associar uma causa a uma exceção em Java. Isto é útil quando queremos propagar informações sobre a causa original de uma exceção.

Construtores

• Arremessável(causa lançável) : onde causa é a exceção que causa a exceção atual.
• Throwable(String msg Causa que pode ser lançada) : onde msg é a mensagem de exceção e causa é a exceção que causa a exceção atual.

Métodos de exceções encadeadas de suporte lançáveis

1. getCausa() : Este método retorna a causa real de uma exceção.
2. initCause(causa lançável) : este método define a causa da exceção de chamada.

Exemplo: Usando uma mensagem personalizada com exceções encadeadas

Em Java podemos encadear exceções usando o construtor da classe 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);  }  } } 

Saída:

comparação de strings em java

Explicação: Neste exemplo, uma matriz de inteiros e define o divisor como 0.

• Dentro do bloco try, ele tenta dividir cada elemento do array por 0, o que gera uma ArithmeticException.
• Esta ArithmeticException é capturada no bloco catch onde uma nova RuntimeException é criada com a exceção original, ou seja, ArithmeticException como sua causa.
• Como o RuntimeException não é capturado, o que exibe o rastreamento de pilha, incluindo o RuntimeException e o ArithmeticException.

Vantagens das exceções encadeadas:

As vantagens das exceções encadeadas estão listadas abaixo:

• Esta exceção ajuda na depuração, fornecendo detalhes sobre as causas primárias e raiz.
• Ele simplifica o tratamento de erros, permitindo a propagação do contexto de exceção completo.
• Isso melhora a rastreabilidade de erros em aplicações complexas.

Desvantagens das exceções encadeadas:

• Se não for usado corretamente, pode tornar o rastreamento de pilha mais longo e mais difícil de ler.
• O uso excessivo pode causar mensagens de erro confusas se as exceções forem encadeadas desnecessariamente.
• Os desenvolvedores devem garantir que causas significativas estejam vinculadas; caso contrário, pode enganar durante a depuração.