Error handling patterns in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a try-catch block used for in Kotlin Android development?

A try-catch block is used to handle exceptions that might occur during code execution, preventing the app from crashing and allowing graceful error recovery.

intermediate

What does the finally block do in Kotlin error handling?

The finally block contains code that always runs after try and catch blocks, whether an exception occurred or not. It's often used to clean up resources like closing files or network connections.

intermediate

Explain the difference between checked and unchecked exceptions in Kotlin Android.

Kotlin does not have checked exceptions like Java. All exceptions are unchecked, meaning the compiler does not force you to catch or declare them. You decide where to handle exceptions.

advanced

What is the purpose of using sealed classes for error handling in Kotlin?

Sealed classes let you define a fixed set of error types, making it easier to <strong>handle different error cases explicitly</strong> with when expressions, improving code safety and readability.

intermediate

Why should you avoid catching generic Exception in Android apps?

Catching generic Exception can hide unexpected errors and make debugging harder. It's better to catch specific exceptions to handle known error cases clearly and avoid masking bugs.

Which Kotlin keyword is used to catch exceptions?

A throw

B handle

C try

D catch

The catch block is used to catch exceptions thrown in the try block.

What block runs regardless of whether an exception occurs or not?

A catch

B finally

C try

D throw

The finally block always runs after try and catch blocks.

In Kotlin, are exceptions checked or unchecked?

A Unchecked

B Checked

C Both

D Neither

Kotlin exceptions are unchecked, so the compiler does not force handling them.

What Kotlin feature helps define a fixed set of error types?

A Data classes

B Interfaces

C Sealed classes

D Enums

Sealed classes allow defining a closed set of subclasses, useful for error types.

Why avoid catching generic Exception in Android apps?

A It hides unexpected errors

B It improves performance

C It is required by Kotlin

D It prevents all crashes

Catching generic Exception can hide bugs and make debugging difficult.

Describe how you would use try-catch-finally blocks to handle errors in an Android Kotlin app.

Think about what code might fail, how to catch errors, and cleaning up resources.

Explain the benefits of using sealed classes for error handling compared to just using exceptions.

Consider how sealed classes help organize and handle errors explicitly.

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