Kuidas tagada Kotlinis tüüpide turvalisus?

Kotlin'i tüübi turvalisus tagatakse kompileerimise ajal, kasutades mitmeid peamisi mehhanisme:

Mitte-null tüübisüsteem: Kotlin eristab viite tüüpe, mis võivad väärtust null võtta (näidatud ? lõpus tüübi nimel), ja neid, mis ei saa. Kompilaator nõuab selgeid nullkontrolle või turvalisi kutsungeid (?.) ja operaatoreid (?:, !!).

// Viide, mis ei saa olla null
val nonNullableString: String = "Hello"

// Viide, mis võib olla null
var nullableString: String? = "World"
nullableString = null // Lubatud

// Kompileerimisviga: nõutav nulli töötlemine
// val length = nullableString.length

// Turvaline kutsung
val length: Int? = nullableString?.length

// Elvis operaator
val safeLength: Int = nullableString?.length ?: 0

Tark-klassifikatsioonid (Smart Casts): Kompilaator automaatselt muudab muutuja tüübi if, when, while, for ja muude väljendite sees pärast tüübi või null kontrolli.

fun printLength(obj: Any) {
    if (obj is String) {
        // Selles plokis teab kompilaator, et obj on String
        println("Stringi pikkus on ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Selles plokis teab kompilaator, et str ei ole null
        println("String ei ole null, pikkus on ${str.length}")
    }
}

Üldistüübid (Generics): Kotlin toetab üldistüüpe, mis võimaldavad luua klasse, liideseid ja funktsioone, mis töötavad erinevate tüüpidega, pakkudes tüübiturvalisust kompileerimise ajal.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Kompilaator teab, et item on String
    println(box.item.uppercase())
}
```

Kovariantsus (out) ja kontravariantsus (in): Annab võimaluse täpsustada, kuidas alamliigid võivad kasutada universaalseid tüüpe, vältides tüübi sobimatuse vigu kompileerimisel.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Kompileerimisviga
}

interface Sink<in T> {
    // fun produceT(): T // Kompileerimisviga
    fun consumeT(t: T)
}

Sealed klassid: Esindavad piiratud klasside hierarhiat, kus kõik alamklassid on teada kompileerimise ajal. See võimaldab kompilaatoril kontrollida when-lause täiendavust sealed klassi alamklassidega, tagades kõigi võimalike juhtumite käsitlemise.

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val code: Int) : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Andmed: ${result.data}")
        is Result.Error -> println("Viga: ${result.code}")
        // Ilma 'else'-ita garantii kõigi alamklasside käsitlemiseks
    }
}

Need mehhanismid töötavad koos, võimaldades avastada paljusid potentsiaalseid tüüpi vigu varases arenguetapis enne rakenduse käivitamist.