"return" inside the try-catch-finally

[Kaustubh Patil]

Hi all,
i am confused about the way the return works ...
say if i have a return in the try block and something in the finally..
this is the prog..

public class TestReturn
{
    public static void main(String[] a)
    {
        TestReturn tr = new TestReturn();
        try
        {
            System.out.println("in main ii = "+tr.m(20));
        }
        catch(Exception ignore)
        {}
    }
    public int m(int j) throws Exception
    {
        int ii = 1;
        try
        {
           if(j==10) throw new Exception("e");
           System.out.println("in try ii ="+ii);
           return ii++;
        }
        catch(Exception e)
        {
            System.out.println("inside catch.. ii = "+ii);
            throw e;
        }
        finally
        {
            System.out.println("inside finally..ii = "+ii);
        }
     }
}

the following gets printed..
----------------------
in try ii =1
inside finally..ii = 2
in main ii = 1
-----------------------
now the question is ..
The return should give the control back to the calling procedure..
But i do not see it happening here. The control is returned (i guess) to the main the vaule of ii is printed as 1 and then the ii++ takes place and the statement in the finally is executed..
How does this happpens..Does it mean that the statements in the finally get executed after the return ? if not then whats the logic..??
Thanks in advance...

[Dirk Schreckmann]

The finally block gets to execute last - even if the try or catch block returns. Note that the return value of the try or catch block would not be used if the finally block were to return (which it does not have to do if the try or catch blocks have already done so). Of course, if the try or catch block were to throw an exception or close the JVM, then the finally block might not get a chance to execute.

[Ilja Preuss]

Originally posted by Dirk Schreckmann:
Of course, if the try or catch block were to throw an exception or close the JVM, then the finally block might not get a chance to execute.

I think the semantic of a finally block is to *always* get executed before controll is given back to the caller, no matter what.
A killed JVM might be an exception, of course... :roll:

[Michael Ernest]

the try/catch/finally construct is a derivative of C++, which in turn derives this feature from 'jump' instructions that appear in ISO C as setjmp() and longjmp(). These in turn derive from CPU instructions by the same name, but that's drilling a bit deep.
In short, each of these constructs alters the expected trace of bytecode instruction processing. The bytecode that are invoked by finally are defined to precede any return instruction that might occur in try or catch.