Behaviour of return statement in catch and finally

Please see the following code and explain the output behavior.

public class MyFinalTest {
     
    public int doMethod(){
        try{
            throw new Exception();
        }
        catch(Exception ex){
            return 5;
        }
        finally{
            return 10;
        }
    }
    
    public static void main(String[] args) {

        MyFinalTest testEx = new MyFinalTest();
        int rVal = testEx.doMethod();
        System.out.println("The return Val : "+rVal);
    }

}

The result is the return Val : 10.

Eclipse shows a warning: finally block does not complete normally.

What happens to the return statement in catch block ?

It is overridden by the one in finally, because finally is executed after everything else.

That's why, a rule of thumb - never return from finally. Eclipse, for example, shows a warnings for that snippet: "finally block does not complete normally"

finally is always executed (the only exception is System.exit()). You can think of this behavior this way:

1. An exception is thrown
2. Exception is caught and return value is set to 5
3. Finally block gets executed and return value is set to 10
4. The function returns

This is an easy question if you remember the low level layout of the VM.

1. The return value is put up the stack by the catch code.
2. Afterwards, the finally code is executed and overwrites the value on the stack.
3. Then, the method returns with the most up to date value (10) to be used by the caller.

If unsure about things like this, fall back to your understanding of the underlying system (ultimately going to assembler level).

(funny sidenote)

Finally block always get executed unless and until System.exit() statement is first in finally block.

So here in above example Exection is thrown by try statement and gets catch in catch block. There is return statement with value 5 so in stack call value 5 gets added later on finally block executed and latest return value gets added on top of the stack while returning value, stack return latest value as per stack behavior "LAST IN FIRST OUT" so It will return value as 10.

The finally block is always executed (if the matching try was executed) so before the method returns 5 as in the catch block, it executes the finally block and returns 10.

In a nut shell, we could say finally block dominates return statement, irrespective of, if return present in try or catch block.

Always finally dominates in that use case.

public static int m1() {
	try {
		return 100;
	} 
	catch(Exception e)
	{
		return 101;
	}
	finally {
		return 102;
	}
}

Output - 102

finally block will always execute (only exception is it encounters System.exit() anywhere before it), so simply the 5 is replaced (overridden) by 10 before returning by finally block

the finally section will execute always execute. e.g. if you have any thing to release, or log out sort of thing, if error occur then go to catch section else finally will execute.

Session session //  opened some session 
try 
{
 // some error 
}
catch { log.error }
finally 
{ session.logout();}

it should not used to return anything. you can use outside of.