Why Multiple catch blocks in Kotlin? - Purpose & Use Cases

The Big Idea

What if your program could tell exactly what went wrong and fix it smoothly every time?

The Scenario

Imagine you write a program that reads a file and converts its content to a number. If something goes wrong, like the file is missing or the content is not a number, you want to handle each problem differently.

Without multiple catch blocks, you might try to catch all errors in one place, making it hard to know what exactly went wrong.

The Problem

Using just one catch block means you have to guess the error type inside it, which is slow and confusing.

You might miss some errors or handle them incorrectly, causing bugs or crashes.

It's like trying to fix a broken car by only saying "something is wrong" without knowing if it's the engine, tires, or brakes.

The Solution

Multiple catch blocks let you write separate handlers for each error type.

This way, your program can respond exactly to the problem it faces, making your code clearer and safer.

It's like having a mechanic who knows exactly how to fix the engine, tires, or brakes separately.

Before vs After

✗ Before

try {
    // code that may throw exceptions
} catch (e: Exception) {
    if (e is IOException) {
        // handle IO error
    } else if (e is NumberFormatException) {
        // handle number format error
    }
}

✓ After

try {
    // code that may throw exceptions
} catch (e: IOException) {
    // handle IO error
} catch (e: NumberFormatException) {
    // handle number format error
}

What It Enables

You can write clear, precise error handling that makes your program more reliable and easier to understand.

Real Life Example

When reading user input from a file, you can catch file-not-found errors separately from errors caused by wrong number formats, giving users clear messages for each problem.

Key Takeaways

One catch block for all errors is confusing and error-prone.

Multiple catch blocks let you handle each error type clearly.

This makes your code safer and easier to maintain.