Finally block behavior in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the finally block in Kotlin?

The finally block is used to execute code that must run regardless of whether an exception was thrown or caught. It is typically used for cleanup tasks like closing files or releasing resources.

beginner

When does the finally block execute in Kotlin?

The finally block executes after the try and catch blocks finish, no matter if an exception occurred or not.

intermediate

Can the finally block override a return statement in the try or catch block?

Yes, if the finally block contains a return statement, it will override any previous return from the try or catch blocks, which can lead to unexpected behavior.

advanced

What happens if an exception is thrown inside the finally block?

If an exception is thrown inside the finally block, it will replace any exception thrown in the try or catch blocks, potentially hiding the original exception.

beginner

Write a simple Kotlin code snippet showing a try-catch-finally structure.

fun example() { try { println("In try block") val result = 10 / 0 // This will throw an exception } catch (e: ArithmeticException) { println("Caught exception: ${e.message}") } finally { println("This runs no matter what") } }

When does the finally block run in Kotlin exception handling?

A Always, after try and catch blocks

B Only if an exception is thrown

C Only if no exception is thrown

D Never

The finally block always runs after the try and catch blocks, regardless of exceptions.

What happens if there is a return statement in both try and finally blocks?

A The return in finally block is ignored, try's return is used

B The return in try block is ignored, finally's return is used

C Both returns execute and return the sum

D Compilation error

The finally block's return overrides the try block's return, which can cause unexpected results.

If an exception is thrown in the finally block, what happens to an exception thrown in the try block?

A No exception is thrown

B Both exceptions are thrown together

C The finally block's exception replaces the try block's exception

D The try block's exception is thrown, finally's is ignored

An exception in finally replaces any exception from try or catch blocks.

Is the finally block mandatory in Kotlin's try-catch structure?

A No, it's optional

B Yes, always required

C Only if catch is present

D Only if try block throws exception

The finally block is optional and used only when cleanup or guaranteed execution is needed.

Which of these is a good use case for a finally block?

A Handling specific exceptions

B Returning values

C Declaring variables

D Closing a file or releasing resources

Finally blocks are ideal for cleanup tasks like closing files or releasing resources.

Explain the role and behavior of the finally block in Kotlin exception handling.

Think about what must always happen after trying code, no matter what.

Describe what happens when a return statement is present in both try and finally blocks in Kotlin.

Consider which return value the function actually sends back.

Practice

1.

What is the main purpose of the finally block in Kotlin?

easy

A. To execute code that must run regardless of exceptions

B. To catch exceptions thrown in the try block

C. To declare variables used in try block

D. To stop program execution immediately

Solution

1. Step 1: Understand the role of finally

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

2. Step 2: Identify its main use

   It is used to run cleanup code like closing files or releasing resources, always executing even if exceptions occur.

3. Final Answer:

   To execute code that must run regardless of exceptions -> Option A

4. Quick Check:

   finally always runs = A [OK]

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

Common Mistakes:

• Confusing finally with catch block
• Thinking finally only runs if no exception
• Believing finally stops program execution

2.

Which of the following is the correct syntax for a try-catch-finally block in Kotlin?

?

easy

A. catch (e: Exception) { /* handle */ } try { /* code */ } finally { /* cleanup */ }

B. try { /* code */ } finally { /* cleanup */ } catch (e: Exception) { /* handle */ }

C. try { /* code */ } catch { /* handle */ } finally { /* cleanup */ }

D. try { /* code */ } catch (e: Exception) { /* handle */ } finally { /* cleanup */ }

Solution

1. Step 1: Recall Kotlin try-catch-finally order

   The correct order is try, then catch, then finally.

2. Step 2: Check syntax correctness

   try { /* code */ } catch (e: Exception) { /* handle */ } finally { /* cleanup */ } follows the correct order and syntax with exception type in catch.

3. Final Answer:

   try { /* code */ } catch (e: Exception) { /* handle */ } finally { /* cleanup */ } -> Option D

4. Quick Check:

   try-catch-finally order = C [OK]

Hint: Remember order: try, catch, then finally [OK]

Common Mistakes:

• Placing finally before catch
• Omitting exception type in catch
• Starting with catch block

3.

What will be the output of the following Kotlin code?

fun test(): Int {
    try {
        println("Try block")
        return 1
    } catch (e: Exception) {
        println("Catch block")
        return 2
    } finally {
        println("Finally block")
    }
}

fun main() {
    println("Result: ${test()}")
}

medium

A. Try block
Finally block
Result: 1

B. Try block
Result: 1

C. Try block
Catch block
Finally block
Result: 2

D. Finally block
Result: 1

Solution

1. Step 1: Trace the try block execution

   The try block prints "Try block" and returns 1, but before returning, finally runs.

2. Step 2: Understand finally block behavior with return

   The finally block prints "Finally block" before the function returns the value 1.

3. Final Answer:

   Try block Finally block Result: 1 -> Option A

4. Quick Check:

   finally runs before return = A [OK]

Hint: finally runs even if return happens in try [OK]

Common Mistakes:

• Ignoring finally output when return is in try
• Assuming catch runs without exception
• Thinking finally runs after return prints

4.

Identify the error in this Kotlin code snippet:

fun example() {
    try {
        println("Inside try")
    } finally {
        println("Inside finally")
    } catch (e: Exception) {
        println("Inside catch")
    }
}

medium

A. "catch" block must come before "finally" block

B. "finally" block must come after "catch" block

C. "catch" block cannot be used without "try"

D. No error, code is correct

Solution

1. Step 1: Check order of try-catch-finally

   The correct order is try, then catch, then finally. Here finally comes before catch, which is invalid.

2. Step 2: Identify correct placement

   The finally block must always come after all catch blocks.

3. Final Answer:

   "finally" block must come after "catch" block -> Option B

4. Quick Check:

   finally after catch = D [OK]

Hint: Catch comes before finally in try-catch-finally [OK]

Common Mistakes:

• Placing finally before catch
• Thinking catch can be after finally
• Ignoring syntax order rules

5.

Consider this Kotlin function:

fun compute(): Int {
    try {
        return 10
    } finally {
        return 20
    }
}

What will compute() return and why?

hard

A. 10, because the first return in try is used

B. Compilation error due to multiple returns

C. 20, because finally's return overrides try's return

D. 0, because finally resets the return value

Solution

1. Step 1: Analyze return in try block

   The try block returns 10, but before returning, finally executes.

2. Step 2: Understand return in finally block

   The finally block also has a return statement, which overrides the previous return from try.

3. Final Answer:

   20, because finally's return overrides try's return -> Option C

4. Quick Check:

   Return in finally overrides try return = B [OK]

Hint: Return in finally overrides any previous return [OK]

Common Mistakes:

• Assuming first return always wins
• Thinking multiple returns cause error
• Ignoring finally's effect on return