რა განსხვავებაა Kotlin და Java-ის გამონაკლისებს შორის?

ძირითადი განსხვავება შემოწმებადი (checked) გამონაკლისების დამუშავებაში:

Java-ში არსებობს ორი ტიპის გამონაკლისი:

• შემოწმებადი (Checked Exception): მოითხოვს აშკარად დამუშავებას try-catch ბლოკში ან მეთოდის სიგნატურაში throws სიტყვით. მაგალითები: IOException, FileNotFoundException.
• არასამოწმებელი (Unchecked Exception): არ მოითხოვს აშკარად დამუშავებას. მაგალითები: RuntimeException და მისი ქვკლასები, Error.

Kotlin-ში არ არსებობს შემოწმებადი გამონაკლისები. ყველა გამონაკლისი ძირითადად არამოწმებადი არის. ეს ამარტივებს კოდს, რადგან არ არის საჭირო ყველგან გამოიყენოს try-catch ან throws რუტინული ოპერაციებისათვის, რომლებიც გამონაკლისს გამოიწვევს:

Java-ს მაგალითი:

// Java
public class FileRead {
    public void readFile() throws IOException { // აუცილებელია გამოაცხადო
        BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }
}

Kotlin-ის მაგალითი:

// Kotlin
import java.io.File

fun readFile() { // არ არის საჭირო გამოაცხადო throws
    File("file.txt").forEachLine {
        println(it)
    }
}

მიუხედავად შემოწმებადი გამონაკლისების არარსებობის, Kotlin-ი კვლავ შეუძლია გამოაგზავნოს და დამუშავოს ისინი (როგორც Java ბიბლიოთეკებიდან გამოგზავნილები), try-catch-finally ბლოკების გამოყენებით. ეს კეთდება არსებული Java კოდის თავსებადობისთვის:

// Kotlin
import java.io.IOException

fun readFileSafe() {
    try {
        readFile() // ფუნქციის გამოძახება, რომელიც შეიძლება გამოაგზავნოს IOException
    } catch (e: IOException) {
        println("Error reading file: ${e.message}")
    } finally {
        println("File operation finished.")
    }
}

შედეგი: Kotlin ამარტივებს განვითარების პროცესს, გამონაკლისების დამუშავების აუცილებლობას ამოღებით, უფრო მეტად დაფუძნებული რუნტაიმ გამონაკლისებზე და სტანდარტული შეცდომების დამუშავებაზე საჭიროების შემთხვევაში.