Posso rilevare più eccezioni Java nella stessa clausola catch?

In Java, voglio fare qualcosa del genere:

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

...invece di:

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

C'è un modo per fare questo?

Questo è stato possibile da Java 7 . La sintassi per un blocco multi-catch è:

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

Ricorda, tuttavia, che se tutte le eccezioni appartengono alla stessa gerarchia di classi, puoi semplicemente prendere quel tipo di eccezione di base.

Si noti inoltre che non è possibile rilevare sia ExceptionA che ExceptionB nello stesso blocco se ExceptionB è ereditato, direttamente o indirettamente, da ExceptionA. Il compilatore si lamenterà:

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

Non esattamente prima di Java 7, ma farei qualcosa del genere:

Java 6 e precedenti

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

All'interno di Java 7 è possibile definire più clausole catch come:

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

Se esiste una gerarchia di eccezioni, è possibile utilizzare la classe base per rilevare tutte le sottoclassi di eccezioni. Nel caso degenerato è possibile rilevare tutte le eccezioni Java con:

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

In un caso più comune se RepositoryException è la classe base e PathNotFoundException è una classe derivata, allora:

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

Il codice sopra catturerà RepositoryException e PathNotFoundException per un tipo di gestione delle eccezioni e tutte le altre eccezioni vengono raggruppate insieme. Da Java 7, secondo la risposta @ OscarRyz sopra:

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

No, uno per cliente.

È possibile catturare una superclasse, come java.lang.Exception, purché si esegua la stessa azione in tutti i casi.

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

Ma quella potrebbe non essere la migliore pratica. Dovresti cogliere un'eccezione solo quando hai una strategia per gestirla effettivamente - e il logging e il ri-lancio non significa "gestirla". Se non si dispone di un'azione correttiva, è meglio aggiungerlo alla firma del metodo e lasciarlo in bolla a qualcuno in grado di gestire la situazione.

Un'alternativa più chiara (ma meno dettagliata, e forse non come preferita) alla risposta di user454322 su Java 6 (cioè Android) sarebbe quella di catturare tutti Exceptioni messaggi di lancio RuntimeException. Questo non funzionerebbe se stai pianificando di catturare altri tipi di eccezioni più in alto nello stack (a meno che tu non le rilasci anche loro), ma catturerà effettivamente tutte le eccezioni verificate .

Per esempio:

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

Detto questo, per la verbosità, potrebbe essere meglio impostare un valore booleano o un'altra variabile e in base a quello eseguire un codice dopo il blocco try-catch.

In pre-7 che ne dici di:

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

Sì. Ecco come usare il separatore pipe (|),

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

Per kotlin, per ora non è possibile ma hanno considerato di aggiungerlo: Fonte
Ma per ora, solo un piccolo trucco:

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

Cattura l'eccezione che risulta essere una classe genitore nella gerarchia delle eccezioni. Questa è ovviamente una cattiva pratica . Nel tuo caso, l'eccezione genitore comune sembra essere la classe Exception e catturare qualsiasi eccezione che sia un'istanza di Exception, è in effetti una cattiva pratica: eccezioni come NullPointerException sono in genere errori di programmazione e dovrebbero essere risolte controllando i valori null.