Attraper plusieurs exceptions Java, relancer une exception

En Java 7, le bloc catch a été amélioré pour gérer plusieurs exceptions dans un seul bloc catch. Si vous interceptez plusieurs exceptions et qu’elles ont un code similaire, l’utilisation de cette fonctionnalité réduira la duplication du code. Comprendre la fonctionnalité de capture de plusieurs exceptions en Java avec un exemple.

Exceptions multiples en Java

Avant Java 7, nous devions intercepter plusieurs exceptions une par une, comme indiqué ci-dessous.

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

En Java 7, nous pouvons intercepter ces deux exceptions dans un seul bloc catch comme ceci :

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

Si un bloc catch gère plusieurs exceptions, vous pouvez les séparer avec un pipe (|) et dans ce cas, le paramètre d’exception (ex) est final, donc vous ne pouvez pas le modifier. Le bytecode généré par cette fonctionnalité est plus petit et réduit la redondance du code.

Java relance une exception

Une autre amélioration est apportée dans l’analyse du compilateur des exceptions relancées. Java relance une exception vous permet de spécifier des types d’exceptions plus spécifiques dans la clause throws de la déclaration d’une méthode. Voyons cela avec un petit exemple :

package com.journaldev.util;

public class Java7MultipleExceptions {

	public static void main(String[] args) {
		try{
			rethrow("abc");
		}catch(FirstException | SecondException | ThirdException e){
			//L'attribution ci-dessous lancera une exception de temps de compilation car e est final
			//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) {
			//L'attribution ci-dessous désactive la fonctionnalité améliorée de vérification du type d'exception rejetée de 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);
		}
	}

}

Comme vous pouvez le voir dans la méthode rethrow, le bloc catch capture l’exception mais il ne fait pas partie de la clause throws. Le compilateur Java 7 analyse le bloc try complet pour vérifier quels types d’exceptions sont lancés, puis re-lancés à partir du bloc catch. Notez que cette analyse est désactivée si vous modifiez l’argument du bloc catch. Lecture complémentaire : Gestion des exceptions en Java.