Is finally block really necessary for the clean up code (like closing streams)?

Question

I am very confused as to why do I need to need to put the clean-up code like closing streams in a finally block.

I\'ve read that the code in finally<

Answer 1

If an Exception occurs, ie, the try block is executed, then, rest assured, the finally block will also be executed. It's just a safeguard option instead of putting an unreliable assumption that the rest of the method will get executed.

Answer 2

after the finally block runs rest of the method continues

This is only true if there was no exception caught. If an exception happens inside the try block the catch block will be executed (if there is one for this exception), the finally block will be executed, and then control is given to the caller of the method if the catch block throws the exception further, without running any further code in this method.

EDIT: clarify that catch would have to return of course, and not just eat the exception.

Answer 3

Maybe there is a slight misunderstanding here (or this is myself who misunderstand). The finally block is run whether a method exits on exceptional conditions or not, e.g.

 try {
      throw new Exception();
 }
 finally {
      // Block of code will be called before the method exits as exception is thrown
 }

Note that there is (very) few exception to this rule, as, for instance:

 try {
      System.exit(-1);
 }
 finally {
      // Block of code will be called before the method exits as exception is thrown
 }

This is a (quite dangerous) case where the program will exit without executing the finally block.

Answer 4

My question is; if the rest of the method has to continue then why do I not put the clean-up code after my try/catch block in a function.

Basically, like this:

InputStream is = ...
try {
   // use stream
} catch (IOException ex) {
   // report / recover
}
is.close();

But what happens if the // use stream section throws a different (e.g. unchecked) exception? Or the // report / recover code? In either case the close() call doesn't happen. (And what if there is a break or return statement in those blocks?)

It is possible to implement it this way in theory. The problem is making sure that the code always (i.e. ALWAYS) runs. And it is difficult to do that without catching a whole bunch of exceptions that you shouldn't be catching ... and won't be able to deal with properly if you do catch.

All in all, finally is the better solution.

• it is simpler than the convolutions you otherwise need to do to handle the situation properly, and
• it is more reliable than a typical half-hearted attempt.

And it is even simpler / more reliable if you can use the new Java 7 "try with resources" form in which the finally is taken care of automatically.

---

I would add that your characterization of when the finally clause is executed is a bit inaccurate. In reality, the finally block is executed no matter how the try block terminates, including:

• when the try block drops off the end,
• when it throws an exception ... irrespective of whether the exception is caught at this level, or
• when it executes a return, continue or break.

In fact, the only cases where the finally block does not execute are if the try block calls System.exit() or the JVM crashes. (Or if it goes into an infinite loop ...)

Answer 5

In case you encounter an unexpected exception (not caught and handled).

Answer 6

if the rest of the method has to continue then why do I not put the clean-up code after my try/catch block in a function.

Because the clean-up of your code is related to your try to do an action that attempts to open resources etc and logically it should be as part of the final clause as it is the last action related to your try.
It would not make sense for example to close a file or connection 100 lines later due to some processing you have to do before returning.
You got the results. No exception, release the resources. Best to do it in finally so that your code is cleaner as it is always executed