What is the difference between exceptions in Kotlin and Java?

The main difference in handling checked exceptions.

In Java, there are two types of exceptions:

• Checked Exceptions: require explicit handling in a try-catch block or declaration in the method signature with the throws keyword. Examples: IOException, FileNotFoundException.
• Unchecked Exceptions: do not require explicit handling. Examples: RuntimeException and its subclasses, Error.

In Kotlin, there are no checked exceptions. All exceptions in Kotlin are essentially unchecked. This simplifies the code, as there is no need to use try-catch or throws everywhere for routine operations that might throw exceptions.

Example in Java:

// Java
public class FileRead {
    public void readFile() throws IOException { // Must declare
        BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }
}

Example in Kotlin:

// Kotlin
import java.io.File

fun readFile() { // No need to declare throws
    File("file.txt").forEachLine {
        println(it)
    }
}

Despite the absence of checked exceptions, Kotlin can still throw and handle them (such as those thrown from Java libraries) using try-catch-finally blocks. This is done for compatibility with existing Java code.

// Kotlin
import java.io.IOException

fun readFileSafe() {
    try {
        readFile() // Call to a function that might throw IOException
    } catch (e: IOException) {
        println("Error reading file: ${e.message}")
    } finally {
        println("File operation finished.")
    }
}

In summary: Kotlin simplifies development by removing the need to handle checked exceptions explicitly, relying more on runtime exceptions and standard error handlers where necessary.