Re: Catching Thrown Exceptions
On 2/21/2012 1:36 AM, Davej wrote:
I figured that if you threw an exception inside a try it would be
caught. No? In my Java program the throw was not caught. In C# this is
the way things work.
In Java, a thrown exception is caught by one of the `catch'
clauses associated with a `try'. This may be the immediately
enclosing `try' if it has an appropriate `catch'; if not, it will
be some outer `try' further up the calling/nesting stack. If the
Java code has no suitable `catch' anywhere along the path, the
exception is caught by the Java Virtual Machine's last-gasp catcher,
which need not be a literal `catch' clause (because the JVM need not
be written in Java), but has much the same effect: It is as if the
entire thread ran inside `try {...} catch(Throwable t) {...}'.
You haven't shown any code so it's difficult to guess what your
problem is, but perhaps it's a confusion about what constitutes an
"appropriate" `catch' clause. Each `catch' specifies a type of
exception it's interested in, and will only catch exceptions of
that type or of one of its subtypes. A `catch(IOException ex)'
clause will catch IOException and FileNotFoundException, but it
will not catch IllegalStateException or NumberFormatException.
Perhaps your code throws an exception of a type you were not
expecting, for which your `catch' is not suitable. Without code,
though, it's hard to tell.
One construct that processes exceptions indiscriminately is
the `finally' clause: Code in a `finally' will run on any kind of
exit from its `try' block, whether by exception or `return' or
`break' or whatever. If a thrown exception terminates the `try',
the `finally' code runs "en passant" during the search for an
applicable `catch', after which the search continues. (Things
get more complicated if the `finally' code throws yet another
exception or does something else weird, but let's not go there
until we know more about your problem.)
--
Eric Sosman
esosman@ieee-dot-org.invalid