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.

Practice

1. Why is error handling important in Kotlin programs?

easy

A. It helps keep the program running smoothly even when errors occur.

B. It makes the program run faster by skipping checks.

C. It removes the need to write any code for errors.

D. It automatically fixes all bugs without programmer input.

Solution

1. Step 1: Understand the purpose of error handling

   Error handling is used to manage unexpected problems during program execution.

2. Step 2: Identify the benefit of error handling

   It helps the program continue running safely and informs the user about issues.

3. Final Answer:

   It helps keep the program running smoothly even when errors occur. -> Option A

4. Quick Check:

   Error handling = program safety and stability [OK]

Hint: Error handling keeps programs safe and user-friendly [OK]

Common Mistakes:

• Thinking error handling speeds up code
• Believing error handling fixes bugs automatically
• Assuming error handling removes all code for errors

2. Which Kotlin syntax correctly starts a block to catch exceptions?

easy

A. catch (Exception e) { ... } try { ... }

B. try { ... } catch (e: Exception) { ... }

C. try (e: Exception) { ... } catch { ... }

D. catch { ... } try (e: Exception) { ... }

Solution

1. Step 1: Recall Kotlin error handling syntax

   Kotlin uses try to start a block and catch (e: Exception) to handle errors.

2. Step 2: Match syntax to options

   try { ... } catch (e: Exception) { ... } correctly shows try { ... } catch (e: Exception) { ... }.

3. Final Answer:

   try { ... } catch (e: Exception) { ... } -> Option B

4. Quick Check:

   Correct try-catch syntax = try { ... } catch (e: Exception) { ... } [OK]

Hint: Try starts block, catch handles exceptions with (e: Exception) [OK]

Common Mistakes:

• Swapping try and catch order
• Using parentheses incorrectly
• Using Java-style catch syntax in Kotlin

3. What will be the output of this Kotlin code?

fun main() {
  try {
    val result = 10 / 0
    println(result)
  } catch (e: ArithmeticException) {
    println("Error caught: Division by zero")
  }
}

medium

A. 10

B. Program crashes with exception

C. 0

D. Error caught: Division by zero

Solution

1. Step 1: Analyze the try block

   The code attempts to divide 10 by 0, which causes an ArithmeticException.

2. Step 2: Check the catch block

   The catch block catches ArithmeticException and prints the error message.

3. Final Answer:

   Error caught: Division by zero -> Option D

4. Quick Check:

   Division by zero triggers catch = prints error message [OK]

Hint: Division by zero triggers catch block printing error [OK]

Common Mistakes:

• Expecting program to print 10 or 0
• Thinking program crashes without catch
• Ignoring exception type in catch

4. Identify the error in this Kotlin code snippet:

fun main() {
  try {
    val text = "abc"
    val number = text.toInt()
  } catch e: NumberFormatException {
    println("Invalid number")
  }
}

medium

A. Missing parentheses around exception in catch block

B. Using toInt() on a string is not allowed

C. try block should not have braces

D. println statement is outside catch block

Solution

1. Step 1: Check catch block syntax

   Kotlin requires parentheses around the exception in catch: catch (e: Exception).

2. Step 2: Identify the error

   The code uses catch e: NumberFormatException without parentheses, causing syntax error.

3. Final Answer:

   Missing parentheses around exception in catch block -> Option A

4. Quick Check:

   Catch syntax needs parentheses [OK]

Hint: Catch exception must be in parentheses (e: Exception) [OK]

Common Mistakes:

• Omitting parentheses in catch
• Thinking toInt() is invalid on strings
• Misplacing println outside catch

5. You want to read an integer from user input safely in Kotlin. Which approach best handles invalid input without crashing?

fun readInt(): Int {
  // Your code here
}

hard

A. Use if (readLine() is Int) return readLine()!! else return 0

B. Directly call readLine()!!.toInt() without try-catch

C. Use try { readLine()!!.toInt() } catch (e: Exception) { 0 } to return 0 on error

D. Ignore errors and assume input is always valid

Solution

1. Step 1: Understand safe input reading

   Using try-catch allows catching exceptions from invalid input conversion.

2. Step 2: Evaluate options

   Use try { readLine()!!.toInt() } catch (e: Exception) { 0 } to return 0 on error uses try-catch to convert input safely and returns 0 if conversion fails.

3. Final Answer:

   Use try { readLine()!!.toInt() } catch (e: Exception) { 0 } to return 0 on error -> Option C

4. Quick Check:

   Try-catch safely handles input errors [OK]

Hint: Wrap input conversion in try-catch to avoid crashes [OK]

Common Mistakes:

• Not using try-catch for input conversion
• Assuming input is always valid
• Using incorrect type checks on readLine()