Why error handling matters in Kotlin - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch an exception and print a message.

Kotlin

try {
    val result = 10 / [1]
    println("Result: $result")
} catch (e: Exception) {
    println("Error occurred")
}

Drag options to blanks, or click blank then click option'

A0

Bnull

C2

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-zero number won't cause an error here.

Dividing by zero causes an exception, so catching it shows why error handling matters.

2fill in blank

medium

Complete the code to throw an exception when input is negative.

Kotlin

fun checkNumber(num: Int) {
    if (num < [1]) {
        throw IllegalArgumentException("Negative number not allowed")
    }
}

Drag options to blanks, or click blank then click option'

A10

B1

C-1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 or -1 changes the condition meaning.

We check if the number is less than zero to detect negative numbers.

3fill in blank

hard

Fix the error in the catch block to print the exception message.

Kotlin

try {
    val data = "abc".toInt()
} catch (e: Exception) {
    println(e[1])
}

Drag options to blanks, or click blank then click option'

A.message()

B.message

C.getMessage()

D.toString()

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses causes a syntax error.

In Kotlin, exception messages are accessed with the property message without parentheses.

4fill in blank

hard

Fill both blanks to handle a NumberFormatException and print a custom message.

Kotlin

try {
    val num = "abc".toInt()
} catch (e: [1]) {
    println("[2]")
}

Drag options to blanks, or click blank then click option'

ANumberFormatException

BIllegalArgumentException

CNullPointerException

DArithmeticException

Attempts:

3 left

💡 Hint

Common Mistakes

Catching wrong exception types.

We catch NumberFormatException and print a message explaining the error.

5fill in blank

hard

Fill all three blanks to create a function that safely parses an integer or returns null.

Kotlin

fun safeParseInt(str: String): Int? {
    return try {
        str[1]toInt()
    } catch (e: [2]) {
        [3]
    }
}

Drag options to blanks, or click blank then click option'

A.

BNumberFormatException

Cnull

D!!

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong exception type or returning wrong value.

The dot operator calls toInt(). We catch NumberFormatException and return null if parsing fails.

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()