Jak zapewnić bezpieczeństwo typów w Kotlinie?

Bezpieczeństwo typów w Kotlin zapewniane jest na etapie kompilacji dzięki kilku kluczowym mechanizmom:

System typów nie-nullowalnych: Kotlin rozróżnia typy referencyjne, które mogą przyjąć wartość null (oznaczone ? na końcu nazwy typu), od tych, które tego nie mogą. Kompilator wymaga jawnych sprawdzeń null lub użycia bezpiecznych wywołań (?.) i operatorów (?:, !!).

// Referencja, która nie może być null
val nonNullableString: String = "Hello"

// Referencja, która może być null
var nullableString: String? = "World"
nullableString = null // Dozwolone

// Błąd kompilacji: konieczne obsłużenie null
// val length = nullableString.length

// Bezpieczne wywołanie
val length: Int? = nullableString?.length

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

Inteligentne rzutowania (Smart Casts): Kompilator automatycznie konwertuje typ zmiennej w blokach if, when, while, for i innych po sprawdzeniu typu lub null.

fun printLength(obj: Any) {
    if (obj is String) {
        // Wewnątrz tego bloku, kompilator wie, że obj jest String
        println("Długość Stringa to ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Wewnątrz tego bloku, kompilator wie, że str nie jest null
        println("String nie jest null, długość to ${str.length}")
    }
}

Typy generyczne (Generics): Kotlin obsługuje generyki, które pozwalają tworzyć klasy, interfejsy i funkcje działające z różnymi typami, zapewniając bezpieczeństwo typów na etapie kompilacji.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Kompilator wie, że item jest typu String
    println(box.item.uppercase())
}
```

Kowariancja (out) i kontrawariancja (in): Pozwalają określić, jak podtypy mogą być używane w typach generycznych, zapobiegając błędom niezgodności typów podczas kompilacji.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Błąd kompilacji
}

interface Sink<in T> {
    // fun produceT(): T // Błąd kompilacji
    fun consumeT(t: T)
}

Klasy zamknięte (Sealed classes): Reprezentują ograniczoną hierarchię klas, w której wszystkie podklasy są znane w czasie kompilacji. Umożliwia to kompilatorowi sprawdzanie kompletności wyrażeń when z podklasami sealed klasy, zapewniając obsługę wszystkich możliwych przypadków.

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("Dane: ${result.data}")
        is Result.Error -> println("Błąd: ${result.code}")
        // Bez 'else', kompilator gwarantuje obsługę wszystkich podklas Sealed
    }
}

Mechanizmy te współpracują ze sobą, pozwalając wykrywać wiele potencjalnych błędów związanych z typami na wczesnym etapie rozwoju, jeszcze przed uruchomieniem aplikacji.