try/finally without catch and return value [duplicate]

Question

I have a program as following:

public class Main {
    public static void main(String[] args)throws Exception
    {
        int res = test();
        System.out.println("after call , res = " + res) ;
    }

    public static int test()throws Exception
    {
        try
        {
            return 10/0;
        }
        finally
        {
            System.out.println("finally") ;
        }
    }
}

after run above program , following result saw in console:

finally
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Main.test(Main.java:17)
    at Main.main(Main.java:7)

this behavior is normal because exception thrown to main method.

Then I change code as following :

public class Main {
    public static void main(String[] args)throws Exception
    {
        int res = test();
        System.out.println("after call , res = " + res) ;
    }

    public static int test()throws Exception
    {
        try
        {
            return 10/0;
        }
        finally
        {
            System.out.println("finally") ;
            return 20;
        }
    }
} 

When run above program I saw following result in console:

finally
after call , res = 20

My question related to second format. Why when return in finally block , exception not thrown to main method?

Answer 1

When your exception is thrown, it will first go through your finally block.

If your finally block does not return or throw anything then the original exception is passed on.

If your finally block on the other hand returns a value, then the exception is no longer propagated at all.

• Reference: JLS about try-finally

Answer 2

Look at the execution of try catch finally.

From java language specification -jls-14.20.2

If the run-time type of V is not assignment compatible with a catchable exception class of any catch clause of the try statement, then the finally block is executed. Then there is a choice:

If the finally block completes normally, then the try statement completes abruptly because of a throw of the value V.

If the finally block completes abruptly for reason S, then the try statement completes abruptly for reason S (and the throw of value V is discarded and forgotten).

Answer 3

From the JLS (emphasis mine):

If execution of the try block completes abruptly because of a throw of a value V, then there is a choice:
[...]
If the run-time type of V is not assignment compatible with a catchable exception class of any catch clause of the try statement, then the finally block is executed. Then there is a choice:

• If the finally block completes normally, then the try statement completes abruptly because of a throw of the value V.

• If the finally block completes abruptly for reason S, then the try statement completes abruptly for reason S (and the throw of value V is discarded and forgotten).

This means if you return within the finally block, the method returns without throwing an exception.

Besides return, there are other statementes that can cause the finally block to complete abruptly and forget about the exception. They are defined in the JLS Section 14.1. Basically, it is break, continue, return or an exception (either thrown or caused by a statement/method). The complete try/catch/finally block then completes with this reason.

There are a few more cases ín the specification of try/catch/finally, especially if there is no exception or a matching catch clause exists. It comes down to finally beats catch beats try.

Answer 4

1. If you use return in the finally section, you lose exception. Method will be finished with a normal type of a return value.
2. If you don't use return in the finally section, in your case, method will be finished with exception.

---

The first case:

try {
    throw new Exception();
} finally {
    //Exception will be lost, normal shutdown of the method
    return;
}

The second case:

try {
    throw new Exception();
} finally {
    //Exception won't be lost, we'll get Exception in the main method
}

The third case:

try {
    throw new Exception();
} finally {
    throw new IOException();
    // we lost Exception, IOException will be thrown
}

---

Note: Using the finally section to throw exceptions or to return values is a bad practice. This section has been created, for example, for closing external resources.