Ce sunt tipurile 'nullable' în Kotlin și cum…

Tipurile nullable în Kotlin sunt tipuri care pot conține atât o valoare, cât și null. Ele sunt indicate explicit prin simbolul ? după numele tipului.

Funcționarea se bazează pe sistemul de tipuri al Kotlin, care previne NullPointerException în timpul compilării. Compilatorul necesită o verificare explicită a null înainte de a accesa membrii unui obiect de tip nullable.

Principalele modalități de a lucra în siguranță cu tipurile nullable sunt:

Verificarea null cu if:

fun printLength(str: String?) {
    if (str != null) {
        println(str.length) // Apel sigur după verificarea null
    } else {
        println("Șir null")
    }
}

Operatorul de apel sigur (?.): Returnează null dacă obiectul este null, altfel rezultatul apelului.
```
val safeLength: Int? = str?.length // Dacă str este null, safeLength va fi null
```
Operatorul Elvis (?:): Permite furnizarea unei valori implicite în cazul în care expresia din stânga operatorului este null.
```
val lengthOrDefault: Int = str?.length ?: 0 // Dacă str este null, lengthOrDefault va fi 0
```
Operatorul de afirmare explicită non-null (!!): Transformă un tip nullable într-unul non-nullable. Se folosește cu precauție, deoarece va arunca o NullPointerException dacă valoarea este null.
```
val assertedLength: Int = str!!.length // Va arunca NPE dacă str este null
```

Funcțiile let/run/apply/also cu apel sigur:

str?.let {
    // Codul se va executa doar dacă str nu este null
    println("Lungimea șirului: ${it.length}")
}

Sistemul de tipuri nullable al Kotlin crește semnificativ siguranța și reduce probabilitatea apariției NullPointerException comparativ cu limbajele în care null poate fi atribuit oricărui tip fără o indicație explicită.

Ce sunt tipurile 'nullable' în Kotlin și cum funcționează?