Considering this code, can I be *absolutely sure* that the `finally` block always executes, no matter what `something()` is?

    try {  
        something();  
        return success;  
    }  
    catch (Exception e) {   
        return failure;  
    }  
    finally {  
        System.out.println(&quot;I don&#39;t know if this will get printed out&quot;);
    }


Does a finally block always get executed in Java?

If a finally block throws an exception, what **exactly** happens?  

Specifically, what happens if the exception is thrown midway through a finally block.  Do the rest of statements (after) in this block get invoked?  

I am aware that exceptions will propagate upwards. 

What happens if a finally block throws an exception?

I have seen people say that it is bad form to use catch with no arguments, especially if that catch doesn&#39;t do anything:

    StreamReader reader=new  StreamReader(&quot;myfile.txt&quot;);
    try
    {
      int i = 5 / 0;
    }
    catch   // No args, so it will catch any exception
    {}
    reader.Close();

However, this is considered good form:

    StreamReader reader=new  StreamReader(&quot;myfile.txt&quot;);
    try
    {
      int i = 5 / 0;
    }
    finally   // Will execute despite any exception
    {
      reader.Close();
    }

As far as I can tell, the only difference between putting cleanup code in a finally block and putting cleanup code after the try..catch blocks is if you have return statements in your try block (in that case, the cleanup code in finally will run, but code after the try..catch will not).

Otherwise, what&#39;s so special about finally?

Why is try {...} finally {...} good; try {...} catch{} bad?

Why doesn&#39;t @try block work?
It crashed the app, but it was supposed to be caught by the @try block.

     NSString* test = [NSString stringWithString:@&quot;ss&quot;];
 
     @try {
        [test characterAtIndex:6];
  
     }
     @catch (NSException * e) {
        NSLog(@&quot;Exception: %@&quot;, e);
     }
     @finally {
        NSLog(@&quot;finally&quot;);
     }



@try - catch block in Objective-C

I was surprised recently to find that it&#39;s possible to have a return statement in a finally block in Java.

It seems like lots of people think it&#39;s a bad thing to do as described in &#39;[Don&#39;t return in a finally clause][1]&#39;. Scratching a little deeper, I also found &#39;[Java&#39;s return doesn&#39;t always][2]&#39; which shows some pretty horrible examples of other types of flow control in finally blocks.

So, my question is, can anyone give me an example where a return statement (or other flow control) in a finally block produces better / more readable code?


  [1]: https://web.archive.org/web/20070922061412/http://weblogs.java.net/blog/staufferjames/archive/2007/06/_dont_return_in.html
  [2]: https://web.archive.org/web/20190528011825/http://www.cs.arizona.edu/projects/sumatra/hallofshame/

Returning from a finally block in Java

For any possible try-finally block in Python, is it guaranteed that the `finally` block will always be executed?

For example, let’s say I return while in an `except` block:

    try:
        1/0
    except ZeroDivisionError:
        return
    finally:
        print(&quot;Does this code run?&quot;)

Or maybe I re-raise an `Exception`:

    try:
        1/0
    except ZeroDivisionError:
        raise
    finally:
        print(&quot;What about this code?&quot;)

Testing shows that `finally` does get executed for the above examples, but I imagine there are other scenarios I haven&#39;t thought of.

**Are there any scenarios in which a `finally` block can fail to execute in Python?**


Does &#39;finally&#39; always execute in Python?

So I came across some code this morning that looked like this:

    try
    {
        x = SomeThingDangerous();
        return x;
    }
    catch (Exception ex)
    {
        throw new DangerousException(ex);
    }
    finally
    {
        CleanUpDangerousStuff();
    }

Now this code compiles fine and works as it should, but it just doesn&#39;t feel right to return from within a try block, especially if there&#39;s an associated finally.

My main issue is what happens if the finally throws an exception of it&#39;s own? You&#39;ve got a returned variable but also an exception to deal with... so I&#39;m interested to know what others think about returning from within a try block?

Is it bad practice to return from within a try catch finally block?

How does a return statement inside a try/catch block work?

    function example() {
        try {
            return true;
        }
        finally {
            return false;
        }
    }

I&#39;m expecting the output of this function to be `true`, but instead it is `false`!


Why does a return in `finally` override `try`?

I&#39;m reviewing some new code.  The program has a try and a finally block only.  Since the catch block is excluded, how does the try block work if it encounters an exception or anything throwable?  Does it just go directly to the finally block?

Java Try Catch Finally blocks without Catch

Why do this 

    } catch (SQLException sqle) {
        sqle.printStackTrace();
    } finally {
        cs.close();
        rs.close();
    }
Instead of this

    } catch (SQLException sqle) {
        sqle.printStackTrace();
    }
    rs.close();
    cs.close();

Why use finally instead of code after catch

I&#39;m aware of headaches that involve returning in try/catch/finally blocks - cases where the return in the finally is always the return for the method, even if a return in a try or catch block should be the one executed.

However, does the same apply to System.exit()? For example, if I have a try block:

    try {
        //Code
        System.exit(0)
    }
    catch (Exception ex) {
        //Log the exception
    }
    finally {
        System.exit(1)
    }

If there are no exceptions, which System.exit() will be called? If the exit was a return statement, then the line System.exit(1) would always (?) be called. However, I&#39;m not sure if exit behaves differently than return.

