Error handling patterns in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

Handling Null Pointer Exception in Kotlin Android

What will be the output when this Kotlin Android code runs and the nullable variable is null?

Android Kotlin

val userName: String? = null
val displayName = userName!!.length
println("Length: $displayName")

A Throws KotlinNullPointerException at runtime

B Prints: Length: 0

C Prints: Length: null

D Compilation error due to null safety

💡 Hint

The double exclamation mark (!!) forces a non-null assertion.

Using !! on a null value causes KotlinNullPointerException at runtime.

🧠 Conceptual

intermediate

Try-Catch Block Behavior in Kotlin Android

What is the output of this Kotlin code snippet in Android when an exception occurs inside the try block?

Android Kotlin

try {
  val result = 10 / 0
  println("Result: $result")
} catch (e: ArithmeticException) {
  println("Caught division by zero")
} finally {
  println("Finally block executed")
}

A Result: 0\nFinally block executed

B Only Finally block executed

C Caught division by zero\nFinally block executed

D Runtime crash without any output

💡 Hint

Division by zero throws ArithmeticException.

The exception is caught and handled, then finally block runs.

❓ lifecycle

advanced

Exception Handling in Android Activity Lifecycle

If an exception is thrown inside onCreate() of an Android Activity and not caught, what happens?

A Exception is logged but app continues normally

B Exception is silently ignored and activity continues

C Activity restarts automatically without user notice

D App crashes and shows a crash dialog

💡 Hint

Uncaught exceptions in lifecycle methods cause app crashes.

Android does not catch uncaught exceptions in lifecycle methods; app crashes.

📝 Syntax

advanced

Correct Kotlin Syntax for Catching Multiple Exceptions

Which Kotlin code snippet correctly catches both IOException and NumberFormatException in Android?

Android Kotlin

fun parseData() {
  try {
    // code that may throw exceptions
  } catch (e: IOException, e: NumberFormatException) {
    println("Exception caught")
  }
}

A catch (e: IOException) { println("Exception caught") } catch (e: NumberFormatException) { println("Exception caught") }

B catch (e: IOException | NumberFormatException) { println("Exception caught") }

C catch (e: Exception) { if (e is IOException || e is NumberFormatException) println("Exception caught") }

D catch (e: IOException, e: NumberFormatException) { println("Exception caught") }

💡 Hint

Kotlin does not support multiple exception types in one catch clause.

Kotlin requires separate catch blocks for different exception types.

🔧 Debug

expert

Diagnosing Silent Failure in Coroutine Exception Handling

In this Kotlin coroutine code, why does the exception not crash the app or print the error message?

Android Kotlin

GlobalScope.launch {
  try {
    throw IllegalStateException("Error in coroutine")
  } catch (e: Exception) {
    // empty catch block
  }
}
println("Coroutine launched")

A GlobalScope.launch requires explicit supervisor to catch exceptions

B Exception is caught but ignored due to empty catch block

C Coroutine does not support exceptions so it fails silently

D Exception is thrown on main thread causing crash before catch

💡 Hint

Empty catch blocks swallow exceptions silently.

The exception is caught but nothing is done, so no error is shown.

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