java - todas - JDK 7 Capturando múltiples tipos de excepciones y volviendo a tirar excepciones con una comprobación de tipos mejorada

tipos de excepciones en java

Question

Antes de Java 7, si teníamos que volver a lanzar una excepción desde un método, entonces tendremos que hacer cualquiera de las 2 formas,

public void rethrowException(String exceptionName) throws FirstException, SecondException{
try {
if (exceptionName.equals("First")) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (FirstExceptione) {
throw e;
}catch (SecondException) {
throw e;
}
}

y el segundo ser,

public void rethrowException(String exceptionName) throws Exception {
try {
if (exceptionName.equals("First")) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (Exception e) {
throw e;
}
}

Según mi entender, New Java 7.0 ha mejorado de forma que puede detectar un amplio nivel de excepción de excepciones y aún mantiene las excepciones limitadas en la definición de método, al igual que el código de abajo,

public void rethrowException(String exceptionName)
throws FirstException, SecondException {
try {
// ...
}
catch (Exception e) {
throw e;
}
}

El compilador de Java SE 7 puede determinar que la excepción lanzada por la instrucción throw e debe provenir del bloque try, y que las únicas excepciones lanzadas por el bloque try pueden ser FirstException y SecondException. Aunque el parámetro de excepción de la cláusula catch, e, es type Exception, el compilador puede determinar que es una instancia de FirstException o SecondException. Este análisis está deshabilitado si el parámetro catch se asigna a otro valor en el bloque catch. Sin embargo, si el parámetro de captura se asigna a otro valor, debe especificar el tipo de excepción Excepción en la cláusula throws de la declaración del método.

De los documentos de Oracle,

En detalle, en Java SE 7 y posteriores, cuando declara uno o más tipos de excepción en una cláusula catch y vuelve a lanzar la excepción manejada por este bloque catch, el compilador verifica que el tipo de la excepción rethrown cumple con las siguientes condiciones:

1) The try block is able to throw it.
2) There are no other preceding catch blocks that can handle it.
3) It is a subtype or supertype of one of the catch clause''s exception parameters.
4) In releases prior to Java SE 7, you cannot throw an exception that is a supertype of one of
the catch clause''s exception parameters. A compiler from a release prior to Java SE 7 generates
the error, "unreported exception Exception; must be caught or declared to be thrown" at the
statement throw e. The compiler checks if the type of the exception thrown is assignable to any
of the types declared in the throws clause of the rethrowException method declaration. However,
the type of the catch parameter e is Exception, which is a supertype, not a subtype, of
FirstException andSecondException.

No pude entender el 3 ° y el 4 ° punto teóricamente. ¿Alguien puede explicarme en contexto con el código mencionado anteriormente?

Answer 1

Considera seguir la situación:

Su aplicación arroja una de las excepciones FirstException , SecondException , Exception

Exception es el FirstException de FirstException , SecondException porque extienden Exception .

También debería aplicar que SecondException extends FirstException . Entonces FirstException es un SecondExeption de SecondExeption y SecondException un subtipo de FirstException .

Ahora tenemos un método que siempre arroja SecondException .

Primer caso:

try {
[...]
} catch(SecondException se) {
// Exception gets always caught in here
[...]
} catch(FirstException fe) {
[...]
} catch(Exception e) {
[...]
}

Segundo caso:

try {
[...]
} catch(Exception e) {
// Exception gets always caught in here
// because Exception is supertype of all other Exception
[...]
} catch(FirstException fe) {
[...]
} catch(SecondException se) {
// is never called.
[...]
} 

¿Ves el punto?