Kā nodrošināt tipu drošību Kotlin?

Kotlin tipa drošība tiek nodrošināta kompilācijas laikā, izmantojot vairākus galvenos mehānismus:

Nepārtrauktas tipa sistēma: Kotlin atšķir starp atsauces tipiem, kas var pieņemt vērtību null (norādīts ar ? beigās tipa nosaukuma), un tiem, kas nevar. Kompilators pieprasa skaidras nulles pārbaudes vai drošas izsaukšanas (?.) un operatoru (?:, !!).

// Atsauce, kas nevar būt null
val nonNullableString: String = "Hello"

// Atsauce, kas var būt null
var nullableString: String? = "World"
nullableString = null // Atļauts

// Kompilācijas kļūda: nepieciešama nulles apstrāde
// val length = nullableString.length

// Droša izsaukšana
val length: Int? = nullableString?.length

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

Intelligentās pārbaudes (Smart Casts): Kompilators automātiski pārveido mainīgā tipu iekšpusē if, when, while, for un citās izteiksmēs pēc tipa vai null pārbaudes.

fun printLength(obj: Any) {
    if (obj is String) {
        // Šajā blokā kompilators zina, ka obj ir String
        println("String garums ir ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Šajā blokā kompilators zina, ka str nav null
        println("String nav null, garums ir ${str.length}")
    }
}

Ģeneriskie tipi (Generics): Kotlin atbalsta ģeneriskumu, ļaujot izveidot klases, interfeisus un funkcijas, kas darbojas ar dažādiem tipiem, nodrošinot tipa drošību kompilācijas laikā.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Kompilators zina, ka item ir String
    println(box.item.uppercase())
}
```

Kovariantība (out) un kontravariantība (in): Ļauj precizēt, kā apakštipi var tikt izmantoti universālajos tipos, novēršot tipu nesaderības kļūdas kompilācijas laikā.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Kompilācijas kļūda
}

interface Sink<in T> {
    // fun produceT(): T // Kompilācijas kļūda
    fun consumeT(t: T)
}

Sealed klases: Apzīmē ierobežotu klases hierarhiju, kuras visi apakšklas ir zināmas kompilācijas laikā. Tas ļauj kompilatoram pārbaudīt when izteiksmju pilnīgumu ar sealed klases apakšklas, nodrošinot visu iespējamās gadījumu apstrādi.

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("Dati: ${result.data}")
        is Result.Error -> println("Kļūda: ${result.code}")
        // Bez 'else' kompilators garantē visu apakškla apstrādi
    }
}

Šie mehānismi darbojas kopā, ļaujot agrīni identificēt daudzus potenciālos tipu kļūdas, pirms tiek palaists lietojumprogramma.