que - throws en java




¿Puedo capturar múltiples excepciones de Java en la misma cláusula catch? (6)

En Java, quiero hacer algo como esto:

try {
    ...     
} catch (/* code to catch IllegalArgumentException, SecurityException, 
            IllegalAccessException, and NoSuchFieldException at the same time */) {
   someCode();
}

...en lugar de:

try {
    ...     
} catch (IllegalArgumentException e) {
    someCode();
} catch (SecurityException e) {
    someCode();
} catch (IllegalAccessException e) {
    someCode();
} catch (NoSuchFieldException e) {
    someCode();
}

¿Hay alguna manera de hacer esto?


Capture la excepción que resulta ser una clase primaria en la jerarquía de excepciones. Esto es, por supuesto, una mala práctica . En su caso, la excepción padre común es la clase de excepción, y detectar cualquier excepción que sea una instancia de excepción es una mala práctica. Las excepciones como NullPointerException suelen ser errores de programación y, por lo general, deben resolverse comprobando los valores nulos.


Dentro de Java 7 puedes definir múltiples cláusulas catch como:

catch (IllegalArgumentException | SecurityException e)
{
    ...
}

Esto ha sido posible desde Java 7 . La sintaxis para un bloque de captura múltiple es:

try { 
  ...
} catch (IOException | SQLException ex) { 
  ...
}

Sin embargo, recuerde que si todas las excepciones pertenecen a la misma jerarquía de clases, simplemente puede capturar ese tipo de excepción base.

También tenga en cuenta que no puede capturar tanto ExceptionA como ExceptionB en el mismo bloque si ExceptionB se hereda, directa o indirectamente, de ExceptionA. El compilador se quejará:

Alternatives in a multi-catch statement cannot be related by subclassing
  Alternative ExceptionB is a subclass of alternative ExceptionA

No exactamente antes de Java 7, pero haría algo como esto:

Java 6 y antes

try {
  //.....
} catch (Exception exc) {
  if (exc instanceof IllegalArgumentException || exc instanceof SecurityException || 
     exc instanceof IllegalAccessException || exc instanceof NoSuchFieldException ) {

     someCode();

  } else if (exc instanceof RuntimeException) {
     throw (RuntimeException) exc;     

  } else {
    throw new RuntimeException(exc);
  }

}



Java 7

try {
  //.....
} catch ( IllegalArgumentException | SecurityException |
         IllegalAccessException |NoSuchFieldException exc) {
  someCode();
}

Sí. Aquí está la forma de usar el separador de tubería (|),

try
{
    .......
}    
catch
{
    catch(IllegalArgumentException | SecurityException | IllegalAccessException | NoSuchFieldException e)
}

Si hay una jerarquía de excepciones, puede usar la clase base para capturar todas las subclases de excepciones. En el caso degenerado puede capturar todas las excepciones de Java con:

try {
   ...
} catch (Exception e) {
   someCode();
}

En un caso más común, si RepositoryException es la clase base y PathNotFoundException es una clase derivada, entonces:

try {
   ...
} catch (RepositoryException re) {
   someCode();
} catch (Exception e) {
   someCode();
}

El código anterior detectará RepositoryException y PathNotFoundException para un tipo de manejo de excepciones y todas las demás excepciones se agruparán. Desde Java 7, según la respuesta de @ OscarRyz anterior:

try { 
  ...
} catch( IOException | SQLException ex ) { 
  ...
}




multi-catch