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

En Java, quiero hacer algo como esto:

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

...en vez de:

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

¿Hay alguna forma de hacer esto?

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

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

catch (IllegalArgumentException | SecurityException 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 capturará RepositoryException y PathNotFoundException para un tipo de manejo de excepciones y todas las demás excepciones se agrupan. Desde Java 7, según la respuesta de @ OscarRyz anterior:

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

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 detectar una excepción cuando tiene una estrategia para manejarlo realmente, y registrar y volver a lanzar no es "manejarlo". Si no tiene una acción correctiva, es mejor agregarla a la firma del método y dejar que brote a alguien que pueda manejar la situación.

Una alternativa más limpia (pero menos detallada, y tal vez no tan preferida) a la respuesta del usuario 454322 en Java 6 (es decir, Android) sería capturar todos Exceptionlos correos electrónicos y volver a lanzarlos 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 efectivamente capturará 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, para verbosidad, podría ser mejor establecer una variable booleana o alguna otra y, en función de eso, ejecutar algún código después del bloque try-catch.

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

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

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

Para kotlin, no es posible por ahora, pero han considerado agregarlo: Fuente
Pero por ahora, solo un pequeño truco:

try {
    // code
} catch(ex:Exception) {
    when(ex) {
        is SomeException,
        is AnotherException -> {
            // handle
        }
        else -> throw ex
    }
}

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