Exception Handling in Kotlin

 Exception handling in Kotlin is similar to other languages like Java, but with some differences and improvements. Kotlin does not have checked exceptions, which means you are not required to catch or declare exceptions. This makes the code cleaner and more concise. Here's how exception handling works in Kotlin:

---

1. Basic Exception Handling with try-catch

Kotlin uses the try-catch block to handle exceptions. The syntax is straightforward:

kotlin

Copy

fun main() {
    try {
        val result = 10 / 0 // This will throw an ArithmeticException
        println("Result: $result")
    } catch (e: ArithmeticException) {
        println("Caught an exception: ${e.message}")
    }
}

• The try block contains the code that might throw an exception.

• The catch block handles the exception. You can specify the type of exception to catch (e.g., ArithmeticException).

---

2. finally Block

The finally block is used to execute code regardless of whether an exception is thrown or not. It is typically used for cleanup operations, such as closing resources.

kotlin

Copy

fun main() {
    try {
        val result = 10 / 0
        println("Result: $result")
    } catch (e: ArithmeticException) {
        println("Caught an exception: ${e.message}")
    } finally {
        println("This will always execute.")
    }
}

---

3. try as an Expression

In Kotlin, try-catch can be used as an expression, meaning it can return a value. This is useful for assigning a value based on whether an exception occurs.

kotlin

Copy

fun main() {
    val result = try {
        10 / 0
    } catch (e: ArithmeticException) {
        -1 // Return a default value in case of an exception
    }
    println("Result: $result") // Output: Result: -1
}

---

4. No Checked Exceptions

Unlike Java, Kotlin does not have checked exceptions. This means you are not forced to catch or declare exceptions in your code. For example:

kotlin

Copy

fun readFile() {
    // No need to declare or catch IOException
    val file = File("nonexistent.txt")
    file.readText()
}

---

5. Custom Exceptions

You can define custom exceptions by creating a class that extends Exception or any other exception class.

kotlin

Copy

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

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

---

6. Common Kotlin Exceptions

Here are some common exceptions you might encounter in Kotlin:

• ArithmeticException: Thrown for arithmetic errors (e.g., division by zero).

• NullPointerException: Thrown when accessing a null object.

• IllegalArgumentException: Thrown when an argument is invalid.

• IndexOutOfBoundsException: Thrown when accessing an index outside the bounds of a collection.

---

7. Handling Multiple Exceptions

You can handle multiple exceptions by adding multiple catch blocks:

kotlin

Copy

fun main() {
    try {
        val input = "abc"
        val number = input.toInt() // This will throw NumberFormatException
        println("Number: $number")
    } catch (e: NumberFormatException) {
        println("Invalid number format: ${e.message}")
    } catch (e: Exception) {
        println("Caught a general exception: ${e.message}")
    }
}

---

8. Rethrowing Exceptions

You can rethrow an exception after catching it using the throw keyword:

kotlin

Copy

fun main() {
    try {
        throw CustomException("Original exception")
    } catch (e: CustomException) {
        println("Caught exception: ${e.message}")
        throw e // Rethrow the exception
    }
}

---

9. Using runCatching for Functional Exception Handling

Kotlin provides a functional approach to exception handling using runCatching. It wraps the code in a Result object, which can be used to handle success or failure.

kotlin

Copy

fun main() {
    val result = runCatching {
        10 / 0
    }
    result.onSuccess { value ->
        println("Success: $value")
    }.onFailure { exception ->
        println("Failed: ${exception.message}")
    }
}

---

Summary

• Kotlin uses try-catch-finally for exception handling.

• try-catch can be used as an expression.

• Kotlin does not have checked exceptions.

• You can define custom exceptions by extending the Exception class.

• Use runCatching for a functional approach to exception handling.