multiple - propagacion de excepciones en java

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

Question

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?

Answer 1

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.

Answer 2

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

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

Answer 3

En pre-7, ¿qué tal?

  Boolean   caught = true;
  Exception e;
  try {
     ...
     caught = false;
  } catch (TransformerException te) {
     e = te;
  } catch (SocketException se) {
     e = se;
  } catch (IOException ie) {
     e = ie;
  }
  if (caught) {
     someCode(); // You can reference Exception e here.
  }

Answer 4

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

Answer 5

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();
}

Answer 6

No, uno por cliente.

Puede capturar una superclase, como java.lang.Exception, siempre que realice la misma acción en todos los casos.

try {
    // some code
} catch(Exception e) { //All exceptions are caught here as all are inheriting java.lang.Exception
    e.printStackTrace();
}

Pero esa podría no ser la mejor práctica. Solo debe capturar una excepción cuando tenga una estrategia para manejarlo realmente, y el registro y el reenvío no lo están "manejando". Si no tiene una acción correctiva, es mejor agregarla a la firma del método y dejar que se convierta en alguien que pueda manejar la situación.

Answer 7

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

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

Answer 8

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 ) { 
  ...
}

Answer 9

Una alternativa más limpia (pero menos detallada, y quizás no como la preferida) a la respuesta de user454322 en Java 6 (es decir, Android) sería capturar todas las Exception y volver a lanzar las RuntimeException . Esto no funcionaría si planea capturar otros tipos de excepciones más arriba en la pila (a menos que también las vuelva a lanzar), pero capturará efectivamente todas las excepciones marcadas .

Por ejemplo:

try {
    // CODE THAT THROWS EXCEPTION
} catch (Exception e) {
    if (e instanceof RuntimeException) {
        // this exception was not expected, so re-throw it
        throw e;
    } else {
        // YOUR CODE FOR ALL CHECKED EXCEPTIONS
    } 
}

Dicho esto, por verbosidad, podría ser mejor establecer una variable booleana o alguna otra variable y, basándose en eso, ejecutar algún código después del bloque try-catch.