The code is in an extreme case that is very difficult, if not impossible, to reproduce, so I can&#39;t write a unit test. I&#39;m going to try to run an experiment later today, if I get a few free minutes, but I&#39;m curious anyway, and perhaps someone on SO knows the answer and can provide it before or in case I can&#39;t run an experiment.

How does Java&#39;s System.exit() work with try/catch/finally blocks?

Eclipse give me that warning in the following code:

	public int getTicket(int lotteryId, String player) {
		try {
	        c = DriverManager.getConnection(&quot;jdbc:mysql://&quot; + this.hostname + &quot;:&quot; + this.port + &quot;/&quot; + this.database, this.user, this.password); 
	        int ticketNumber;
	        
	        PreparedStatement p = c.prepareStatement(
	        		&quot;SELECT max(num_ticket) &quot; +
	        		&quot;FROM loteria_tickets &quot; +
	        		&quot;WHERE id_loteria = ?&quot;
	        		);
	        p.setInt(1, lotteryId);
	       	ResultSet rs = p.executeQuery();
	       	if (rs.next()) {
	       		ticketNumber = rs.getInt(1);
	       	} else {
	       		ticketNumber = -1;
	       	}
	       	
	       	ticketNumber++;
	       	
	       	p = c.prepareStatement(
	       			&quot;INSERT INTO loteria_tickets &quot; +
	       			&quot;VALUES (?,?,?,?)&quot;);
	       	p.setInt(1, lotteryId);
	       	p.setInt(2, ticketNumber);
	       	p.setString(3, player);
	       	p.setDate(4, new java.sql.Date((new java.util.Date()).getTime()));
	       	p.executeUpdate();
	       	
	       	return ticketNumber;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {	
			if (c != null) {
				try {
					c.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			return -1;
		}
	}

What is wrong with my code?	

&#39;finally block does not complete normally&#39; Eclipse warning

Please see the following code and explain the output behavior.

    public class MyFinalTest {
         
        public int doMethod(){
            try{
                throw new Exception();
            }
            catch(Exception ex){
                return 5;
            }
            finally{
                return 10;
            }
        }
        
        public static void main(String[] args) {

            MyFinalTest testEx = new MyFinalTest();
            int rVal = testEx.doMethod();
            System.out.println(&quot;The return Val : &quot;+rVal);
        }

    }

The result is the return Val : 10.

Eclipse shows a warning: `finally block does not complete normally`.

What happens to the return statement in catch block ?

Behaviour of return statement in catch and finally

I need a way to break from the middle of try/catch block without throwing an exception.
Something that is similar to the break and continue in for loops.
Is this possible?

I have been getting weird throughts about throwing a custom exception (naming it &quot;BreakContinueException&quot;) that simple does nothing in its catch handler. I&#39;m sure this is very twisted.

So, any straight forward solution I&#39;m not aware of?

How can I break from a try/catch block without throwing an exception in Java

This was an interview question:

    public class Demo {

        public static void main(String[] args) {
            System.out.println(foo());
        }

        static String foo() {
            try {
                return &quot;try ...&quot;;
            } catch (Exception e) {
                return &quot;catch ...&quot;;
            } finally {
                return &quot;finally ...&quot;; //got as result
            }
        }
    }

My question is why there are no compile time errors. When I have the return statement in my `finally` block, it is bound to return from `finally` instead of `try` and `catch` block. I tried to compile this code with `-Xlint` option, it gives a warning as.

    warning: [finally] finally clause cannot complete normally

Multiple return statements without compiler error

I see that the `Finally` in `Try .. Catch` will always execute after any parts of the execution of the try catch block.
 
Is it any different to just skip the `Finally` section and just run it after, outside the try catch block?

Example 1, Try ... Catch ... Finally ... End Try
----------------------------------------

        Try
            &#39;Do something
        Catch ex As Exception
            &#39;Handle exception
        Finally
            &#39;Do cleanup
        End Try

Example 2, Try ... Catch ... End Try ... Do the finally stuff outside
----------------------------------------


        Try
            &#39;Do something
        Catch ex As Exception
            &#39;Handle exception
        End Try
        &#39;Do cleanup


Why use Finally in Try ... Catch

In `C#`, how does a try catch finally block work?

So if there is an exception, I know that it will jump to the catch block and then jump to the finally block. 

But what if there is no error, the catch block wont get run, but does the finally block get run then?

How does the try catch finally block work?

Can we use  return statement in **finally** block. Can this cause any problem?

Can we use &quot;return&quot; in finally block

I am attempting to use JDK 7&#39;s &quot;try-catch with resources&quot; statement; IntelliJ highlights  my resource line, saying 

&gt; Try-with-resources are not supported at this language level.

When I try to compile, I get:

&gt;java: try-with-resources is not supported in -source 1.6
&gt;  (use -source 7 or higher to enable try-with-resources)

I checked that try-with-resources is enabled for my current project, and that my project is using JDK 7 (Library:  C:\Program Files\Java\jdk1.7.0_11).  Any ideas?  I can&#39;t figure out what option to change (if that&#39;s even the issue).

All Try Catch-Finally Solutions on Gang of Coders

Total of 19 Try Catch-Finally Solutions