![]() | |
|
The Java SE 7 compiler performs more precise analysis of rethrown exceptions than earlier releases of Java SE. This enables
you to specify more specific exception types in the throws
clause of a method declaration.
Consider the following example:
public class FirstException extends Exception { // ... }
public class SecondException extends Exception { // ... }
public void rethrowException(String exceptionName) throws Exception {
try {
if (exceptionName.equals("First")) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (Exception e) {
throw e;
}
}
This examples's try
block could throw either FirstException
or SecondException
. Suppose
you want to specify these exception types in the throws
clause of the rethrowException
method declaration.
In releases prior to Java SE 7, you cannot do so. Because the exception parameter of the catch
clause, e
,
is type Exception
, and the catch
block rethrows the exception parameter e
, you can only
specify the exception type Exception
in the throws
clause of the rethrowException
method
declaration.
However, in Java SE 7, you CAN specify the exception types FirstException
and SecondException
in the
throws
clause in the rethrowException
method declaration. The Java SE 7 compiler can determine that
the exception thrown by the statement throw e;
must have come from the try
block, and the only exceptions
thrown by the try
block can be FirstException
and SecondException
. Even though the exception
parameter of the catch
clause, e
, is type Exception
, the compiler can determine that it is
an instance of either FirstException
or SecondException
:
public void rethrowException(String exceptionName) throws FirstException, SecondException {
try {
// ...
} catch (Exception e) {
throw e;
}
}
This analysis is disabled if the catch
parameter is assigned to another value in the catch
block. However, if
the catch
parameter is assigned to another value, you must specify the exception type Exception
in the throws
clause of the method declaration.
In detail, in Java SE 7, when you declare one or more exception types in a catch
clause, and rethrow the exception handled by this
catch
block, the compiler verifies that the type of the rethrown exception meets the following conditions:
The try
block is able to throw it.
There are no other preceding catch
blocks that can handle it.
It is a subtype or supertype of one of the catch
clause's exception parameters.
The Java SE 7 compiler allows you to specify the exception types FirstException
and SecondException
in the
throws
clause in the rethrowException
method declaration because you can rethrow an exception that is a
supertype of any of the types declared in the throws
.
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
and SecondException
.
![]() ![]() ![]() |