Finally block in Java - Step-by-Step Execution

Concept Flow - Finally block

Start try block

↓

Execute try code

↓

Exception?

Yes→Catch block executes

↓

Catch code runs

↓

Try code ends

↓

Catch ends

↓

Finally block runs regardless

↓

Program continues

The finally block runs after try and catch blocks, no matter if an exception happened or not.

Execution Sample

Java

try {
    System.out.println("Try block");
    int a = 5 / 0;
} catch (ArithmeticException e) {
    System.out.println("Catch block");
} finally {
    System.out.println("Finally block");
}

This code tries to divide by zero, catches the error, and always runs the finally block.

Execution Table

Step	Action	Evaluation	Output
1	Enter try block	No exception yet	Try block
2	Execute division 5 / 0	ArithmeticException thrown
3	Catch ArithmeticException	Catch block runs	Catch block
4	Execute finally block	Runs regardless of exception	Finally block
5	End of try-catch-finally	Program continues

💡 Finally block runs always, then program continues after try-catch-finally

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
a	undefined	undefined	Exception thrown, no value	undefined	undefined

Key Moments - 3 Insights

Does the finally block run if an exception is thrown and caught?

Yes, as shown in step 4 of the execution table, the finally block runs no matter what.

What happens if no exception occurs in the try block?

The finally block still runs after the try block finishes, even if catch is skipped (not shown here but same rule).

Can the finally block change the program flow by itself?

Usually no, finally runs after try/catch, but if it contains return or throws, it can affect flow (not shown here).

Visual Quiz - 3 Questions

Look at the execution table, what is printed at step 3?

A Finally block

B Try block

C Catch block

D No output

💡 Hint

Check the 'Output' column at step 3 in the execution table.

At which step does the finally block execute?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for the step where 'Finally block' is printed in the output column.

If the division 5 / 0 did not throw an exception, which step would be skipped?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Catch block runs only if exception occurs, see step 3 in execution table.

Concept Snapshot

try {
  // code that might throw
} catch(Exception e) {
  // handle error
} finally {
  // always runs
}

The finally block runs after try and catch, no matter what happens.

Full Transcript

This example shows how Java's finally block works. The try block runs first and tries to divide by zero, which causes an ArithmeticException. The catch block catches this error and prints 'Catch block'. Then, the finally block runs and prints 'Finally block' regardless of the exception. This means finally always runs after try and catch, whether an error happened or not. Variables like 'a' do not get assigned if an exception occurs during their calculation. This flow helps ensure cleanup or important code runs no matter what.

Practice

1.

What is the main purpose of the finally block in Java exception handling?

easy

A. To catch exceptions thrown in the try block

B. To throw new exceptions

C. To execute code regardless of whether an exception occurs or not

D. To declare exceptions that a method can throw

Solution

1. Step 1: Understand the role of try-catch-finally

   The try block contains code that might throw exceptions, catch handles them, and finally runs code after both.

2. Step 2: Identify the purpose of finally

   The finally block always executes, whether an exception occurs or not, to finalize or clean up resources.

3. Final Answer:

   To execute code regardless of whether an exception occurs or not -> Option C

4. Quick Check:

   finally always runs = B [OK]

Hint: finally always runs after try/catch blocks [OK]

Common Mistakes:

• Thinking finally only runs if an exception occurs
• Confusing finally with catch block
• Assuming finally can catch exceptions

2.

Which of the following is the correct syntax to add a finally block after a try-catch in Java?

try {
    // code
} catch(Exception e) {
    // handle
} ??? {
    // cleanup
}

easy

A. finally

B. end

C. finalize

D. final

Solution

1. Step 1: Recall Java exception syntax

   Java uses the keyword finally to define the block that runs after try and catch.

2. Step 2: Match the correct keyword

   Among options, only finally is the valid keyword for this block.

3. Final Answer:

   finally -> Option A

4. Quick Check:

   finally keyword syntax = D [OK]

Hint: finally keyword always spelled 'finally' [OK]

Common Mistakes:

• Using 'final' instead of 'finally'
• Confusing with 'finalize' method
• Using invalid keywords like 'end'

3.

What will be the output of the following Java code?

public class Test {
    public static void main(String[] args) {
        try {
            System.out.print("Try-");
            return;
        } catch(Exception e) {
            System.out.print("Catch-");
        } finally {
            System.out.print("Finally");
        }
        System.out.print("End");
    }
}

medium

A. Try-Catch-End

B. Try-Catch-Finally-End

C. Try-End

D. Try-Finally

Solution

1. Step 1: Analyze try block execution

   The try block prints "Try-" and then returns, so normally method would exit here.

2. Step 2: Check finally block behavior with return

   Even with return, finally block executes, printing "Finally" before method exits.

3. Step 3: Confirm code after finally

   Code after finally (System.out.print("End")) is unreachable due to return, so not executed.

4. Final Answer:

   Try-Finally -> Option D

5. Quick Check:

   finally runs even after return = C [OK]

Hint: finally runs even if try returns early [OK]

Common Mistakes:

• Assuming code after finally runs after return
• Thinking catch block runs without exception
• Ignoring finally block execution

4.

Identify the error in the following code snippet:

try {
    int a = 5 / 0;
} finally {
    System.out.println("Cleanup");
}

medium

A. No error, code is valid

B. finally block cannot be used without catch

C. Syntax error in try block

D. Missing catch block for exception

Solution

1. Step 1: Check try-finally syntax rules

   Java allows try-finally without catch; try must be followed by catch or/and finally.

2. Step 2: Analyze exception handling

   Division by zero throws ArithmeticException at runtime, finally executes cleanup, then exception propagates to caller.

3. Step 3: Confirm no error

   The code compiles and runs validly (prints "Cleanup" before propagating exception); no syntax or structural error.

4. Final Answer:

   No error, code is valid -> Option A

5. Quick Check:

   try-finally valid without catch = D [OK]

Hint: try-finally without catch is valid [OK]

Common Mistakes:

• Thinking finally requires catch block
• Confusing runtime exception with syntax error
• Believing finally alone causes compile error

5.

Consider this method:

public static int test() {
    try {
        System.out.print("Try-");
        throw new RuntimeException();
    } catch(RuntimeException e) {
        System.out.print("Catch-");
        return 1;
    } finally {
        System.out.print("Finally-");
        return 2;
    }
}

What will System.out.print(test()); output?

hard

A. Try-Catch-Finally-1

B. Try-Catch-Finally-2

C. Try-Finally-2

D. Catch-Finally-1

Solution

1. Step 1: Trace try block execution

   Try prints "Try-" then throws RuntimeException.

2. Step 2: Catch block handles exception

   Catch prints "Catch-" and returns 1, but return is not final yet.

3. Step 3: finally block overrides return

   Finally prints "Finally-" and returns 2, overriding previous return 1.

4. Step 4: Combine printed output and return value

   Printed output is "Try-Catch-Finally-" and method returns 2, so print(test()) outputs "2" after prints.

5. Final Answer:

   Try-Catch-Finally-2 -> Option B

6. Quick Check:

   finally return overrides catch return = A [OK]

Hint: finally return overrides other returns [OK]

Common Mistakes:

• Ignoring finally return overriding catch return
• Assuming catch return is final
• Missing printed output before return