Kann ich mehrere Java-Ausnahmen in derselben catch-Klausel abfangen?

In Java möchte ich so etwas tun:

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

...anstatt:

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

Gibt es eine Möglichkeit, dies zu tun?

Dies ist seit Java 7 möglich . Die Syntax für einen Multi-Catch-Block lautet:

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

Denken Sie jedoch daran, dass Sie einfach diesen Basisausnahmetyp abfangen können, wenn alle Ausnahmen zur selben Klassenhierarchie gehören.

Beachten Sie auch, dass Sie ExceptionA und ExceptionB nicht im selben Block abfangen können, wenn ExceptionB direkt oder indirekt von ExceptionA geerbt wird. Der Compiler wird sich beschweren:

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

Nicht genau vor Java 7, aber ich würde so etwas tun:

Java 6 und früher

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

In Java 7 können Sie mehrere catch-Klauseln definieren, z.

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

Wenn es eine Hierarchie von Ausnahmen gibt, können Sie die Basisklasse verwenden, um alle Unterklassen von Ausnahmen abzufangen. Im entarteten Fall können Sie alle Java-Ausnahmen abfangen mit:

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

In einem häufigeren Fall, wenn RepositoryException die Basisklasse und PathNotFoundException eine abgeleitete Klasse ist, gilt Folgendes:

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

Der obige Code fängt RepositoryException und PathNotFoundException für eine Art der Ausnahmebehandlung ab, und alle anderen Ausnahmen werden zusammengefasst. Seit Java 7 gemäß der obigen Antwort von @ OscarRyz:

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

Nein, eine pro Kunde.

Sie können eine Oberklasse wie java.lang.Exception abfangen, solange Sie in allen Fällen dieselbe Aktion ausführen.

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

Dies ist jedoch möglicherweise nicht die beste Vorgehensweise. Sie sollten eine Ausnahme nur dann abfangen, wenn Sie eine Strategie für die tatsächliche Behandlung haben - und Protokollieren und erneutes Werfen bedeutet nicht "Behandeln". Wenn Sie keine Korrekturmaßnahme haben, fügen Sie diese besser der Methodensignatur hinzu und lassen Sie sie an jemanden weitergeben, der mit der Situation umgehen kann.

Eine sauberere (aber weniger ausführliche und möglicherweise nicht bevorzugte) Alternative zur Antwort von user454322 auf Java 6 (dh Android) wäre, alle Exceptions zu fangen und s erneut zu werfen RuntimeException. Dies würde nicht funktionieren, wenn Sie planen, andere Arten von Ausnahmen weiter oben im Stapel abzufangen (es sei denn, Sie werfen sie auch erneut), sondern alle effektiv abgefangen Ausnahmen .

Zum Beispiel:

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

Aus Gründen der Ausführlichkeit ist es jedoch möglicherweise am besten, einen Booleschen Wert oder eine andere Variable festzulegen und basierend darauf nach dem try-catch-Block Code auszuführen.

In Pre-7 wie wäre es mit:

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

Ja. Hier ist der Weg mit dem Rohrabscheider (|):

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

Für Kotlin ist es momentan nicht möglich, aber sie haben darüber nachgedacht, es hinzuzufügen: Quelle
Aber im Moment nur ein kleiner Trick:

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

Fangen Sie die Ausnahme ab, die zufällig eine übergeordnete Klasse in der Ausnahmehierarchie ist. Dies ist natürlich eine schlechte Praxis . In Ihrem Fall ist die allgemeine übergeordnete Ausnahme zufällig die Exception-Klasse, und das Abfangen einer Ausnahme, die eine Instanz von Exception ist, ist in der Tat eine schlechte Praxis. Ausnahmen wie NullPointerException sind normalerweise Programmierfehler und sollten normalerweise durch Überprüfen auf Nullwerte behoben werden.