CODEWITHSUNDEEP
javaexception
Luca
Luca

Reputation: 1766

try-catch-finally and rest of the method order of execution

I've got a doubt about using the try/catch/finally clauses,let me explain: I know that every method which declares an exception specification in its declaration has to be surrounded (in a calling method) with a try block,followed by a catch block that can capture that exception (unless I don't declare the calling method throwing an exception as well). If the calling method has other statements after the try-catch, those are executed regardless of what happens (exception thrown or not). So if I have the following code:

 public class ExceptionCall {
   Throwing t = new Throwing();
    public void methodTry(){
        while(true){
            try {
                if (t.flag++==0)
                    t.throwing();
                System.out.println("no exception");
            } 
            catch (MyException e) {
                e.printStackTrace(System.err);
                System.out.println("working on it!");
            }
            finally{
                System.out.println("finally clause");
            }
                System.out.println("out");
                if (t.flag==2) 
                    break;  
        }
    }
}

Here Throwing has a method called (guess what :) ) throwing() which is declared to throw a MyException exception, and has a public field called flag containing an int initialized to 0 to provide a sort of condition checking.

So for a couple of times the code outside the guarded region is executed no matter what happens in the try block.

So my question is, what is the finally block for?? I mean, I know it comes in handy when the calling method returns from the try or the catch block (in this case I could have a break statement inside the catch and the finally would be executed), but in a case like this what's the difference??

Upvotes: 2

Views: 832

Answers (2)

Jordi Castilla
Jordi Castilla

Reputation: 26961

Finally block is used to handle those resources that need you to make some action at the end of the statement no matter what happens in the code.

For example: readers or streams are resources that must be closed after it's use, but exceptions can happen during it's usage, so where you close them???

Here is where finally clause becomes really handy:

FileReader reader;

try {
  reader = new FileReader("someNonExistingFile");
} catch (FileNotFoundException e) {
   // handle FileNotFoundException
   e.printMessage();
} finally {
   // reader MUST BE CLOSED ALWAYS, so FINALLY, CLOSE IT
   reader.close();
}

In this example, you need to close reader always (if file exists and if file doesn't) so, instead of closing it twice (in try and in catch) you use finally.

Further info and examples of finally here. Also check try with resources (Java 7+).

Upvotes: 3

bowmore
bowmore

Reputation: 11280

The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling — it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated.

See : https://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html

Upvotes: 5

Related Questions