What is finally statement in java?

Answer 1

Although try and catch provide a great way to trap and handle exceptions, we are left with the problem of how to clean up if an exception occurs. Because execution transfers out of the try block as soon as an exception is thrown, we can't put our cleanup code at the bottom of the try block and expect it to be executed if an exception occurs.

Exception handlers are a poor place to clean up after the code in the try block because each handler then requires its own copy of the cleanup code. If, for example, you opened a database connection somewhere in the guarded region, each exception handler would have to release the connection. That would make it too easy to forget to do cleanup, and also lead to a lot of redundant code. If you forget to close the connection in cases where an exception occurs, you will be left with orphan connections which can eventually crash your database. To address this problem, Java offers the finally block.

A finally block encloses code that is always executed at some point after the try block, whether an exception was thrown or not. Even if there is a return statement in the try block, the finally block executes right after the return statement is encountered, and before the return executes!

This is the right place to close your files, release your db connections, and perform any other cleanup your code requires. If the try block executes with no exceptions, the finally block is executed immediately after the try block completes. If there was an exception thrown, the finally block executes immediately after the proper catch block completes. Let's look at another pseudocode example:

1: try {

2: // This is the first line of the "guarded region".

3: }

4: catch(DatabaseDownException) {

5: // Put code here that handles this exception

6: }

7: catch(SomeOtherException) {

8: // Put code here that handles this exception

9: }

10: finally {

11: // Put code here to release any resource we

12: // allocated in the try clause.

13: }

14:

15: // More code here

As before, execution starts at the first line of the try block, line 2. If there are no exceptions thrown in the try block, execution transfers to line 11, the first line of the finally block. On the other hand, if a SomeOtherException is thrown while the code in the try block is executing, execution transfers to the first line of that exception handler, line 8 in the catch clause. After all the code in the catch clause is executed, the program moves to line 11, the first line of the finally clause. To summarize - THE FINALLY BLOCK WILL EXECUTE ALWAYS. There is actually a catch here about the finally block executing always, but I will leave you to ponder over it for sometime. We will look at it a little later.

Answer 2

finally creates a block of code that will be executed after a try/catch block has

completed and before the code following the try/catch block. The finally block will

execute whether or not an exception is thrown. If an exception is thrown, the finally

block will execute even if no catch statement matches the exception. Any time a

method is about to return to the caller from inside a try/catch block, via an uncaught

exception or an explicit return statement, the finally clause is also executed just before

the method returns. This can be useful for closing file handles and freeing up any other

resources that might have been allocated at the beginning of a method with the intent

of disposing of them before returning. The finally clause is optional. However, each try

statement requires at least one catch or a finally clause.