How does Kotlin handle exception handling? What is the difference between try-catch and try-catch-finally blocks?

In Kotlin, exception handling is very similar to exception handling in Java.

To handle exceptions in Kotlin, we can use the ‘try‘, ‘catch‘ and ‘finally‘ clauses. The basic syntax for handling exceptions in Kotlin is as follows:

try {
    // code that might throw an exception
} catch (e: Exception) {
    // code that handles the exception
} finally {
    // code that is executed regardless of whether an exception was thrown or not
}

If an exception is thrown inside the ‘try‘ block, the control is transferred to the ‘catch‘ block. The ‘catch‘ block is responsible for handling the exception thrown by the ‘try‘ block.

The ‘finally‘ block is optional and is executed regardless of whether an exception was thrown or not. This block is typically used to release resources like file handles, database connections etc.

There are two types of ‘try-catch‘ blocks in Kotlin:

1. **‘try-catch‘**: This is the basic form of ‘try-catch‘. It handles only one type of exception at a time. For example:

try {
    // code that might throw an exception
} catch (e: IOException) {
    // code that handles IOException
} catch (e: FileNotFoundException) {
    // code that handles FileNotFoundException
} catch (e: Exception) {
    // code that handles all other exceptions
}

In the above code, we have multiple catch blocks that handle different types of exceptions. If the code inside the ‘try‘ block throws an ‘IOException‘, the first catch block will be executed. If it throws a ‘FileNotFoundException‘, the second catch block will be executed. If it throws any other type of exception, the third catch block will be executed.

2. **‘try-catch-finally‘**: This form of ‘try-catch‘ block is used when we need to execute some cleanup code regardless of whether an exception was thrown or not. For example:

val file = File("example.txt")
try {
    // code that might throw an exception
    file.writeText("Hello World")
} catch (e: IOException) {
    // code that handles IOException
} finally {
    // code that is executed regardless of whether an exception was thrown or not
    file.delete()
}

In the above code, we are creating a file ‘example.txt‘ and writing some text to it. If the write operation throws an ‘IOException‘, the catch block will be executed and the file will be deleted in the ‘finally‘ block. If the write operation is successful, the ‘finally‘ block will still be executed and the file will be deleted.

In conclusion, Kotlin handles exception handling in a similar way to Java, with the ability to use ‘try-catch‘ and ‘try-catch-finally‘ blocks. The difference between the two is that ‘try-catch-finally‘ blocks are used for cleanup code that needs to be executed regardless of whether an exception was thrown or not.