Posso catturare più eccezioni Java nella stessa clausola catch?

Question

In Java, voglio fare qualcosa di simile:

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

... invece di:

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

Esiste un modo per fare questo?

Answer 1

Questo è possibile since Java 7. La sintassi per blocco try-catch è:

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

Prima di Java 7 questo non era possibile. Ricorda però che se tutte le eccezioni appartengono alla stessa gerarchia di classi, puoi semplicemente catturare quel tipo di eccezione di base. L'unico altro modo è catturare ogni eccezione nel proprio blocco di cattura.

Modifica: si noti che in Java 7, non è possibile rilevare sia ExceptionA che ExceptionB nello stesso blocco se ExceptionB è ereditato, direttamente o indirettamente, da ExceptionA. Il compilatore si lamenterà: The exception ExceptionB is already caught by the alternative ExceptionA.

Answer 2

No, uno per cliente.

È possibile catturare una superclasse, come java.lang.Exception, a condizione che 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 questa potrebbe non essere la migliore pratica. Dovresti solo rilevare un'eccezione quando hai una strategia per gestirla effettivamente - e il logging e il rethrowing non lo "maneggiano". Se non si dispone di un'azione correttiva, è meglio aggiungerla alla firma del metodo e lasciarla diventare una bolla in grado di gestire la situazione.

Answer 3

Cattura l'eccezione che si verifica essere una classe genitore nella gerarchia di eccezioni. This is of course, bad practice. Nel tuo caso, l'eccezione genitore comune sembra essere la classe Exception e rilevare qualsiasi eccezione che sia un'istanza di Exception, è in effetti una cattiva pratica - eccezioni come NullPointerException sono di solito errori di programmazione e dovrebbero essere risolti controllando i valori null.

Answer 4

Se esiste una gerarchia di eccezioni, è possibile utilizzare la classe di base per catturare tutte le sottoclassi di eccezioni. Nel caso degenere si può prendere tutte eccezioni Java con:

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

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

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

È possibile che questo il codice catturerà RepositoryException e PathNotFoundException per un tipo di gestione delle eccezioni e tutte le altre eccezioni sono raggruppate insieme. Dal Java 7, come da @ di OscarRyz risposta di cui sopra:

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

Answer 5

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

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

Answer 6

Non esattamente prima di Java 7, ma, vorrei fare qualcosa di simile :

Java 6 e prima

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 7

A più pulito (ma meno prolissa, e forse non a scelta) alternativa alla risposta di user454322 su Java 6 (vale a dire, Android) sarebbe quello di catturare tutti Exception s e ri- buttare RuntimeException s. Questo non funzionerebbe se hai intenzione di catturare altri tipi di eccezioni più in alto nello stack (a meno che tu non li rilasci anche tu), ma riuscirà a catturare tutte le eccezioni selezionate.

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 prolissità, potrebbe essere meglio per impostare un valore booleano o di qualche altra variabile e in base a tale eseguire del codice dopo il blocco try-catch.

Answer 8

In pre-7 che ne dici:

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