Basic Syntax and Behavior

public class FinallyExample { public static void main(String[] args) { try { System.out.println("Inside try block"); int result = 10 / 2; // No exception System.out.println("Result: " + result); } catch (ArithmeticException e) { System.out.println("Exception caught: " + e.getMessage()); } finally { System.out.println("Finally block executed - always runs!"); } } }

Output:

Inside try block Result: 5 Finally block executed - always runs!

Finally with Exception

public class FinallyWithException { public static void main(String[] args) { try { System.out.println("Inside try block"); int result = 10 / 0; // ArithmeticException System.out.println("This won't be printed"); } catch (ArithmeticException e) { System.out.println("Exception caught: " + e.getMessage()); } finally { System.out.println("Finally block executed despite exception!"); } } }

Output:

Inside try block Exception caught: / by zero Finally block executed despite exception!

Finally with Uncaught Exception

public class FinallyUncaughtException { public static void main(String[] args) { try { System.out.println("Inside try block"); String str = null; str.length(); // NullPointerException } catch (ArithmeticException e) { System.out.println("This won't catch NullPointerException"); } finally { System.out.println("Finally executes even with uncaught exception!"); } // This line won't be reached due to uncaught exception } }

Output:

Inside try block Finally executes even with uncaught exception! Exception in thread "main" java.lang.NullPointerException

Return Statement in Finally

public class FinallyReturn { public static int testFinallyReturn() { try { System.out.println("Inside try"); return 1; } finally { System.out.println("Inside finally"); return 2; // This overrides the try return! } } public static void main(String[] args) { System.out.println("Return value: " + testFinallyReturn()); } }

Output:

Inside try Inside finally Return value: 2

System.exit() in Finally

public class FinallySystemExit { public static void testSystemExit() { try { System.out.println("Inside try"); System.exit(0); // JVM terminates here } finally { System.out.println("This won't be printed!"); } } public static void main(String[] args) { testSystemExit(); System.out.println("This also won't be printed"); } }

Output:

Inside try

Real-World Use Cases

1. Resource Cleanup

import java.io.*; public class ResourceCleanup { public static void readFile(String filename) { BufferedReader reader = null; try { reader = new BufferedReader(new FileReader(filename)); String line; while ((line = reader.readLine()) != null) { System.out.println(line); } } catch (IOException e) { System.out.println("Error reading file: " + e.getMessage()); } finally { try { if (reader != null) { reader.close(); System.out.println("File closed successfully"); } } catch (IOException e) { System.out.println("Error closing file: " + e.getMessage()); } } } }

2. Database Connection Cleanup

public class DatabaseExample { public static void processDatabase() { Connection conn = null; PreparedStatement stmt = null; try { // Get database connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "pass"); stmt = conn.prepareStatement("SELECT * FROM users"); // Execute query and process results ResultSet rs = stmt.executeQuery(); while (rs.next()) { // Process each row } } catch (SQLException e) { System.out.println("Database error: " + e.getMessage()); } finally { // Always close resources try { if (stmt != null) stmt.close(); if (conn != null) conn.close(); System.out.println("Database resources closed"); } catch (SQLException e) { System.out.println("Error closing resources: " + e.getMessage()); } } } }

Try-with-Resources (Java 7+)

import java.io.*; public class TryWithResources { public static void readFileModern(String filename) { // Automatic resource management - no finally needed for closing try (BufferedReader reader = new BufferedReader(new FileReader(filename))) { String line; while ((line = reader.readLine()) != null) { System.out.println(line); } } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } // Resources automatically closed here } }

Complex Scenarios

Nested Finally Blocks

public class NestedFinally { public static void complexOperation() { try { System.out.println("Outer try"); try { System.out.println("Inner try"); int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("Inner catch"); throw e; // Re-throw exception } finally { System.out.println("Inner finally"); } } catch (Exception e) { System.out.println("Outer catch: " + e.getMessage()); } finally { System.out.println("Outer finally"); } } public static void main(String[] args) { complexOperation(); } }

Output:

Outer try Inner try Inner catch Inner finally Outer catch: / by zero Outer finally

Important Rules and Behaviors

1. Execution Order

public class ExecutionOrder { public static String testOrder() { try { System.out.println("Try block"); return "Try return"; } catch (Exception e) { System.out.println("Catch block"); return "Catch return"; } finally { System.out.println("Finally block"); // If you return here, it overrides previous returns } } public static void main(String[] args) { System.out.println("Result: " + testOrder()); } }

Output:

Try block Finally block Result: Try return

2. Exception in Finally Block

public class ExceptionInFinally { public static void testFinallyException() { try { try { System.out.println("Inner try"); throw new RuntimeException("Exception from try"); } finally { System.out.println("Inner finally"); throw new RuntimeException("Exception from finally"); } } catch (RuntimeException e) { System.out.println("Caught: " + e.getMessage()); } } public static void main(String[] args) { testFinallyException(); } }

Output:

Inner try Inner finally Caught: Exception from finally

Best Practices

1. Use finally for cleanup - Always close resources in finally blocks
2. Avoid returns in finally - They can suppress exceptions from try/catch
3. Keep finally blocks simple - Avoid complex logic that might throw exceptions
4. Use try-with-resources - For automatic resource management when possible
5. Handle exceptions in finally - Wrap resource cleanup in try-catch within finally

// ✅ Good practice public static void safeResourceUsage() { Connection conn = null; try { conn = getConnection(); // Use connection } catch (SQLException e) { // Handle exception } finally { if (conn != null) { try { conn.close(); } catch (SQLException e) { // Log but don't throw - don't mask original exception System.err.println("Warning: Failed to close connection: " + e.getMessage()); } } } }

The finally block is crucial for ensuring that cleanup code always executes, regardless of what happens in the try-catch blocks, making it essential for robust resource management and preventing resource leaks.