Typy null

Czym jest null

null oznacza brak wartości – „nic”, „pustka”. To coś innego niż zero czy pusty tekst: zmienna o wartości null nie wskazuje na żadne dane. Pojawia się np. wtedy, gdy czegoś nie udało się znaleźć albo nie podano (pamiętasz toIntOrNull() z lekcji o wczytywaniu?).

NullPointerException – groźny błąd

Problem zaczyna się, gdy program próbuje coś zrobić z wartością, której nie ma. Próba odwołania się do null (np. odczytania długości nieistniejącego tekstu) powoduje błąd NullPointerException, w skrócie NPE – jeden z najczęstszych powodów „wysypywania się” programów.

Kluczowa idea Kotlina: zamiast pozwalać, by NPE wybuchł w czasie działania programu (u użytkownika!), język wyłapuje ryzyko już podczas pisania kodu.

Typy nienullowalne

Domyślnie typy w Kotlinie są nienullowalne – nie wolno przypisać im null. Zmienna typu String zawsze zawiera jakiś tekst, więc można jej bezpiecznie używać.

val imie: String = "Anna"

// imie = null            // BŁĄD już przy pisaniu – String nie może być null

println(imie.length)        // bezpieczne – imie na pewno istnieje
println(imie.uppercase())   // bezpieczne

Typy nullowalne – znak zapytania

Czasem brak wartości jest naturalny (np. nieznaleziony wynik). Aby pozwolić zmiennej być pustą, dopisujemy do typu znak zapytania: String?. Taki typ może zawierać tekst albo null.

val imie: String? = "Anna"     // może mieć tekst...
val drugie: String? = null     // ...albo być puste

Jak Kotlin zapobiega NPE

Skoro String? może być null, Kotlin nie pozwoli użyć go wprost – bo groziłoby to NPE. Próba odczytania np. .length na wartości nullowalnej to błąd już podczas pisania:

val imie: String? = pobierzImie()

// println(imie.length)   // BŁĄD! imie może być null

Jednym z najprostszych sposobów jest sprawdzenie, czy wartość nie jest null. Wewnątrz takiego warunku Kotlin wie, że wartość istnieje, i pozwala jej użyć:

val imie: String? = pobierzImie()

if (imie != null) {
    println(imie.length)   // OK – w tym miejscu imie na pewno nie jest null
} else {
    println("Brak imienia")
}

Przypisania między typami

Kierunek ma znaczenie. Wartość nienullowalną zawsze można włożyć tam, gdzie dozwolony jest null (bo „na pewno coś jest” spełnia warunek „coś albo nic”). Odwrotnie już nie – nullowalnej nie wolno przypisać do typu, który nie dopuszcza null.

val pewne: String = "Anna"
val moze: String? = pewne      // OK – nie-null pasuje do nullowalnego

val cosNull: String? = null
// val pewne2: String = cosNull    // BŁĄD! nullowalne nie pasuje do nienullowalnego

Częste błędy

❌ Błąd 1: null w typie nienullowalnym

val imie: String = null
// Błąd! String nie może
// być null

val imie: String? = null
// OK

❌ Błąd 2: bezpośrednie użycie nullowalnego

val imie: String? = pobierz()
println(imie.length)
// Błąd! imie może być null

val imie: String? = pobierz()
if (imie != null) {
    println(imie.length)
}

❌ Błąd 3: nullowalne tam, gdzie wymagane nie-null

val moze: String? = "tekst"
val pewne: String = moze
// Błąd! moze mogłoby
// być null

val moze: String? = "tekst"
val nadalMoze: String? = moze
// OK

❌ Błąd 4: zapomniany ? przy wyniku, który bywa null

val liczba: Int =
    readln().toIntOrNull()
// Błąd! wynik może
// być null

val liczba: Int? =
    readln().toIntOrNull()
// OK

Podsumowanie

• null oznacza brak wartości – to nie to samo co 0 czy pusty tekst.
• Odwołanie do null powoduje błąd NullPointerException (NPE) w czasie działania programu.
• Domyślnie typy są nienullowalne (String) – zawsze mają wartość, można ich bezpiecznie używać.
• Dopisanie ? tworzy typ nullowalny (String?) – może zawierać wartość albo null.
• Kotlin nie pozwala użyć nullowalnego wprost – wyłapuje ryzyko NPE już podczas pisania kodu.
• Nie-null można przypisać do nullowalnego, ale nie odwrotnie (bez wcześniejszego sprawdzenia).

Zadania do wykonania

Zadania z wczytywaniem uruchamiaj w IntelliJ IDEA; pozostałe w Kotlin Playground.