Kotlin Tutoial

Basics

Control Flow

Array & String

Functions

Collections

OOPs Concept

Exception Handling

Null Safety

Regex & Ranges

Java Interoperability

Miscellaneous

Android

Kotlin Exception Handling | try, catch, throw and finally

Exception handling is a crucial part of software development. It ensures that your program can deal with unexpected situations gracefully, without crashing or producing unintended results. Kotlin provides a robust mechanism for exception handling using the familiar try, catch, finally, and throw constructs.

1. `try` and `catch`:

The primary mechanism for exception handling in Kotlin (like many other languages) is the try-catch block. You place the code that might throw an exception inside the try block and handle the exception in the catch block.

Example:

fun main() {
    try {
        val result = 10 / 0
        println(result)
    } catch (e: ArithmeticException) {
        println("Cannot divide by zero!")
    }
}

In this example, dividing by zero is not allowed in integer arithmetic, so an ArithmeticException is thrown. The exception is caught in the catch block, and a message is printed instead.

2. Multiple `catch` blocks:

If the try block could throw more than one type of exception, you can have multiple catch blocks.

try {
    // some code
} catch (e: ArithmeticException) {
    // handle arithmetic exception
} catch (e: NullPointerException) {
    // handle null pointer exception
}

3. `finally` block:

The finally block contains code that will be executed regardless of whether an exception was thrown. This is often used for cleanup tasks, like closing open files or database connections.

try {
    // some code
} catch (e: Exception) {
    // handle exception
} finally {
    // this code is always executed
}

4. `throw` keyword:

You can throw an exception using the throw keyword. This can be useful if you want to signal that a method can't continue executing because of some unexpected condition.

fun checkAge(age: Int) {
    if (age < 0) {
        throw IllegalArgumentException("Age cannot be negative")
    }
}

5. The Nothing type:

In Kotlin, when a function throws an exception and does not return, you can use the Nothing return type to indicate that the function will never return a value.

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

6. Kotlin's approach to checked exceptions:

Unlike Java, Kotlin does not have checked exceptions. In Java, some exceptions must be either caught or declared in the method signature. In Kotlin, there is no such requirement, making exception handling more flexible but also putting more responsibility on the developer to handle potential exceptions appropriately.

Conclusion:

Kotlin provides a comprehensive mechanism for handling exceptions, ensuring that developers can write robust and resilient code. By understanding and using try, catch, finally, and throw effectively, you can handle unexpected situations in your Kotlin programs gracefully.

Using try-catch in Kotlin: The basic structure of a try-catch block in Kotlin.

try {
    // Code that may throw an exception
} catch (e: Exception) {
    // Handle the exception
}

Handling specific exceptions in Kotlin: Catching specific exceptions allows for more targeted error handling.

try {
    // Code that may throw FileNotFoundException
} catch (e: FileNotFoundException) {
    // Handle FileNotFoundException
} catch (e: IOException) {
    // Handle other IOExceptions
}

Throwing exceptions in Kotlin: Use the throw keyword to throw exceptions.

fun divide(a: Int, b: Int): Int {
    if (b == 0) {
        throw ArithmeticException("Cannot divide by zero")
    }
    return a / b
}

Custom exceptions in Kotlin: Define custom exceptions by extending the Exception class.
```
class MyCustomException(message: String) : Exception(message)
```
Exception propagation in Kotlin: Unhandled exceptions propagate up the call stack.
```
fun main() {
    divide(10, 0)
}
```

Multiple catch blocks in Kotlin: Catch multiple types of exceptions in separate catch blocks.

try {
    // Code that may throw exceptions
} catch (e: FileNotFoundException) {
    // Handle FileNotFoundException
} catch (e: IOException) {
    // Handle other IOExceptions
}

Handling checked and unchecked exceptions in Kotlin: Kotlin does not distinguish between checked and unchecked exceptions. All exceptions are unchecked.
```
try {
    // Code that may throw exceptions
} catch (e: Exception) {
    // Handle the exception
}
```

Kotlin finally block usage: The finally block is executed regardless of whether an exception is thrown or not.

try {
    // Code that may throw an exception
} catch (e: Exception) {
    // Handle the exception
} finally {
    // Code that always executes
}

Resource management with try-finally in Kotlin: Ensure resource cleanup using finally, common in file or database handling.
```
val file = File("example.txt")
try {
    // Code that may throw an exception
} finally {
    file.close()
}
```

Exception chaining in Kotlin: Chain exceptions to provide more context about the error.

try {
    // Code that may throw an exception
} catch (e: IOException) {
    throw MyCustomException("Error processing file", e)
}

Rethrowing exceptions in Kotlin: Rethrow an exception to propagate it up the call stack.

fun handleException() {
    try {
        // Code that may throw an exception
    } catch (e: Exception) {
        // Handle the exception
        throw e
    }
}

Error handling strategies in Kotlin: Choose appropriate error-handling strategies based on the situation.

try {
    // Code that may throw an exception
} catch (e: MyCustomException) {
    // Handle custom exception
} catch (e: Exception) {
    // Handle other exceptions
}

Using try-catch with expressions in Kotlin: Exception handling can be used as an expression, returning a result.

val result = try {
    // Code that may throw an exception
} catch (e: Exception) {
    // Handle the exception
    defaultValue
}

Kotlin Exception Handling | try, catch, throw and finally

1. try and catch:

2. Multiple catch blocks:

3. finally block: