CapturarCapturar M Múltiplas Exceúções em Java,ltipl Relasanç Exarce Exceçãoções 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 várias exceções em Java com um exemplo.

Captura de várias exceções em Java

Antes do Java 7, costumávamos capturar várias 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, assim:

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

Se um bloco catch lidar com 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 é feita na análise do compilador de exceções relançadas. 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 lançará 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 aprimorado de rethrow 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 do Java 7 analisa o bloco try completo para verificar quais tipos de exceções são lançadas e então relançadas a partir do bloco catch. Note que essa análise é desativada se você alterar o argumento do bloco catch. Leitura adicional: Tratamento de Exceção em Java.