Finally block behavior in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of finally block with return in try

What is the output of this Kotlin code snippet?

Kotlin

fun test(): Int {
    try {
        return 1
    } finally {
        println("Finally block executed")
    }
}

fun main() {
    println(test())
}

A Compilation error

B

Finally block executed
1

C

Finally block executed
0

D

1
Finally block executed

💡 Hint

Remember that finally block runs even if try returns.

In Kotlin, the finally block always runs after the try block, even if the try block returns. So the println in finally executes before the returned value is printed.

❓ Predict Output

intermediate

Effect of exception and finally block

What will be printed when this Kotlin code runs?

Kotlin

fun test(): Int {
    try {
        throw Exception("Error")
    } finally {
        println("Finally block runs")
    }
}

fun main() {
    try {
        test()
    } catch (e: Exception) {
        println(e.message)
    }
}

A

Finally block runs
Error

B Finally block runs

C

Error
Finally block runs

D No output, program crashes

💡 Hint

Finally block runs even if exception is thrown.

The exception is thrown in try, but before propagating, finally block runs and prints its message. Then the exception is caught in main and its message is printed.

🔧 Debug

advanced

Why does this finally block not execute?

Consider this Kotlin code. Why does the finally block not print anything?

Kotlin

fun test(): Int {
    try {
        System.exit(0)
    } finally {
        println("Finally block executed")
    }
}

fun main() {
    test()
}

A Because println is inside try, not finally.

B Because finally block only runs if exception is thrown.

C Because System.exit terminates the JVM immediately, skipping finally.

D Because the code has a syntax error and does not compile.

💡 Hint

System.exit stops the program immediately.

System.exit(0) stops the whole program immediately, so the finally block is never reached or executed.

📝 Syntax

advanced

Identify the syntax error in finally usage

Which option contains a syntax error related to the finally block in Kotlin?

A try { println("Try") } catch (e: Exception) { println("Catch") } finally { println("Finally") }

B try { println("Try") } finally println("Finally")

C } )"yllaniF"(nltnirp { yllanif } )"hctaC"(nltnirp { )noitpecxE :e( hctac } )"yrT"(nltnirp { yrt

D try { println("Try") } catch (e: Exception) { println("Catch") } finally println("Finally")

💡 Hint

Finally block must be a block, not a single statement without braces if catch is present.

In Kotlin, if a finally block is present after a catch block, it must be a block enclosed in braces. Option D misses braces around finally block, causing syntax error.

🧠 Conceptual

expert

Finally block and variable modification with return

What is the output of this Kotlin code?

Kotlin

fun test(): Int {
    var x = 1
    try {
        return x
    } finally {
        x = 2
        println("Finally block: x = $x")
    }
}

fun main() {
    println("Returned value: ${test()}")
}

A

Finally block: x = 2
Returned value: 1

B

Finally block: x = 2
Returned value: 2

C

Returned value: 1
Finally block: x = 2

D Compilation error

💡 Hint

Return value is determined before finally block runs.

The return value is evaluated before finally block runs, so it returns the original x=1. The finally block changes x to 2 and prints it, but this does not affect the returned value.

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