Capturar Múltiples Excepciones en Java, Volver a Lanzar la Excepción

En Java 7, el bloque catch se ha mejorado para manejar múltiples excepciones en un solo bloque catch. Si estás capturando múltiples excepciones y tienen código similar, usar esta funcionalidad reducirá la duplicación de código. Entendamos la funcionalidad de capturar múltiples excepciones en Java con un ejemplo.

Capturar múltiples excepciones en Java

Antes de Java 7, solíamos capturar múltiples excepciones una por una como se muestra a continuación.

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, podemos capturar ambas excepciones en un solo bloque catch como:

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

Si un bloque catch maneja múltiples excepciones, puedes separarlas usando el símbolo de tubería (|) y en este caso, el parámetro de excepción (ex) es final, por lo que no puedes cambiarlo. El código de bytes generado por esta funcionalidad es más pequeño y reduce la redundancia de código.

Relanzar una excepción en Java

Otra mejora se ha realizado en el análisis del compilador de excepciones relanzadas. La funcionalidad de relanzar una excepción en Java te permite especificar tipos de excepción más específicos en la cláusula throws de una declaración de método. Veamos esto con un pequeño ejemplo:

package com.journaldev.util;

public class Java7MultipleExceptions {

	public static void main(String[] args) {
		try{
			rethrow("abc");
		}catch(FirstException | SecondException | ThirdException e){
			// La asignación a continuación lanzará una excepción en tiempo de compilación ya que e es 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) {
			// La asignación a continuación deshabilita la función mejorada de verificación de tipo de excepción reasignada 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);
		}
	}

}

Como puedes ver, en el método rethrow, el bloque catch captura Exception pero no es parte de la cláusula throws. El compilador de Java 7 analiza el bloque try completo para verificar qué tipos de excepciones se lanzan y luego las vuelve a lanzar desde el bloque catch. Ten en cuenta que este análisis se desactiva si cambias el argumento del bloque catch. Lectura adicional: Manejo de Excepciones en Java.