Quando deve Throwable ser usado em vez de nova exceção?
https://stackoverflow.com/questions/498217
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Dada:. Throwable é superclasse de Exception
Quando li textos sobre escrever seus próprios 'exceções', vejo exemplos de Throwable sendo usado no bloco catch e outros textos mostram new Exception() sendo usado no bloco catch. Ainda estou para ver uma explicação de quando se deve usar cada um.
A minha pergunta é esta, quando deve Throwable ser usado e quando deve new Exception() ser usado?
Dentro do catch ou else bloco usando:
throw throwable;
ou
throw new Exception();
Solução
(de comentários) A questão que trouxe isso é que Eu preciso passar uma 'exceção' a ??um pedaço de código um colega de trabalho está construindo se uma coleção não são construídas.
Nesse caso, você pode querer jogar um exceção verificada . Você poderia jogar um Exception , uma apropriada existente subclasse dela (exceto RuntimeException e suas subclasses que são desmarcada ), ou uma subclasse personalizada de Exception (por exemplo, "CollectionBuildException"). Veja a Java Tutorial sobre Exceções para chegar até a velocidade com exceções Java.
Outras dicas
Sempre lançar uma Exception (nunca um Throwable). Você geralmente não pegar Throwable quer, mas você pode. Throwable é superclasse para Exception e Error, assim você iria pegar Throwable se você queria não só pegar Exceptions mas Errors, esse é o ponto em tê-lo. A coisa é, Errors geralmente são coisas que uma aplicação normal seria nem deve captura, então é só usar Exception a menos que você tenha um motivo específico para uso Throwable.
Você não deve realmente capturar uma exceção e lançar um novo tão geral como "new Exception".
Em vez disso, se desejar a borbulhar a exceção basta fazer o seguinte:
try {
// Do some stuff here
}
catch (DivideByZeroException e) {
System.out.println("Can't divide by Zero!");
}
catch (IndexOutOfRangeException e) {
// catch the exception
System.out.println("No matching element found.");
}
catch (Throwable e) {
throw e; // rethrow the exception/error that occurred
}
Não é uma boa prática, creio eu, para pegar uma exceção e lançar uma nova exceção ao invés do que foi levantada para o seu bloco de código, a menos que você levantar uma exceção personalizada útil que fornece contexto suficiente para escapar à causa da a exceção original.
Apenas dois lugares que você deve ver a palavra Throwable em código:
public static void main(String args[])
{
try
{
// Do some stuff
}
catch(Throwable t)
{
}
}
e
public class SomeServlet extends HttpServlet
{
public void doPost(HttpRequest request, HttpResponse response)
{
try
{
// Do some stuff
}
catch (Throwable t)
{
// Log
}
}
}
Throwable é uma interface, não uma classe. Duas classes estender Throwable, Exception e Error.
A regra é:. Ser tão específico quanto você pode quando capturar exceções - o que significa, por exemplo, captura de exceção em vez de Throwable, e IOException em vez de exceção
não pegar erros - erros são bugs. Corrigir o código em seu lugar.
Se você tem que pegar absolutamente tudo, use "captura Throwable", mas isso é má forma.
throw new Exception(); é algo que você deve não fazer em um bloco catch, mas você pode ter que ou quer fazer new SomeException(throwable); throw (preservando o rastreamento de pilha completo) em vez de throw throwable;, a fim de estar de acordo com a API do seu método, por exemplo, quando declara que jogar SomeException mas você está chamando código que pode lançar uma IOException que você não deseja adicionar ao que você cláusula throws do método.
O caso provavelmente mais comum é new RuntimeException(throwable); para evitar ter uma cláusula throws completamente. Muitas pessoas vão dizer que este é um abuso horrível porque você deve usar exceções verificadas. IMO eles estão errados e exceções verificadas são um erro na concepção da linguagem Java que apenas resulta em código feio, insustentável.
Como ouvi-lo quando java saiu primeiro, a teoria era que Throwable pode ser usado para a transferência de controle em outros casos além exceções. Eu nunca vi isso usado dessa forma embora (e isso é provavelmente uma coisa muito boa).
Então, basta pegar Exception (ou melhor ainda, uma mais exceção de grão fino).
Throwable destina-se a ser apenas pego pela embalagem ou o loop principal do seu programa. Na maioria das vezes pegando coisas abaixo Erro de exceção por exemplo, não acrescenta muito a capacidade para um programa, depois de tudo o que você pode possível fazer se um VirtualError outros erros são jogados. Não muito, exceto log e continuar.
Todas as exceções são um problema no final ... também dizer Erros são erros does not qualquer coisa média.
Os erros não são bugs - são problemas que o host VM está experimentando, por exemplo OutOfMemoryError. As exceções são um meio que a operação atual pode usar para notificar que falhou e talvez proporcionar algum diagnóstico.
Geralmente, você não iria jogar ou pegar Throwable. Em particular, os erros JVM (que se estendem Error ()) não são significava para ser capturado pelo código do usuário, a menos que você está fazendo um trabalho de nível de sistema estranho.
Treat "Throwable" como um artefato da linguagem. A classe "Exception" é nomeado que porque é a única que se destina a ser usado por programadores quando eles querem um bloco de código para sair "excepcionalmente." - por não sair normalmente ou retornar um valor
Isso inclui ambas as situações regulares de erro (por "regular" Quero dizer, em oposição a erros JVM) e lugares onde você estiver usando exceções como um mecanismo de controle.
Você não deve usar exceções como um "tipo de retorno" ou ...
Se a condição de que você está jogando para é comum, você está gastando uma quantidade enorme de recursos para retornar essa condição para a rotina de chamada. Exceções são caros de construir.
Já vi casos em que laços apertados que jogou exceções como "negativo" para por exemplo alocação de ID, esta rotina ocupava cerca de 99% do tempo da CPU .. quando mudou para um constante retorno documentado em vez disso, este caiu para 25%.
