Captura de Múltiplas Exceções em Java, Rethrow Exception

No Java 7, o bloco catch foi aprimorado para lidar com várias exceções em um único bloco catch. Se você estiver capturando várias exceções e elas tiverem código semelhante, usar esse recurso reduzirá a duplicação de código. Vamos entender o recurso de captura de múltiplas exceções em Java com um exemplo.

Captura de múltiplas exceções em Java

Antes do Java 7, costumávamos capturar múltiplas exceções uma por uma, como mostrado abaixo.

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

No Java 7, podemos capturar ambas essas exceções em um único bloco catch, como:

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

Se um bloco catch manipula várias exceções, você pode separá-las usando um pipe (|) e, nesse caso, o parâmetro de exceção (ex) é final, então você não pode alterá-lo. O código de byte gerado por esse recurso é menor e reduz a redundância de código.

Rethrow de exceção em Java

Outra melhoria foi feita na análise do compilador de exceções retransmitidas. Rethrow de exceção em Java permite que você especifique tipos de exceção mais específicos na cláusula throws da declaração de um método. Vamos ver isso com um pequeno exemplo:

package com.journaldev.util;

public class Java7MultipleExceptions {

	public static void main(String[] args) {
		try{
			rethrow("abc");
		}catch(FirstException | SecondException | ThirdException e){
			//A atribuição abaixo causará uma exceção de tempo de compilação, pois e é 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) {
			//A atribuição abaixo desativa o recurso de verificação de tipo de exceção aprimorada do 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);
		}
	}

}

Como você pode ver, no método rethrow, o bloco catch está capturando Exception, mas não faz parte da cláusula throws. O compilador Java 7 analisa o bloco try completo para verificar quais tipos de exceções são lançadas e depois relançadas a partir do bloco catch. Observe que essa análise é desativada se você alterar o argumento do bloco catch. Leitura adicional: Tratamento de Exceções em Java.