Java Mehrere Ausnahmen abfangen, Ausnahme erneut werfen

In Java 7 wurde der catch-Block verbessert, um mehrere Ausnahmen in einem einzigen catch-Block zu behandeln. Wenn Sie mehrere Ausnahmen abfangen und sie einen ähnlichen Code haben, wird durch Verwendung dieses Features die Code-Duplizierung reduziert. Lassen Sie uns das Feature zum Abfangen mehrerer Java-Ausnahmen anhand eines Beispiels verstehen.

Java mehrere Ausnahmen abfangen

Vor Java 7 haben wir mehrere Ausnahmen einzeln abgefangen, wie unten gezeigt.

catch (IOException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
catch (SQLException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

In Java 7 können wir beide Ausnahmen in einem einzigen catch-Block abfangen, wie folgt:

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Wenn ein catch-Block mehrere Ausnahmen behandelt, können Sie sie mit einem Pipe-Zeichen (|) trennen, und in diesem Fall ist der Ausnahme-Parameter (ex) final, sodass Sie ihn nicht ändern können. Der Bytecode, der durch dieses Feature generiert wird, ist kleiner und reduziert die Code-Redundanz.

Java Ausnahme erneut werfen

Eine weitere Verbesserung wurde bei der Compiler-Analyse von erneut geworfenen Ausnahmen vorgenommen. Mit Java Ausnahme erneut werfen können Sie spezifischere Ausnahmetypen in der throws-Klausel einer Methodendeklaration angeben. Lassen Sie uns dies anhand eines kleinen Beispiels sehen:

package com.journaldev.util;

public class Java7MultipleExceptions {

	public static void main(String[] args) {
		try{
			rethrow("abc");
		}catch(FirstException | SecondException | ThirdException e){
			// Die unten stehende Zuweisung wird eine Kompilierzeit-Ausnahme auslösen, da e final ist
			//e = new Exception();
			System.out.println(e.getMessage());
		}
	}

	static void rethrow(String s) throws FirstException, SecondException,
			ThirdException {
		try {
			if (s.equals("First"))
				throw new FirstException("First");
			else if (s.equals("Second"))
				throw new SecondException("Second");
			else
				throw new ThirdException("Third");
		} catch (Exception e) {
			// Die folgende Zuweisung deaktiviert das verbesserte Rethrow-Ausnahmeprüffeature von Java 7
			// e=new ThirdException();
			throw e;
		}
	}

	static class FirstException extends Exception {

		public FirstException(String msg) {
			super(msg);
		}
	}

	static class SecondException extends Exception {

		public SecondException(String msg) {
			super(msg);
		}
	}

	static class ThirdException extends Exception {

		public ThirdException(String msg) {
			super(msg);
		}
	}

}

Wie Sie sehen können, fängt der Catch-Block in der Methode rethrow eine Ausnahme ab, die jedoch nicht Bestandteil der throws-Klausel ist. Der Java 7 Compiler analysiert den vollständigen Try-Block, um zu überprüfen, welche Arten von Ausnahmen ausgelöst und dann aus dem Catch-Block erneut geworfen werden. Beachten Sie, dass diese Analyse deaktiviert wird, wenn Sie das Argument des Catch-Blocks ändern. Weitere Informationen: Exception Handling in Java.