Why error handling matters in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code with try-catch?

Look at this Kotlin code. What will it print?

Kotlin

fun main() {
    val numbers = listOf(1, 2, 0, 4)
    for (num in numbers) {
        try {
            val result = 10 / num
            println("Result: $result")
        } catch (e: ArithmeticException) {
            println("Cannot divide by zero")
        }
    }
}

A

Result: 10
Result: 5
Result: 0
Result: 2

B

Result: 10
Result: 5
Cannot divide by zero
Result: 2

C

Result: 10
Result: 5
Exception in thread "main" java.lang.ArithmeticException: / by zero

D

Cannot divide by zero
Result: 10
Result: 5
Result: 2

💡 Hint

Think about what happens when dividing by zero inside the try block.

The code tries to divide 10 by each number. When it reaches zero, it throws an ArithmeticException, which is caught and prints "Cannot divide by zero". Other divisions print the result.

🧠 Conceptual

intermediate

Why should programs handle errors?

Why is it important for programs to handle errors properly?

A To prevent the program from crashing and provide meaningful feedback to users

B To make the program run faster by skipping error checks

C To hide all errors so users never know something went wrong

D To make the code shorter and simpler

💡 Hint

Think about user experience and program stability.

Handling errors prevents crashes and helps users understand what went wrong, improving reliability and user trust.

🔧 Debug

advanced

Identify the error in this Kotlin error handling code

Find the mistake in this Kotlin code that tries to handle exceptions.

Kotlin

fun main() {
    try {
        val text = "abc"
        val number = text.toInt()
        println(number)
    } catch (e: NumberFormatException) {
        println("Conversion failed")
    } catch (e: Exception) {
        println("General error")
    } catch (e: Throwable) {
        println("Unknown error")
    }
}

A The code will cause a compile error because toInt() is unsafe

B The code is correct and will print "Conversion failed"

C The catch blocks are in the wrong order; Throwable should be last

D The catch blocks should be combined into one catch block

💡 Hint

Think about the order of catch blocks from specific to general exceptions.

In Kotlin, catch blocks must be ordered from most specific to most general. Throwable is the base class and should be last. Otherwise, the compiler will error.

📝 Syntax

advanced

What error does this Kotlin code produce?

What error will this Kotlin code cause?

Kotlin

fun main() {
    try {
        val list = listOf(1, 2, 3)
        println(list[5])
    } catch (e: IndexOutOfBoundsException) {
        println("Index error caught")
    } catch (e: Exception) {
        println("Other error")
    }
}

A Index error caught

B Other error

C No output, program crashes

D Syntax error: missing colon in catch

💡 Hint

What happens when you access an invalid list index?

Accessing list[5] throws IndexOutOfBoundsException, which is caught and prints "Index error caught".

🚀 Application

expert

What is the value of 'result' after this Kotlin function runs?

Consider this Kotlin function that handles errors. What will be the value of result after calling safeDivide(10, 0)?

Kotlin

fun safeDivide(a: Int, b: Int): Int {
    return try {
        a / b
    } catch (e: ArithmeticException) {
        -1
    } finally {
        println("Operation attempted")
    }
}

fun main() {
    val result = safeDivide(10, 0)
    println("Result is $result")
}

A 10

B 0

C Exception thrown, no value returned

D -1

💡 Hint

Remember what the catch block returns and how finally works.

The division by zero throws ArithmeticException, caught and returns -1. The finally block runs but does not change the return value.