Care este diferența dintre excepții în Kotlin și Java?

Principala diferență în gestionarea excepțiilor verificate (checked).

În Java există două tipuri de excepții:

• Excepții verificate (Checked Exception): necesită gestionare explicită într-un bloc try-catch sau declarație în semnătura metodei cu cuvântul cheie throws. Exemple: IOException, FileNotFoundException.
• Excepții necontrolate (Unchecked Exception): nu necesită gestionare explicită. Exemple: RuntimeException și subclasele sale, Error.

În Kotlin nu există excepții verificate. Toate excepțiile în Kotlin sunt, în esență, necontrolate. Acest lucru simplifică codul, deoarece nu trebuie să folosiți try-catch sau throws pentru operațiuni de rutină care pot arunca excepții.

Exemplu în Java:

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

Exemplu în Kotlin:

// Kotlin
import java.io.File

fun readFile() { // Nu este nevoie să declarăm throws
    File("file.txt").forEachLine {
        println(it)
    }
}

În ciuda lipsei excepțiilor verificate, Kotlin poate totuși să le arunce și să le gestioneze (cum ar fi cele aruncate din biblioteci Java), folosind blocuri try-catch-finally. Acest lucru se face pentru compatibilitate cu codul Java existent.

// Kotlin
import java.io.IOException

fun readFileSafe() {
    try {
        readFile() // Apel de funcție care poate arunca IOException
    } catch (e: IOException) {
        println("Eroare la citirea fișierului: ${e.message}")
    } finally {
        println("Operația de fișier s-a încheiat.")
    }
}

Rezumat: Kotlin simplifică dezvoltarea eliminând necesitatea de a trata obligatoriu excepțiile verificate, bazându-se mai mult pe excepții la runtime și pe gestionarea standard a erorilor acolo unde este necesar.