Multiple catch blocks in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of multiple catch blocks in Kotlin?

Multiple catch blocks allow you to handle different types of exceptions separately, so you can respond appropriately to each error type.

beginner

How do you write multiple catch blocks in Kotlin?

You write multiple catch blocks by placing several catch clauses after a try block, each catching a different exception type.

intermediate

What happens if an exception does not match any catch block?

If no catch block matches the exception type, the exception will propagate up the call stack and may crash the program if not handled elsewhere.

intermediate

Can you catch multiple exception types in a single catch block in Kotlin?

No, Kotlin does not support catching multiple exception types in a single catch block using the union operator (|). You need to use separate catch blocks for each exception type.

beginner

Example: What will this Kotlin code print?

try {
  val num = "abc".toInt()
} catch (e: NumberFormatException) {
  println("Number format error")
} catch (e: Exception) {
  println("General error")
}

It will print "Number format error" because the exception thrown is NumberFormatException, which matches the first catch block.

What is the correct way to handle different exceptions in Kotlin?

A Use multiple catch blocks after a try block

B Use one catch block with multiple exception types separated by commas

C Use if statements inside a single catch block

D Use a finally block only

Kotlin uses multiple catch blocks to handle different exceptions separately.

If an exception is not caught by any catch block, what happens?

A The program continues normally

B The exception is ignored

C The exception propagates up and may crash the program

D The finally block catches it automatically

Uncaught exceptions propagate up the call stack and can crash the program if not handled.

Which catch block will handle a NullPointerException if you have these catch blocks? 1) catch (e: IOException) 2) catch (e: Exception)

A Both

B catch (e: IOException)

C Neither

D catch (e: Exception)

NullPointerException is a subclass of Exception, so the second catch block will handle it.

Can you reorder catch blocks arbitrarily in Kotlin?

A No, more specific exceptions should come before general ones

B Yes, order does not matter

C No, general exceptions should come before specific ones

D Yes, but only if you use finally

More specific exceptions must come before general ones to avoid unreachable code.

What keyword starts a block where exceptions are caught in Kotlin?

A catch

B try

C throw

D finally

The try keyword starts the block where exceptions might be thrown and caught.

Explain how multiple catch blocks work in Kotlin and why their order matters.

Think about catching specific exceptions before general ones.

Describe what happens when an exception is thrown inside a try block and how Kotlin decides which catch block to run.

Focus on how Kotlin matches exception types to catch blocks.

Practice

1. What is the main purpose of using multiple catch blocks in Kotlin?

easy

A. To avoid using the try keyword

B. To run multiple try blocks at once

C. To handle different types of exceptions separately

D. To make the program run faster

Solution

1. Step 1: Understand exception handling

   Multiple catch blocks allow handling different exceptions in different ways.

2. Step 2: Compare options

   Only To handle different types of exceptions separately correctly describes handling different exception types separately.

3. Final Answer:

   To handle different types of exceptions separately -> Option C

4. Quick Check:

   Multiple catch blocks = handle exceptions separately [OK]

Hint: Remember: each catch handles one exception type [OK]

Common Mistakes:

• Thinking multiple catch blocks run in parallel
• Believing catch blocks replace try
• Assuming multiple catch blocks speed up code

2. Which of the following is the correct syntax for multiple catch blocks in Kotlin?

easy

A. try { /* code */ } catch (e: IOException) { } catch (e: Exception) { }

B. try { /* code */ } catch IOException { } catch Exception { }

C. try { /* code */ } catch e: IOException { } catch e: Exception { }

D. try { /* code */ } catch (IOException e) { } catch (Exception e) { }

Solution

1. Step 1: Recall Kotlin catch syntax

   Kotlin requires parentheses around the exception variable and type, like catch (e: Exception).

2. Step 2: Check each option

   Only try { /* code */ } catch (e: IOException) { } catch (e: Exception) { } uses correct Kotlin syntax with parentheses and colon for type.

3. Final Answer:

   try { /* code */ } catch (e: IOException) { } catch (e: Exception) { } -> Option A

4. Quick Check:

   Kotlin catch syntax = catch (e: Type) [OK]

Hint: Use parentheses and colon for exception type in catch [OK]

Common Mistakes:

• Omitting parentheses in catch
• Using Java-style catch syntax
• Missing colon between variable and type

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

try {
  val num = "abc".toInt()
} catch (e: NumberFormatException) {
  println("Number format error")
} catch (e: Exception) {
  println("General error")
}

medium

A. Compilation error

B. General error

C. No output

D. Number format error

Solution

1. Step 1: Identify exception thrown

   Calling "abc".toInt() throws NumberFormatException.

2. Step 2: Match catch block

   The first catch block matches NumberFormatException, so it runs and prints "Number format error".

3. Final Answer:

   Number format error -> Option D

4. Quick Check:

   NumberFormatException caught first = prints message [OK]

Hint: Specific exceptions catch before general ones [OK]

Common Mistakes:

• Assuming general catch runs first
• Thinking no exception occurs
• Confusing exception types

4. Find the error in this Kotlin code snippet:

try {
  val list = listOf(1, 2, 3)
  println(list[5])
} catch (e: Exception) {
  println("Error caught")
} catch (e: IndexOutOfBoundsException) {
  println("Index error")
}

medium

A. Missing finally block

B. Catch blocks are in wrong order; specific exception should come first

C. Index 5 is valid, no exception thrown

D. Try block syntax is incorrect

Solution

1. Step 1: Understand catch block order

   Specific exceptions must come before general ones to be reachable.

2. Step 2: Analyze given order

   The general Exception catch is before IndexOutOfBoundsException, so the latter is unreachable, causing a compile error.

3. Final Answer:

   Catch blocks are in wrong order; specific exception should come first -> Option B

4. Quick Check:

   Specific catch before general catch [OK]

Hint: Put specific exceptions before general ones [OK]

Common Mistakes:

• Placing general catch before specific catch
• Ignoring unreachable catch block error
• Assuming finally is mandatory

5. You want to handle FileNotFoundException and IOException differently in Kotlin. Which catch block order is correct?

try {
  // file operations
} catch (e: IOException) {
  println("IO error")
} catch (e: FileNotFoundException) {
  println("File not found")
}

hard

A. Swap catch blocks: FileNotFoundException first, then IOException

B. This order is correct; IOException first, then FileNotFoundException

C. Combine both exceptions in one catch block

D. Remove catch blocks and use only finally

Solution

1. Step 1: Understand exception hierarchy

   FileNotFoundException is a subclass of IOException.

2. Step 2: Determine catch order

   The specific subclass FileNotFoundException must be caught before the general IOException to avoid unreachable code.

3. Final Answer:

   Swap catch blocks: FileNotFoundException first, then IOException -> Option A

4. Quick Check:

   Subclass catch before superclass catch [OK]

Hint: Catch subclasses before superclasses [OK]

Common Mistakes:

• Catching superclass before subclass
• Combining unrelated exceptions incorrectly
• Skipping specific exception handling