Wat is het verschil tussen uitzonderingen in Kotlin en Java?

Het belangrijkste verschil in de verwerking van gecontroleerde (checked) uitzonderingen.

In Java zijn er twee typen uitzonderingen:

• Geverifieerde (Checked Exception): vereisen expliciete handling in een try-catch blok of declaratie in de methodesignatuur met het sleutelwoord throws. Voorbeelden: IOException, FileNotFoundException.
• Ongecontroleerde (Unchecked Exception): vereisen geen expliciete handling. Voorbeelden: RuntimeException en zijn subklassen, Error.

In Kotlin zijn er geen gecontroleerde uitzonderingen. Alle uitzonderingen in Kotlin zijn in wezen ongecontroleerd. Dit vereenvoudigt de code, omdat je try-catch of throws niet hoeft te gebruiken voor routinematige operaties die een uitzondering kunnen veroorzaken.

Voorbeeld in Java:

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

Voorbeeld in Kotlin:

// Kotlin
import java.io.File

fun readFile() { // Geen throws declaratie nodig
    File("file.txt").forEachLine {
        println(it)
    }
}

Ondanks het ontbreken van gecontroleerde uitzonderingen, kan Kotlin nog steeds uitzonderingen werpen en afhandelen (zoals die uit Java-bibliotheken), met behulp van try-catch-finally blokken. Dit wordt gedaan voor compatibiliteit met bestaande Java-code.

// Kotlin
import java.io.IOException

fun readFileSafe() {
    try {
        readFile() // Functie die IOException kan werpen
    } catch (e: IOException) {
        println("Fout bij het lezen van het bestand: ${e.message}")
    } finally {
        println("Bestandsbewerking voltooid.")
    }
}

Samenvatting: Kotlin vereenvoudigt de ontwikkeling door het elimineren van de noodzaak om gecontroleerde uitzonderingen verplicht af te handelen, en vertrouwt meer op runtime-excepties en standaard foutafhandelingsmechanismen waar nodig.