Re: Exception Jargon
getsanjay.sharma@gmail.com wrote:
Hello to all programmers out there. I have done a bit of fiddling with
exceptions I have come to some conclusions, which I would like to get
evaluated.
public class Test
{
public static void main(String[] args)
{
try
{
System.out.println(1/0);
}
catch(Exception e)
{
try
{
System.out.println("In catch");
throw new NullPointerException();
}
catch(Exception ee)
{
System.out.println("I have really caught the
exception");
}
}
finally
{
System.out.println("This is finally");
}
System.out.println("After finally");
}
}
``Now my understanding is this. The first line causes an Arithmetic
Exception(divide by zero). This exception is pushed on to the current
stack frame of the executing method. The C runtime of the JVM now
searches for the corresponding catch block and finds one. Hence the
exception just pushed is popped off the frame and "IN catch" is
printed. The next line again throws an exception which is again
pushed. The same procedure is repeated and "I have really caught the
exception" is printed. Then in the end, the finally block is executed
which prints "This is finally" and since there are no exceptions
pending in the stack frame, the control continues with the method and
"After finally is printed".``
This paragraph embodies models of the JVM implementation that may, or
may not, be true. For example, although as far as I know all existing
JVMs are written in C, there is nothing in the specifications that
requires that. Maybe exceptions are pushed on some stack, but again they
could be in some other form of thread-local memory.
I think you would do better to focus on a model of Java language
behavior. Unless you know a better one, I strongly recommend using the
model in the JLS,
http://java.sun.com/docs/books/jls/third_edition/html/expressions.html
In those terms, evaluation of 1/0 completes abruptly due to an
ArithmeticException. That causes abrupt completion of the println call
and the try block. Abrupt completion of the try block due to an
exception for which there is a catch block causes execution of the catch
block.
The outer catch block contains a try-catch statement whose try block
completes abruptly due to throw of a NullPointerException. There is a
catch block for it, so the inner catch block executes and completes
normally, causing normal completion of the try-catch and the outer catch
block.
http://java.sun.com/docs/books/jls/third_edition/html/statements.html#14.20.2
gives the rules for this situation. The try block of the
try-catch-finally completed abruptly due to an exception, but the catch
block completed normally. The finally block completes normally, so the
try-catch-finally also completes normally, resulting in execution of the
following statement.
Now consider this snippet:
public class Test
{
public static void main(String[] args)
{
try
{
System.out.println(1/0);
}
catch(Exception e)
{
System.out.println("In catch");
throw new NullPointerException();
}
finally
{
System.out.println("This is finally");
}
System.out.println("After finally");
}
}
``Here the same thing is repeated except for the fact that the stack
frame still has an exception pending and so after printing "This is
finally" the control returns to the calling method with the exception
still in store.
Its kind of funny why the "After finally" is not printed. Maybe
because the exception still remains on the stack frame and it is
seeking for someone to handle or for the exception to get propagated
to the main method and let the program die.``
There is nothing strange about it if you use the JLS model. The try
block completes abruptly as before. The catch block also completes
abruptly, but the finally block completes normally. In that case, the
try statement completes abruptly for the same reason as the catch block,
the NullPointerException. Abrupt completion of a statement that is not
in a try statement cases abrupt completion of the method body without
executing any more statements.
This behavior allows a catch block to substitute a new exception without
interfering with the finally clause. The finally clause can force abrupt
completion due to a return or throw, or leave the completion reason
alone by itself completing normally.
Patricia