Kotlin Academy · Lekcja

Typy nullable i non-null

Podstawy systemu typów

Typy nullable i non-null to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Dlaczego bezpieczeństwo wartości null ma znaczenie

Niesławny NullPointerException spowodował awarie niezliczonych programów. Kotlin rozwiązuje ten problem, czyniąc możliwość wystąpienia wartości null elementem systemu typów.

W Kotlinie kompilator wie, czy wartość może być równa null, i wymusza obsłużenie tej możliwości, zanim pojawią się problemy.

Typy non-null

Domyślnie każdy typ w Kotlinie jest typu non-null. Zmienna typu String nigdy nie może przechowywać wartości null.

Gwarancja ta jest egzekwowana podczas kompilacji, więc można swobodnie używać wartości bez dodatkowych sprawdzeń.

fun main() {
    val name: String = "Alice"
    println(name.length)
}

Przypisanie null jest odrzucane

Próba przypisania null do typu non-null powoduje natychmiastowe zatrzymanie kompilatora.

Poniższy wiersz nie skompiluje się, ponieważ String nie akceptuje wartości null:

val name: String = null → błąd

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

Typy nullable

Aby zezwolić na wartość null, dodaj znak zapytania po typie: String?.

Jest to typ nullable. Może przechowywać rzeczywistą wartość albo null.

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

Nullable a non-null

Obie deklaracje wyglądają niemal identycznie, ale zachowują się zupełnie inaczej:

val a: String → nigdy nie ma wartości null
val b: String? → może mieć wartość null

Pojedynczy znak ? zmienia cały kontrakt zmiennej.

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

Kompilator chroni dostęp do wartości nullable

Nie można bezpośrednio wywoływać metod na wartości nullable. Kompilator odmawia kompilacji, ponieważ wartość może być równa null.

Poniższy zakomentowany wiersz nie skompilowałby się:

maybe.length dla typu String? → błąd

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

Sprawdzanie wartości null

Jednym z prostych sposobów użycia wartości nullable jest jawne sprawdzenie za pomocą if.

Wewnątrz bloku if Kotlin wie, że wartość nie jest równa null, i pozwala bezpiecznie jej używać.

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

Null w parametrach funkcji

Typy parametrów również podlegają tej zasadzie. Parametr typu String musi otrzymać rzeczywistą wartość, natomiast String? akceptuje null.

Dzięki temu sygnatury funkcji jasno dokumentują, jakie wartości przyjmują.

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

Typy nullable zwracane przez funkcje

Funkcje mogą zwracać typy nullable, aby wskazać, że wyniku może brakować.

Wywołujący musi wtedy obsłużyć możliwą wartość null przed użyciem wyniku.

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

Domyślne wnioskowanie typu

Podczas przypisywania literału Kotlin automatycznie wnioskuje typ non-null.

val n = "text" → wywnioskowany typ String

Aby uzyskać typ nullable, należy jawnie zadeklarować typ za pomocą ?.

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

Łączenie wszystkiego

System typów dzieli wartości na dwie wyraźne grupy:

Non-null: zawsze można ich bezpiecznie używać
Nullable: przed użyciem wymagają obsługi

To rozróżnienie przenosi błędy związane z null z awarii w czasie działania do błędów kompilacji.

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat typów nullable i non-null.

Podsumowanie

Poznałeś podstawy bezpieczeństwa wartości null w Kotlinie:

Domyślnie każdy typ jest typu non-null
Dodanie ? tworzy typ nullable
Kompilator blokuje niebezpieczny dostęp do wartości nullable
Sprawdzenie if (x != null) pozwala bezpiecznie używać wartości

W dalszej części poznasz zwięzłe operatory, które ułatwiają pracę z wartościami nullable.

Często zadawane pytania

Czy lekcja „Typy nullable i non-null” jest bezpłatna?

Tak — pełny tekst „Typy nullable i non-null” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Typy nullable i non-null”?

Podstawy systemu typów Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Typy nullable i non-null”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Kotlin Academy