Java finally Block

Java Exceptions Tutorial

In the previous article, we have learned how to use Java try/catch Block to handle exceptions in Java. In this article, we will how and why to use finally block with examples.
finally, Block Overview

  • Java finally block is a block that is used to execute important code such as closing connection, stream etc.
  • Java finally block is always executed whether an exception is handled or not.
  • Java finally block follows try/catch block.
    For each try block, there can be zero or more catch blocks, but only one finally block.
    The finally block will not be executed if program exits(either by calling System.exit() or by causing a fatal error that causes the process to abort).
    finally Block Different Scenario Examples
    Here is an example program that shows three methods that exit in various ways, none without executing their finally clauses:

Below example covers the below scenarios:

Throw an exception out of the method
Return from within a try block
Execute a try block normally

// Demonstrate finally.
class FinallyDemo {
 // Throw an exception out of the method.
 static void procA() {
    try {
     System.out.println("inside procA");
     throw new RuntimeException("demo");
    } finally {
       System.out.println("procA's finally");
    }
 }

 // Return from within a try block.
 static void procB() {
   try {
     System.out.println("inside procB");
     return;
   } finally {
     System.out.println("procB's finally");
   }
 }

 // Execute a try block normally.
 static void procC() {
   try {
     System.out.println("inside procC");
   } finally {
     System.out.println("procC's finally");
   } 
 }

 public static void main(String args[]) {
   try {
     procA();
   } catch (Exception e) {
     System.out.println("Exception caught");
   }
    procB();
    procC();
  }
}

Output:

inside procA
procA's finally
Exception caught
inside procB
procB's finally
inside procC
procC's finally

In this example, procA( ) prematurely breaks out of the try by throwing an exception. The finally clause is executed on the way out.
procB( )’s try statement is exited via a return statement. The finally clause is executed before procB( ) returns.
In procC( ), the try statement executes normally, without error. However, the finally block is still executed.

finally, Block Examples

Example 1: In this example, we have used FileInputStream to read the simple.txt file. After reading a file the resource FileInputStream should be closed by using finally block.

public class FileInputStreamExample {
    public static void main(String[] args) {

        FileInputStream fis = null;
        try {
            File file = new File("sample.txt");
            fis = new FileInputStream(file);
            int content; 
            while ((content = fis.read()) != -1) {
               // convert to char and display it
               System.out.print((char) content);
            }
       } catch (IOException e) {
            e.printStackTrace();
       } finally {
           if(fis != null){
               try {
                   fis.close();
               } catch (IOException e) {
                  // TODO Auto-generated catch block
                    e.printStackTrace();
               }
           }
        }
    }
}

Example 2: When we use JDBC connection to communicate with a database. The resource that we have used are ResultSet, Statement, and Connection (in that order) should be closed in a finally block when you are done with them, something like that:

Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;

try {
    // Do stuff
    ...

} catch (SQLException ex) {
    // Exception handling stuff
    ...
} finally {
    if (rs != null) {
        try {
            rs.close();
        } catch (SQLException e) { /* ignored */}
    }
    if (ps != null) {
        try {
            ps.close();
        } catch (SQLException e) { /* ignored */}
    }
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) { /* ignored */}
    }
}