Error Handling in Kotlin

What You’ll Learn 📚

By the end of this tutorial, you’ll understand:

• The basics of error handling in Kotlin
• Key terminology and concepts
• How to use try-catch blocks effectively
• How to create custom exceptions
• Common pitfalls and how to avoid them

Introduction to Error Handling

Error handling is a crucial part of programming. It allows your program to deal with unexpected situations gracefully, rather than crashing or producing incorrect results. In Kotlin, error handling is primarily done using exceptions.

Key Terminology

• Exception: An event that disrupts the normal flow of a program.
• Try-catch block: A way to handle exceptions by ‘trying’ a block of code and ‘catching’ any exceptions that occur.
• Throw: Used to explicitly throw an exception.

Let’s Start with a Simple Example 🚀

fun main() {
    try {
        val result = 10 / 0
        println(result)
    } catch (e: ArithmeticException) {
        println("Oops! Division by zero is not allowed.")
    }
}

Progressively Complex Examples

Example 1: Handling Multiple Exceptions

fun main() {
    try {
        val numbers = listOf(1, 2, 3)
        println(numbers[5]) // This will throw an exception
    } catch (e: IndexOutOfBoundsException) {
        println("Index out of bounds! Please check your list index.")
    } catch (e: Exception) {
        println("An unexpected error occurred: " + e.message)
    }
}

Example 2: Using Finally Block

fun main() {
    try {
        val result = 10 / 2
        println(result)
    } catch (e: ArithmeticException) {
        println("Oops! Division by zero is not allowed.")
    } finally {
        println("This will always execute.")
    }
}

Example 3: Throwing Custom Exceptions

class CustomException(message: String) : Exception(message)

fun main() {
    try {
        throw CustomException("This is a custom exception!")
    } catch (e: CustomException) {
        println(e.message)
    }
}

Common Questions and Answers

1. What is an exception in Kotlin?

   An exception is an event that disrupts the normal flow of a program. It can be caused by various factors, such as invalid user input or a network failure.

2. How do I handle exceptions in Kotlin?

   You handle exceptions using try-catch blocks. You ‘try’ a block of code and ‘catch’ any exceptions that occur.

3. Can I catch multiple exceptions in a single try block?

   Yes, you can catch multiple exceptions by using multiple catch blocks. Each catch block handles a different type of exception.

4. What is the purpose of the finally block?

   The finally block is used to execute code regardless of whether an exception is thrown. It’s often used for cleanup activities.

5. How do I create a custom exception?

   You can create a custom exception by extending the Exception class and providing a constructor that takes a message.

Troubleshooting Common Issues

Make sure to catch exceptions in the correct order. More specific exceptions should be caught before more general ones.

Remember that the finally block always executes, even if you return from the try or catch block.

If you’re not sure what exception might be thrown, you can catch the generic Exception class, but it’s better to be specific when possible.

Practice Exercises

• Modify the first example to handle a NullPointerException if the variable is null.
• Create a program that reads a number from the user and handles NumberFormatException if the input is not a valid number.
• Write a function that throws a custom exception if a string is empty.

For more information, check out the official Kotlin documentation on exceptions.