finally in exception handling

问题:

What exactly does a finally block in exception handling perform?

回答1:

It holds code that should always be executed, regardless of whether an exception occurs.

For example, if you have opened a file, you should close it in the finally block to ensure that it will always be closed; if you closed it in the try block, an earlier exception would cause execution to jump straight to the catch block and skip closing the file.

See the Java tutorials for more details.

回答2:

The finally block always executes, regardless of whether or not the exception was thrown. The classic use example I can think of is closing files.

FileOutputStream stream = null;
try{
    // do stuff with the stream here
} catch (IOException ex){
    // handle exception
} finally{
    // always close the stream
    if(stream != null){
        stream.close();
    }
}

回答3:

It executes no matter if you get into the catch block or not, meaning that is a great place for disposing of objects and doing other cleanups.

回答4:

I use it a lot for cleaning up open resources when there are multiple return statements in a block of code, making the code a lot cleaner as you don't need to clone the same 'close resource' code before every return statement. It's guaranteed that the code will call the finally section, even if you do a return within the try section. It also helps with code safety in this instance, since the programmer could easily leave it out by accident.

回答5:

If you return a value in your try or catch block as well as in the finally block, keep in mind that the finally block's return value is what you'll end up with (the last block executed). That means if you try some code that does NOT throw an Exception and is supposed to return a value, but your finally block is also supposed to return a value, the finally block's value is what will actually be returned. This SO thread talks about that very point. I don't believe returning a value inside a try or catch is usually necessary or the best idea. Also note that System.exit(0) kills the JVM and thus halts execution before anything else runs, which might render your finally block unexecuted.

回答6:

finally block is mainly used to perform close statement for example con.close that is to close connection from database....try block is always followed by either catch block or finally (or both also)...If you once entered in the try block then your finally block will be definately execute except system error,exception in finally block....Main key point of finally block is that it always be executed even the exception is handled or not..

回答7:

finally keyword is used just to make sure that code present in finally block must execute in all circumstances irrespective of exception occurances.

for eg:

 try{
     }
     catch(Exception e){
     }
      finally{
             System.out.print("finally executed");
            }

Note: In above case finally will always execute.

回答8:

Though there are many answers have already given that finally block is required to execute some piece of code in all the conditions whether there is some interruption due to exception, or some bad code, or you return the program control flow from try block, Here I'm adding an example to explain the need of finally block;

Let's suppose you have borrowed a pen from your friend. You use it and then return ( I consider you a gentleman). Now whatever happens, you have to return the pen. You can handle various situations and you put most unavoidable condition in finally block.

//Borrow the pen
try{
  //Use the pen
}catch(StolenPen how){
  //Buy new pen
}catch(InkFinished how){
  //Refill the pen
}catch(SomethingWrong how){
  //Buy new pen
}finally{
  //Return new pen
}