Multiple catch blocks in Kotlin - Mini Project: Build & Apply

Handling Exceptions with Multiple Catch Blocks in Kotlin

📖 Scenario: Imagine you are writing a small Kotlin program that reads numbers from a list and divides 100 by each number. Sometimes, the numbers might cause errors like division by zero or invalid input. You want to handle these errors properly.

🎯 Goal: You will create a Kotlin program that uses multiple catch blocks to handle different types of exceptions separately.

📋 What You'll Learn

Create a list of integers with the exact values: 10, 0, 5, -2

Create a variable called result to store the division result

Use a try block to divide 100 by each number in the list

Use multiple catch blocks to handle ArithmeticException and Exception

Print the result or the error message for each division

💡 Why This Matters

🌍 Real World

Handling different errors separately helps programs run smoothly without crashing. For example, apps that process user input or files often need multiple catch blocks.

💼 Career

Understanding exception handling with multiple catch blocks is important for writing robust Kotlin applications in software development jobs.

1

Create the list of numbers

Create a list called numbers with these exact integer values: 10, 0, 5, and -2.

Kotlin

# Create the list of numbers
# Your code here

Hint

Use listOf() to create a list with the given numbers.

2

Create a variable to store the result

Create a variable called result of type Int and initialize it to 0.

Kotlin

val numbers = listOf(10, 0, 5, -2)
# Create a variable called result and set it to 0
# Your code here

Hint

Use var to create a variable that can change later.

3

Use try and multiple catch blocks to handle exceptions

Write a for loop that goes through each number in numbers. Inside the loop, use a try block to divide 100 by the number and store it in result. Add two catch blocks: one for ArithmeticException and one for general Exception. In each catch, print a message describing the error.

Kotlin

val numbers = listOf(10, 0, 5, -2)
var result: Int = 0
# Write a for loop to process each number
# Use try to divide 100 by the number
# Add catch blocks for ArithmeticException and Exception
# Your code here

Hint

Remember to use for (number in numbers) to loop. Use try to attempt division. Catch ArithmeticException first, then general Exception.

4

Print the final output

Run the program to print the result of dividing 100 by each number or the error messages from the catch blocks.

Kotlin

val numbers = listOf(10, 0, 5, -2)
var result: Int = 0

for (number in numbers) {
    try {
        result = 100 / number
        println("100 divided by $number is $result")
    } catch (e: ArithmeticException) {
        println("Cannot divide by zero for number $number")
    } catch (e: Exception) {
        println("An error occurred with number $number: ${e.message}")
    }
}
# Run the program to see the output
# Your code here

Hint

Just run the program. The output should show results or error messages for each number.

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