Multiple catch blocks in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of multiple catch blocks with specific exceptions

What is the output of this Kotlin code with multiple catch blocks?

Kotlin

fun main() {
    try {
        val num = "abc".toInt()
    } catch (e: NumberFormatException) {
        println("Number format error")
    } catch (e: Exception) {
        println("General error")
    }
}

A No output

B General error

C Number format error

D Compilation error

💡 Hint

The exception thrown is a NumberFormatException, which is caught by the first catch block.

The code tries to convert a non-numeric string to an integer, which throws NumberFormatException. The first catch block matches this exception and prints "Number format error". The second catch block is not reached.

❓ Predict Output

intermediate

Which catch block handles the exception?

Consider this Kotlin code snippet. Which catch block will handle the exception thrown?

Kotlin

fun main() {
    try {
        val arr = arrayOf(1, 2, 3)
        println(arr[5])
    } catch (e: NullPointerException) {
        println("Null pointer exception")
    } catch (e: ArrayIndexOutOfBoundsException) {
        println("Array index out of bounds")
    } catch (e: Exception) {
        println("General exception")
    }
}

A Array index out of bounds

B Null pointer exception

C General exception

D No exception caught

💡 Hint

Accessing an invalid array index throws ArrayIndexOutOfBoundsException.

The code tries to access index 5 in an array of size 3, which throws ArrayIndexOutOfBoundsException. The second catch block matches this exception and prints "Array index out of bounds".

❓ Predict Output

advanced

Multiple catch blocks with ArithmeticException

What is the output of this Kotlin code?

Kotlin

fun main() {
    try {
        val x = 10 / 0
    } catch (e: ArithmeticException) {
        println("Arithmetic error")
    } catch (e: Exception) {
        println("General error")
    } catch (e: Throwable) {
        println("Throwable caught")
    }
}

A Prints "Arithmetic error"

B Runtime error: division by zero not caught

C Prints "General error"

D Compilation error: unreachable catch block

💡 Hint

Division by zero throws ArithmeticException, caught by the first block. The order specific to general is valid.

The division 10 / 0 throws an ArithmeticException, caught by the first catch block, printing "Arithmetic error". The catch blocks are ordered correctly from most specific (ArithmeticException subclass of Exception subclass of Throwable), so no compilation error. Subsequent blocks are not reached.

❓ Predict Output

advanced

Output when multiple exceptions could match

What will this Kotlin program print?

Kotlin

fun main() {
    try {
        val s: String? = null
        println(s!!.length)
    } catch (e: NullPointerException) {
        println("Null pointer caught")
    } catch (e: Exception) {
        println("Exception caught")
    }
}

A Exception caught

B Compilation error

C No output

D Null pointer caught

💡 Hint

The !! operator throws NullPointerException if the value is null.

The code tries to access length of a null string using !!, which throws NullPointerException. The first catch block matches and prints "Null pointer caught".

🧠 Conceptual

expert

Order of catch blocks and exception hierarchy

Given the following Kotlin exception hierarchy: Throwable > Exception > IOException > FileNotFoundException, which order of catch blocks is correct to catch exceptions from most specific to most general?

A catch (e: Exception), catch (e: IOException), catch (e: FileNotFoundException), catch (e: Throwable)

B catch (e: FileNotFoundException), catch (e: IOException), catch (e: Exception), catch (e: Throwable)

C catch (e: Throwable), catch (e: Exception), catch (e: IOException), catch (e: FileNotFoundException)

D catch (e: IOException), catch (e: FileNotFoundException), catch (e: Exception), catch (e: Throwable)

💡 Hint

Catch blocks must go from the most specific exception to the most general.

The correct order is from the most specific subclass to the most general superclass: FileNotFoundException (most specific), IOException, Exception, Throwable (most general). This ensures each catch block is reachable.