Error handling patterns in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch an exception in Kotlin.

Android Kotlin

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

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

AString

BBoolean

CInt

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-exception types like String or Int in catch.

The Exception class is used to catch errors in Kotlin.

2fill in blank

medium

Complete the code to throw an exception when a condition is false.

Android Kotlin

fun checkAge(age: Int) {
    if (age < 18) {
        throw [1]("Age must be 18 or older")
    }
}

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

AIllegalArgumentException

BNullPointerException

CArrayIndexOutOfBoundsException

DIOException

Attempts:

3 left

💡 Hint

Common Mistakes

Using unrelated exceptions like IOException for argument checks.

IllegalArgumentException is used to indicate that a method has been passed an illegal or inappropriate argument.

3fill in blank

hard

Fix the error in the code to properly handle a nullable value with try-catch.

Android Kotlin

fun parseNumber(str: String?): Int {
    return try {
        str?.toInt() ?: throw [1]("Null string")
    } catch (e: NumberFormatException) {
        0
    }
}

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

AIOException

BIllegalArgumentException

CNullPointerException

DArithmeticException

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing unrelated exceptions like IOException for null checks.

NullPointerException is appropriate to throw when a null value is unexpected.

4fill in blank

hard

Fill both blanks to create a try-catch block that logs the error message.

Android Kotlin

try {
    val data = fetchData()
} catch (e: [1]) {
    Log.e("Error", e.[2])
}

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

AException

Bmessage

Ccause

DstackTrace

Attempts:

3 left

💡 Hint

Common Mistakes

Using cause or stackTrace instead of message for error text.

Catch Exception to handle errors, and use message to get the error description.

5fill in blank

hard

Fill all three blanks to define a custom exception class and throw it.

Android Kotlin

class [1](message: String) : [2](message)

fun test() {
    throw [3]("Custom error")
}

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

AMyException

BException

DThrowable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Throwable directly or mismatching class names.

Define a custom exception MyException that inherits from Exception and throw it.

Practice

1. What is the main purpose of a try-catch block in Kotlin error handling?

easy

A. To style the user interface

B. To speed up the app execution

C. To create new variables

D. To catch exceptions and prevent app crashes

Solution

1. Step 1: Understand the role of try-catch

   The try block contains code that might cause an error, and the catch block handles that error.

2. Step 2: Identify the purpose in app safety

   Using try-catch prevents the app from crashing by catching exceptions and allowing graceful handling.

3. Final Answer:

   To catch exceptions and prevent app crashes -> Option D

4. Quick Check:

   Error handling = catch exceptions [OK]

Hint: Try-catch blocks catch errors to keep apps running [OK]

Common Mistakes:

• Thinking try-catch speeds up code
• Confusing try-catch with UI styling
• Believing try-catch creates variables

2. Which of the following is the correct syntax to catch an exception in Kotlin?

easy

A. try { /* code */ } catch e { /* handle */ }

B. try { /* code */ } except (e: Exception) { /* handle */ }

C. try { /* code */ } catch (e: Exception) { /* handle */ }

D. try { /* code */ } catch Exception e { /* handle */ }

Solution

1. Step 1: Recall Kotlin catch syntax

   Kotlin requires parentheses around the exception variable with its type in the catch block.

2. Step 2: Compare options to correct syntax

   Only try { /* code */ } catch (e: Exception) { /* handle */ } uses catch (e: Exception) which is the correct Kotlin syntax.

3. Final Answer:

   try { /* code */ } catch (e: Exception) { /* handle */ } -> Option C

4. Quick Check:

   Correct catch syntax = try { /* code */ } catch (e: Exception) { /* handle */ } [OK]

Hint: Catch needs parentheses with exception type [OK]

Common Mistakes:

• Omitting parentheses in catch
• Using 'except' instead of 'catch'
• Wrong order of exception and variable

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

fun main() {
  try {
    val result = 10 / 0
    println("Result: $result")
  } catch (e: ArithmeticException) {
    println("Caught an arithmetic error")
  } finally {
    println("Done")
  }
}

medium

A. Caught an arithmetic error\nDone

B. Done

C. Exception thrown, app crashes

D. Result: 0\nDone

Solution

1. Step 1: Identify the error in try block

   Dividing 10 by 0 causes an ArithmeticException.

2. Step 2: Check catch and finally behavior

   The catch block catches the exception and prints the message. The finally block always runs and prints "Done".

3. Final Answer:

   Caught an arithmetic error\nDone -> Option A

4. Quick Check:

   Catch runs on error, finally always runs [OK]

Hint: Catch handles error, finally always runs [OK]

Common Mistakes:

• Assuming division by zero prints result
• Ignoring finally block output
• Thinking app crashes without catch

4. Identify the error in this Kotlin code snippet:

try {
  val text: String = null
  println(text.length)
} catch (e: NullPointerException) {
  println("Null pointer caught")
}

medium

A. Code will not compile due to null assignment

B. Accessing length of null causes a crash

C. NullPointerException is not caught correctly

D. No error, code runs fine

Solution

1. Step 1: Analyze null assignment in Kotlin

   Kotlin does not allow assigning null to a non-nullable type without using nullable type syntax.

2. Step 2: Check compilation rules

   Assigning null to val text without declaring it nullable causes a compile-time error.

3. Final Answer:

   Code will not compile due to null assignment -> Option A

4. Quick Check:

   Null safety requires nullable types [OK]

Hint: Null must be assigned to nullable type with ? [OK]

Common Mistakes:

• Assuming NullPointerException is caught at runtime
• Ignoring Kotlin's null safety rules
• Thinking code runs without error

5. You want to read a file and always close it after reading, even if an error occurs. Which Kotlin error handling pattern is best to ensure the file closes properly?

hard

A. Use try block only

B. Use try-catch-finally and close file in finally

C. Use try-catch without finally

D. Use only finally block

Solution

1. Step 1: Understand resource cleanup needs

   Files must be closed to free resources, even if an error happens during reading.

2. Step 2: Use finally block for guaranteed execution

   The finally block runs no matter what, so closing the file there ensures cleanup.

3. Step 3: Combine with try-catch for error handling

   Try-catch handles errors, finally ensures file closure regardless of success or failure.

4. Final Answer:

   Use try-catch-finally and close file in finally -> Option B

5. Quick Check:

   Finally block ensures cleanup [OK]

Hint: Put cleanup code in finally block to always run [OK]

Common Mistakes:

• Closing file only in try block
• Ignoring finally block for cleanup
• Using finally without try-catch