Cuando debería Arrojar ser utilizado en lugar de la nueva Excepción?
https://stackoverflow.com/questions/498217
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Dado: Throwable es Exception's de la superclase.
Cuando leo textos en la escritura de su propia 'excepciones', puedo ver ejemplos de Throwable se utiliza en el catch bloque y otros textos muestran new Exception() se utiliza en el catch el bloque.Todavía tengo que ver una explicación de cuándo se debe utilizar cada uno.
Mi pregunta es la siguiente, cuando debería Throwable debe utilizar y cuándo debe new Exception() se pueden utilizar?
Dentro de la catch o else bloque mediante:
throw throwable;
o
throw new Exception();
Solución
(de los comentarios) El problema que trajo esto es que Necesito pasar una 'excepción' a un pieza de código que está construyendo un compañero de trabajo si no se crea una colección.
En ese caso, es posible que desee lanzar una excepción marcada . Puede lanzar un Exception , un subclase existente apropiada (excepto RuntimeException y sus subclases que están sin marcar ), o una subclase personalizada de CollectionBuildException (por ejemplo, " <=> "). Consulte el Tutorial de Java sobre excepciones para ponerse al día con excepciones de Java.
Otros consejos
Siempre tire un Exception (nunca un Throwable).Por lo general no coger Throwable bien, pero se puede.Arrojadiza es la superclase a Exception y Error, por lo que la captura de Throwable si lo que quiere es no sólo la captura Exceptions pero Errors, que es el punto en tenerlo.La cosa es, Errors generalmente son cosas que una aplicación normal no y no debería coger, así que sólo uso Exception a menos que tenga una razón específica para el uso de Throwable.
Realmente no deberías atrapar una excepción y lanzar una nueva tan general como " new Exception " ;.
En cambio, si desea aumentar la excepción, haga lo siguiente:
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
}
No es una buena práctica, creo, capturar una excepción y lanzar una nueva excepción en lugar de la que se generó en su bloque de código, a menos que genere una excepción personalizada útil que proporcione suficiente contexto para eludir la causa de la excepción original.
Solo dos lugares donde debería ver la palabra Throwable en el código:
public static void main(String args[])
{
try
{
// Do some stuff
}
catch(Throwable t)
{
}
}
Y
public class SomeServlet extends HttpServlet
{
public void doPost(HttpRequest request, HttpResponse response)
{
try
{
// Do some stuff
}
catch (Throwable t)
{
// Log
}
}
}
Throwable es una interfaz, no una clase. Dos clases extienden Throwable, Exception y Error.
La regla es: ser tan específico como sea posible al capturar excepciones; eso significa, por ejemplo, capturar Exception en lugar de Throwable e IOException en lugar de Exception.
No atrape los errores: los errores son errores. Repare el código en su lugar.
Si tiene que atrapar absolutamente todo, use " catch Throwable " ;, pero esta es una mala forma.
throw new Exception(); es algo que nunca debe hacer en un bloque catch, pero es posible que deba o quiera lanzar new SomeException(throwable); (preservando el seguimiento completo de la pila) en lugar de throw throwable; en para cumplir con la API de su método, por ejemplo cuando declara lanzar SomeException pero está llamando a un código que podría arrojar un IOException que no desea agregar a la cláusula throws de su método.
El caso probablemente más común es new RuntimeException(throwable); para evitar tener una cláusula <=> por completo. Muchas personas le dirán que este es un abuso horrible porque debería usar excepciones marcadas. En mi opinión, están equivocados y las excepciones marcadas son un error en el diseño del lenguaje Java que solo da como resultado un código feo e imposible de mantener.
Como escuché cuando salió Java por primera vez, la teoría era que Throwable podría usarse para transferir el control en otros casos además de las excepciones. Sin embargo, nunca he visto que se use de esa manera (y eso probablemente sea algo muy bueno).
Así que solo captura Exception (o mejor aún, una excepción más precisa).
Throwable está destinado a ser capturado solo por el contenedor o el bucle principal de su programa. La mayoría de las veces detectando cosas debajo de la Excepción, por ejemplo, Error no agrega mucha capacidad a un programa, después de todo, ¿qué puede hacer si se arroja un VirtualError y otros Errores? No mucho, excepto iniciar sesión y continuar.
Todas las excepciones son un problema al final ... también decir que los errores son errores no significa nada.
Los errores no son errores, son problemas que está experimentando la máquina virtual host, por ejemplo, OutOfMemoryError. Las excepciones son un medio que la operación actual puede usar para notificar que falló y tal vez proporcionar algún diagnóstico.
Generalmente, no lanzarías ni atraparías a Throwable. En particular, los errores JVM (que extienden Error ()) no están destinados a ser detectados por el código de usuario a menos que esté haciendo un trabajo extraño a nivel del sistema.
Tratar " Tirable " como un artefacto del lenguaje. & Quot; Excepción & Quot; la clase se llama así porque es la que los programadores deben utilizar cuando desean que un bloque de código salga de " excepcionalmente " - al no salir normalmente o devolver un valor.
Eso incluye situaciones de error regulares (por " regular " quiero decir en lugar de errores JVM) y lugares donde está utilizando excepciones como mecanismo de control.
No debe usar Excepciones como " tipo de retorno " ya sea ...
Si la condición por la que estás lanzando es común, estás gastando una gran cantidad de recursos para devolver esa condición a la rutina de llamadas. Las excepciones son caras de construir.
He visto casos en los que los bucles apretados arrojaron excepciones como & "; negativo &"; por ej. Asignación de ID, esta rutina ocupaba aproximadamente el 99% del tiempo de CPU ... cuando se cambió a una constante de retorno documentada, se redujo al 25%.
