Qual é a diferença entre exceções em Kotlin e Java?

A principal diferença na gestão de exceções verificadas (checked).

Em Java, existem dois tipos de exceções:

• Exceções verificadas (Checked Exception): requerem gestão explícita num bloco try-catch ou declaração na assinatura do método com a palavra-chave throws. Exemplos: IOException, FileNotFoundException.
• Exceções não verificadas (Unchecked Exception): não requerem gestão explícita. Exemplos: RuntimeException e suas subclasses, Error.

Em Kotlin, não existem exceções verificadas. Todas as exceções em Kotlin são, na sua essência, não verificadas. Isto simplifica o código, pois não é necessário usar try-catch ou throws em operações rotineiras que possam lançar exceções.

Exemplo em Java:

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

Exemplo em Kotlin:

// Kotlin
import java.io.File

fun readFile() { // Não é necessário declarar throws
    File("file.txt").forEachLine {
        println(it)
    }
}

Apesar da ausência de exceções verificadas, Kotlin ainda pode lançar e tratar exceções (como as lançadas por bibliotecas Java), usando blocos try-catch-finally. Isto é feito para compatibilidade com código Java existente.

// Kotlin
import java.io.IOException

fun readFileSafe() {
    try {
        readFile() // Chamada de função que pode lançar IOException
    } catch (e: IOException) {
        println("Erro ao ler o arquivo: ${e.message}")
    } finally {
        println("Operação de arquivo concluída.")
    }
}

Resumindo: Kotlin facilita o desenvolvimento ao eliminar a necessidade de lidar obrigatoriamente com exceções verificadas, confiando mais em exceções em tempo de execução e em manipuladores de erros padrão quando necessário.