tipos - todas las excepciones en java

¿Es posible que Java capture dos excepciones en el mismo bloque catch?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Puedo capturar múltiples excepciones de Java en la misma cláusula catch? 8 respuestas

Necesito atrapar dos excepciones porque requieren la misma lógica de manejo. Me gustaría hacer algo como:

catch (Exception e, ExtendsRuntimeException re) {
    // common logic to handle both exceptions
}

¿Es posible evitar duplicar el código del controlador en cada bloque catch?

Answer 1

Java 7 y posterior

Se admiten capturas de excepción múltiple , comenzando en Java 7.

La sintaxis es:

try {
     // stuff
} catch (Exception1 | Exception2 ex) {
     // Handle both exceptions
}

El tipo estático de ex es el supertipo común más especializado de las excepciones enumeradas. Hay una buena característica en la que si vuelves a sacar ex en la captura, el compilador sabe que solo se puede lanzar una de las excepciones enumeradas.

Java 6 y versiones anteriores

Antes de Java 7, hay formas de manejar este problema, pero tienden a ser poco elegantes y tener limitaciones.

Enfoque # 1

try {
     // stuff
} catch (Exception1 ex) {
     handleException(ex);
} catch (Exception2 ex) {
     handleException(ex);
}

public void handleException(SuperException ex) {
     // handle exception here
}

Esto se complica si el manejador de excepciones necesita acceder a las variables locales declaradas antes del try . Y si el método del manejador necesita volver a lanzar la excepción (y está marcada), entonces se encontrará con serios problemas con la firma. Específicamente, handleException debe declararse como lanzar SuperException ... lo que potencialmente significa que tiene que cambiar la firma del método adjunto, y así sucesivamente.

Enfoque # 2

try {
     // stuff
} catch (SuperException ex) {
     if (ex instanceof Exception1 || ex instanceof Exception2) {
         // handle exception
     } else {
         throw ex;
     }
}

Una vez más, tenemos un problema potencial con las firmas.

Enfoque n. ° 3

try {
     // stuff
} catch (SuperException ex) {
     if (ex instanceof Exception1 || ex instanceof Exception2) {
         // handle exception
     }
}

Si SuperException la parte else (por ejemplo, porque no hay otros subtipos de SuperException en este momento), el código se vuelve más frágil. Si se reorganiza la jerarquía de excepciones, este controlador sin else puede terminar comiendo excepciones de forma silenciosa.

Answer 2

Antes del lanzamiento de Java SE 7 éramos habituales de escribir código con múltiples declaraciones catch asociadas a un bloque try. Un ejemplo muy básico:

 try {
  // some instructions
} catch(ATypeException e) {
} catch(BTypeException e) {
} catch(CTypeException e) {
}

Pero ahora, con la última actualización de Java, en lugar de escribir múltiples declaraciones catch, podemos manejar múltiples excepciones dentro de una sola cláusula catch. Aquí hay un ejemplo que muestra cómo se puede lograr esta característica.

try {
// some instructions
} catch(ATypeException|BTypeException|CTypeException ex) {
   throw e;
}

Por lo tanto, las múltiples excepciones en una sola cláusula de captura no solo simplifican el código, sino que también reducen la redundancia del código. Encontré este artículo que explica muy bien esta característica junto con su implementación. Mejor y mejor manejo de excepciones de Java 7 Esto también puede ser útil.

Answer 3

Para Java <7 puede usar if-else junto con Exception:

try {
    // common logic to handle both exceptions
} catch (Exception ex) {
    if (ex instanceof Exception1 || ex instanceof Exception2) {

    }
    else {
        throw ex;
        // or if you don''t want to have to declare Exception use
        // throw new RuntimeException(ex);
    }
}

Editado y reemplazado Throwable with Exception.

Answer 4

Si no está en Java 7, puede extraer su manejo de excepciones a un método, de esa manera puede al menos minimizar la duplicación.

try {
   // try something
}
catch(ExtendsRuntimeException e) { handleError(e); }
catch(Exception e) { handleError(e); }

Answer 5

http://docs.oracle.com/javase/tutorial/essential/exceptions/catch.html cubre la captura de múltiples excepciones en el mismo bloque.

 try {
     // your code
} catch (Exception1 | Exception2 ex) {
     // Handle 2 exceptions in Java 7
}

Estoy haciendo tarjetas de estudio, y este hilo fue útil, solo quería poner mi granito de arena.

Answer 6

Java <= 6.x solo le permite capturar una excepción para cada bloque catch:

try {

} catch (ExceptionType name) {

} catch (ExceptionType name) {

}

Documentación:

Cada bloque catch es un manejador de excepciones y maneja el tipo de excepción indicado por su argumento. El tipo de argumento, ExceptionType, declara el tipo de excepción que el manejador puede manejar y debe ser el nombre de una clase que hereda de la clase Throwable.

Para Java 7 puede tener múltiples excepciones atrapadas en un bloque catch:

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

Documentación:

En Java SE 7 y posterior, un solo bloque catch puede manejar más de un tipo de excepción. Esta característica puede reducir la duplicación de código y disminuir la tentación de atrapar una excepción demasiado amplia.

Referencia: http://docs.oracle.com/javase/tutorial/essential/exceptions/catch.html