Smart casts
Automatisch casten na controles
Smart casts is een gratis Kotlin Academy-les op CoddyKit. Dit is les 2 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.
Wat zijn slimme casts
Nadat je het type van een waarde hebt gecontroleerd, onthoudt Kotlin dat feit. Binnen het gecontroleerde blok behandelt Kotlin de waarde automatisch als het verfijnde type.
Deze functie heet een slimme cast en maakt handmatige typeconversie overbodig.
Slimme cast na is
Zodra een controle met is slaagt, kun je de waarde als dat type gebruiken zonder een cast te schrijven.
De compiler voegt die voor je in.
fun describe(x: Any) {
if (x is String) {
println(x.length) // x is smart-cast to String
}
}
fun main() {
describe("hello")
}Slimme cast na een null-controle
Slimme casts werken ook voor nullability. Nadat je hebt bevestigd dat een waarde niet null is, wordt deze als niet-null behandeld.
fun length(text: String?): Int {
if (text != null) {
return text.length // smart-cast to non-null String
}
return 0
}
fun main() {
println(length("abc"))
println(length(null))
}Slimme casts in when
Typecontroles binnen when maken ook slimme casts in elke vertakking mogelijk.
Dit is de idiomatische manier om meerdere mogelijke types af te handelen.
fun area(shape: Any): Double = when (shape) {
is Int -> shape.toDouble()
is String -> shape.length.toDouble()
else -> 0.0
}
fun main() {
println(area(5))
println(area("hello"))
}Slimme cast met vroegtijdige return
Als je vroegtijdig terugkeert wanneer een waarde null is, weet de compiler daarna dat de waarde niet null is.
De rest van de functie gebruikt de waarde veilig.
fun process(text: String?) {
if (text == null) return
println(text.uppercase()) // smart-cast here
}
fun main() {
process("data")
process(null)
}Slimme cast met een Elvis-return
Door Elvis te combineren met return activeer je ook een slimme cast voor de resterende code.
fun process(text: String?) {
val safe = text ?: return
println(safe.length) // safe is non-null
}
fun main() {
process("hi")
process(null)
}Gecombineerde voorwaarden
Slimme casts houden rekening met de logica van gecombineerde voorwaarden met &&.
Na de typecontrole aan de linkerkant ziet de rechterkant het verfijnde type al.
fun check(x: Any) {
if (x is String && x.length > 3) {
println("long string")
} else {
println("other")
}
}
fun main() {
check("hello")
check(2)
}Wanneer slimme casts niet werken
Slimme casts vereisen de garantie dat de waarde tussen de controle en het gebruik niet verandert.
Een veranderlijke var die gelijktijdig kan veranderen, krijgt mogelijk geen slimme cast. Gebruik bij voorkeur val voor betrouwbare slimme casts.
fun main() {
val text: String? = "stable"
if (text != null) {
println(text.length) // val smart-casts cleanly
}
}Een lokale val is het veiligst
Als je een waarde naar een lokale val kopieert, worden slimme casts betrouwbaar.
Dit is een veelgebruikt patroon bij het werken met nullable eigenschappen.
class Box(val content: String?)
fun main() {
val box = Box("item")
val c = box.content
if (c != null) {
println(c.uppercase())
}
}Slimme cast versus expliciete cast
Slimme casts vervangen de meeste expliciete as-casts. Ze zijn veiliger omdat ze alleen worden toegepast wanneer het type bewezen is.
Vervolgens leer je meer over expliciete is en as.
fun main() {
val x: Any = "text"
if (x is String) {
// no need for (x as String)
println(x.reversed())
}
}Alles samenbrengen
Met slimme casts kan de compiler types automatisch verfijnen:
- Na
is-controles → cast naar dat type - Na null-controles → cast naar niet-null
- Werken in
if,whenen na vroegtijdige returns - Het betrouwbaarst met
val
fun render(x: Any): String {
if (x is Int) return "number " + x
if (x is String) return "text " + x.uppercase()
return "unknown"
}
fun main() {
println(render(7))
println(render("go"))
}Korte controle
Test je begrip van slimme casts.
Samenvatting
Je hebt geleerd over slimme casts:
- Type- en null-controles verfijnen het type automatisch
- Ze werken in
if,whenen na vroegtijdige returns vallevert de betrouwbaarste slimme casts op
Vervolgens bestudeer je rechtstreeks de operatoren is en as.
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
Veelgestelde vragen
Is de les “Smart casts” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Smart casts”, 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 “Smart casts”?
Automatisch casten na controles 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 2 van 4.
Hoe lang duurt de les “Smart casts”?
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.