Re: Exception Jargon
On Jul 8, 4:59 pm, "zn=F4rt" <kktuapo...@yahoo.es> wrote:
Forget about stack frames, those are the trees
that won't let you see the forrest. Focus on the concept of exceptions
instead, it's pretty straightforward.
Thanks for your concern but I do know a bit about Exceptions and
wanted to know the nitty gritty details about it, and what kind of
effect it has on the program execution and the low level aspects.
Still thanks for you help. :)
On Jul 8, 6:11 pm, Patricia Shanahan <p...@acm.org> wrote:
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/ex=
pressions.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...
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.
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.
Thanks for the wonderful explanation Patricia. I do understand that
its based on the JLS on how the language behavior is handled by the
JVM, but I was looking for an explanation in low level terms (stack
frames etc.) or the way the OS handles exceptions. I know maybe I am
asking too much or being foolish here, but I think I need some good
tutorials on how things work under the hood rather than
specifications.
One question though..
public class Bitwise
{
public static void so()
{
try
{
double a = 123;
double b = 123;
if(a == 123.0)
System.out.println("Same");
System.out.println(1/0);
}
catch(Exception e)
{
System.out.println("In catch");
throw new NullPointerException();
}
finally
{
System.out.println("This is finally");
return;
}
}
public static void main(String[] args)
{
so();
}
}
In the above snippet, no exception is raised. Is this because the
return statement in the finally block makes all the exceptions in the
current scope of the method disappear? Or does it mean that the
exception is ignored when the finally block contains the return
statement.
Thanks and regards,
S T S