Kotlin'da tur xavfsizligini qanday ta'minlash mumkin…

Kotlin'da turdagi xavfsizligi bir nechta asosiy mexanizmlar yordamida kompilatsiya vaqtida ta'minlanadi:

Null bo'lmagan tur tizimi: Kotlin null qabul qiladigan referens turlar bilan ? bilan belgilangan va null qabul qilmaydigan turlarni ajratadi. Kompilyator null uchun aniq tekshiruvlar yoki xavfsiz chaqiruvlar (?.) va operatorlar (?:, !!) ni talab qiladi.

// Null bo'lmagan referens
val nonNullableString: String = "Hello"

// Null bo'lishi mumkin bo'lgan referens
var nullableString: String? = "World"
nullableString = null // Ruxsat etilgan

// Kompilyatsiya xatosi: null bilan ishlash talab qilinadi
// val length = nullableString.length

// Xavfsiz chaqiruv
val length: Int? = nullableString?.length

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

Aqlli tipga o'tkazish (Smart Casts): Kompilyator if, when, while, for va boshqa ifodalardagi o'zgaruvchilarning tipini yoki null holatini tekshirgandan so'ng avtomatik ravishda o'zgartiradi.

fun printLength(obj: Any) {
    if (obj is String) {
        // Bu blok ichida, kompilyator obj ning String ekanligini biladi
        println("String uzunligi ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Bu blok ichida, kompilyator str ning null emasligini biladi
        println("String null emas, uzunligi ${str.length}")
    }
}

Generik turlar (Generics): Kotlin turli turlar bilan ishlaydigan, kompilatsiya vaqtida tur xavfsizligini ta'minlaydigan sinflar, interfeyslar va funksiyalar yaratishga imkon beradigan generiklarni qo'llab-quvvatlaydi.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Kompilyator, item ning String ekanligini biladi
    println(box.item.uppercase())
}
```

Kovariatsiya (out) va kontravariatsiya (in): Ular, qanday qilib subtiplar umumiy turlarda ishlatilishi mumkinligini aniqlashga imkon beradi, bu esa kompilatsiya vaqtida tur mos kelmasligi xatolarini oldini oladi.

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

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

Yopiq sinflar (Sealed classes): Cheklangan sinf hierarxiyasini ifodalaydi, bunda barcha podsinflar kompilatsiya vaqtida ma'lum. Bu, kompilyator when ifodalarining to'liqligini tekshirishga imkon beradi, bu esa barcha ehtimoliy holatlarni ishlashini ta'minlaydi.

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("Ma'lumot: ${result.data}")
        is Result.Error -> println("Xato: ${result.code}")
        // 'else' bo'lmagan holda, kompilyator barcha podsinflarni ishlashini kafolatlaydi
    }
}

Ushbu mexanizmlar birgalikda ishlaydi, ular tur bilan bog'liq ko'plab potentsial xatoliklarni dastlabki bosqichda aniqlash imkonini beradi, bu esa dastur ishga tushirilishidan oldin amalga oshiriladi.

Kotlin'da tur xavfsizligini qanday ta'minlash mumkin?