Kotlin Academy · Les

Nullable- en non-nulltypen

De basis van het typesysteem

Les 1 van 413 stappen

Nullable- en non-nulltypen is een gratis Kotlin Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Waarom nullveiligheid belangrijk is

De beruchte NullPointerException heeft talloze programma's laten crashen. Kotlin pakt dit probleem rechtstreeks aan door nullbaarheid onderdeel te maken van het typesysteem.

In Kotlin weet de compiler of een waarde null kan zijn of niet, en dwingt de compiler je om die mogelijkheid af te handelen voordat je problemen krijgt.

Niet-nulltypen

Standaard is elk type in Kotlin niet-null. Een variabele van het type String kan nooit null bevatten.

Deze garantie wordt tijdens het compileren afgedwongen, zodat je de waarde zonder controles kunt gebruiken.

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

Toewijzing van null wordt geweigerd

Als je null in een niet-nulltype probeert te plaatsen, stopt de compiler onmiddellijk.

De onderstaande regel kan niet worden gecompileerd, omdat String geen null accepteert:

val name: String = null → fout

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

Nullable typen

Voeg een vraagteken toe na het type om null toe te staan: String?.

Dit is een nullable type. Het kan een echte waarde of null bevatten.

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

Nullable versus niet-null

De twee declaraties lijken bijna identiek, maar gedragen zich heel verschillend:

val a: String → nooit null
val b: String? → kan null zijn

Het ene ? verandert het volledige contract van de variabele.

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

De compiler beveiligt toegang tot nullable waarden

Je kunt niet rechtstreeks methoden aanroepen op een nullable waarde. De compiler weigert dit, omdat de waarde null kan zijn.

De onderstaande regel kan niet worden gecompileerd:

maybe.length op een String? → fout

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

Controleren op null

Een eenvoudige manier om een nullable waarde te gebruiken is een expliciete controle met if.

Binnen het if-blok weet Kotlin dat de waarde niet null is en kun je deze veilig gebruiken.

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

Null in functieparameters

Ook parametertypen volgen deze regel. Een parameter van het type String moet een echte waarde ontvangen, terwijl String? null accepteert.

Zo maken functiesignaturen duidelijk wat een functie accepteert.

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

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

Nullable retourtypen

Functies kunnen nullable typen retourneren om aan te geven dat een resultaat kan ontbreken.

De aanroeper moet de mogelijke null vervolgens afhandelen voordat het resultaat wordt gebruikt.

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

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

Automatische typeafleiding

Wanneer je een letterlijke waarde toewijst, leidt Kotlin automatisch een niet-nulltype af.

val n = "text" → afgeleid als String

Om het type nullable te maken, moet je het type expliciet met ? declareren.

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

Alles samenbrengen

Het typesysteem deelt waarden op in twee duidelijke groepen:

Niet-null: altijd veilig te gebruiken
Nullable: moet vóór gebruik worden afgehandeld

Door dit onderscheid veranderen nullproblemen van runtimecrashes in compileerfouten.

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

Korte toets

Toets je begrip van nullable en niet-nulltypen.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt de basis van Kotlin-nullveiligheid geleerd:

Elk type is standaard niet-null
Met ? maak je een nullable type
De compiler blokkeert onveilige toegang tot nullable waarden
Met een controle if (x != null) kun je de waarde veilig gebruiken

Vervolgens leer je de beknopte operatoren waarmee werken met nullable waarden eenvoudig wordt.

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Nullable- en non-nulltypen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Nullable- en non-nulltypen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “Nullable- en non-nulltypen”?

De basis van het typesysteem Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Nullable- en non-nulltypen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Kotlin Academy