Kotlin'de tip güvenliğini nasıl sağlarım?

Kotlin'de tip güvenliği, birkaç anahtar mekanizma sayesinde derleme zamanında sağlanır:

Null olmayan tip sistemi: Kotlin, null alabilen referans tipleri (tip adının sonunda ? ile gösterilir) ile almayabilenleri ayırt eder. Derleyici, açık null kontrolleri veya güvenli çağrı (?.) ve operatörler (?:, !!) kullanımı gerektirir.

// Null olamayacak referans
val nonNullableString: String = "Hello"

// Null olabilecek referans
var nullableString: String? = "World"
nullableString = null // izin verilir

// Derleme hatası: null işleme gerek var
// val length = nullableString.length

// Güvenli çağrı
val length: Int? = nullableString?.length

// Elvis operatörü
val safeLength: Int = nullableString?.length ?: 0

Akıllı tip dönüşümleri (Smart Casts): Derleyici, if, when, while, for ve diğer ifadeler içindeki değişkenlerin tiplerini veya null durumunu kontrol ettikten sonra otomatik olarak dönüştürür.

fun printLength(obj: Any) {
    if (obj is String) {
        // Bu blok içinde, derleyici obj'in String olduğunu bilir
        println("String uzunluğu ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Bu blok içinde, derleyici str'nin null olmadığını bilir
        println("Null olmayan string, uzunluk ${str.length}")
    }
}

Genel tipler (Generics): Kotlin, farklı tiplerle çalışan ve derleme zamanında tip güvenliğini sağlayan sınıflar, arayüzler ve fonksiyonlar oluşturmayı sağlayan jenerik tipleri destekler.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Derleyici, item'in String olduğunu bilir
    println(box.item.uppercase())
}
```

Kovaryans (out) ve kontravaryans (in): Alt tiplerin genel tiplerde nasıl kullanılabileceğini belirlemeye izin verir, böylece derleme zamanında uyumsuzluk hatalarını önler.

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

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

Sealed sınıflar: Sınırlı bir sınıf hiyerarşisi temsil eder, burada tüm alt sınıflar derleme zamanında bilinir. Bu, derleyicinin when ifadelerinin tamamlayıcılığını kontrol etmesine ve tüm olası durumların işlenmesini sağlamasına olanak tanır.

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("Veri: ${result.data}")
        is Result.Error -> println("Hata: ${result.code}")
        // 'else' olmadan, derleyici tüm alt sınıfların işlendiğinden emin olur
    }
}

Bu mekanizmalar birlikte çalışarak, tiplerle ilgili birçok potansiyel hatayı erken aşamada tespit etmeye olanak tanır, uygulama çalıştırılmadan önce.