Android Academy · Les

Dataklassen en sealed classes

Gebruik dataklassen voor waardegelijkheid en copy() en sealed classes voor uitputtende typehiërarchieën en een overzichtelijke modellering van toestanden.

Les 3 van 413 stappen

Dataklassen en sealed classes is een gratis Android Academy-les op CoddyKit. Dit is les 3 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 Android Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Android Academy bevat in totaal 4 lessen.

Wat zijn dataklassen?

Een dataklasse in Kotlin is een klasse met als hoofddoel het opslaan van gegevens. De compiler genereert automatisch nuttige methoden voor je:

equals() — twee instanties vergelijken op basis van waarde
hashCode() — een consistente hash op basis van eigenschappen
toString() — een leesbare tekenreeksweergave
copy() — een aangepaste kopie maken
Ondersteuning voor destructurering

Een dataklasse declareren

Voeg het sleutelwoord data toe vóór class. Alle eigenschappen moeten in de primaire constructor staan:

data class User(val id: Int, val name: String, val email: String)

fun main() {
    val u1 = User(1, "Alice", "alice@example.com")
    val u2 = User(1, "Alice", "alice@example.com")

    println(u1)          // User(id=1, name=Alice, email=alice@example.com)
    println(u1 == u2)    // true  (value equality)
    println(u1 === u2)   // false (different objects)
}

copy() — één veld aanpassen

copy() maakt een nieuwe instantie met enkele gewijzigde eigenschappen. Het origineel wordt niet aangepast (onveranderlijkheid):

data class Product(val name: String, val price: Double, val inStock: Boolean)

fun main() {
    val original = Product("Laptop", 999.0, true)

    // Only change the price; keep everything else
    val onSale = original.copy(price = 799.0)

    println(original)  // Product(name=Laptop, price=999.0, inStock=true)
    println(onSale)    // Product(name=Laptop, price=799.0, inStock=true)
}

Destructurerende declaraties

Dataklassen ondersteunen destructurering — pak eigenschappen uit in variabelen met behulp van de door de compiler gegenereerde functies componentN():

data class Point(val x: Int, val y: Int)

fun main() {
    val point = Point(10, 20)

    // Destructure into separate variables
    val (x, y) = point
    println("x=$x, y=$y")   // x=10, y=20

    // Also works in for loops with maps
    val scores = mapOf("Alice" to 95, "Bob" to 88)
    for ((name, score) in scores) {
        println("$name: $score")
    }
}

Wat zijn sealed classes?

Een sealed class is een beperkte klassenhiërarchie — alle subklassen moeten in hetzelfde bestand worden gedefinieerd. Daardoor is de verzameling mogelijke typen al tijdens het compileren bekend.

Gebruik sealed classes om een eindige verzameling toestanden weer te geven, zoals netwerkresultaten, UI-toestanden of navigatiegebeurtenissen.

Syntaxis van een sealed class

Declareer subklassen rechtstreeks binnen dezelfde klasse of in hetzelfde bestand:

sealed class NetworkResult<out T> {
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val message: String, val code: Int = 0) : NetworkResult<Nothing>()
    object Loading : NetworkResult<Nothing>()
}

fun handle(result: NetworkResult<String>) {
    when (result) {
        is NetworkResult.Success -> println("Data: ${result.data}")
        is NetworkResult.Error  -> println("Error ${result.code}: ${result.message}")
        NetworkResult.Loading   -> println("Loading...")
    }
}

Sealed class + when (volledig)

De kracht van sealed classes: when is volledig. De compiler dwingt je om elk subtype af te handelen — er worden geen gevallen vergeten:

sealed class UiState {
    object Loading : UiState()
    data class Success(val message: String) : UiState()
    data class Error(val error: String) : UiState()
}

fun render(state: UiState): String = when (state) {
    is UiState.Loading      -> "Showing spinner"
    is UiState.Success      -> "Show: ${state.message}"
    is UiState.Error        -> "Error: ${state.error}"
    // Compiler error if you remove any branch!
}

fun main() {
    println(render(UiState.Loading))
    println(render(UiState.Success("Loaded!")))
}

Sealed class versus enum

Beide geven een vaste verzameling waarden weer, maar:

Enum — elke constante is één instantie, zonder extra gegevens per variant
Sealed class — elke variant kan verschillende gegevens bevatten en een klasse of een object zijn

Gebruik enum wanneer varianten geen gegevens nodig hebben. Gebruik een sealed class wanneer varianten verschillende eigenschappen nodig hebben.

Objectdeclaraties (singeltons)

object maakt een singleton — één instantie, lui aangemaakt en threadveilig:

object AppConfig {
    const val BASE_URL = "https://api.example.com"
    const val TIMEOUT = 30L

    fun buildUrl(path: String) = "$BASE_URL/$path"
}

fun main() {
    println(AppConfig.BASE_URL)          // https://api.example.com
    println(AppConfig.buildUrl("users")) // https://api.example.com/users
}

Companion objects

Een companion object bevindt zich in een klasse en biedt leden op klasseniveau (zoals static in Java). Ze worden vaak gebruikt voor fabrieksmethoden:

class Token private constructor(val value: String) {
    companion object {
        fun create(raw: String): Token {
            val cleaned = raw.trim()
            require(cleaned.isNotEmpty()) { "Token must not be blank" }
            return Token(cleaned)
        }
    }
}

fun main() {
    val token = Token.create("  abc123  ")
    println(token.value)  // abc123
}

Dataklassen in een echte app

Combineer dataklassen met sealed classes voor een duidelijke modellering van toestanden:

data class Post(val id: Int, val title: String, val body: String)

sealed class PostState {
    object Loading : PostState()
    data class Loaded(val posts: List<Post>) : PostState()
    data class Failed(val reason: String) : PostState()
}

fun showState(state: PostState) = when (state) {
    PostState.Loading        -> println("Fetching posts...")
    is PostState.Loaded      -> println("${state.posts.size} posts loaded")
    is PostState.Failed      -> println("Failed: ${state.reason}")
}

fun main() {
    showState(PostState.Loaded(listOf(
        Post(1, "Hello", "World"),
        Post(2, "Kotlin", "Rocks")
    )))
}

Korte controle

Welke uitspraak beschrijft het best waardoor sealed classes verschillen van gewone abstracte klassen?

Beantwoord dit in de interactieve les

Samenvatting: data- en sealed classes

Je beschikt nu over twee krachtige Kotlin-hulpmiddelen:

data class — gelijkheid op basis van waarden, copy(), destructurering en automatisch gegenereerde toString()
sealed class — eindige typehiërarchie, volledige when en varianten die hun eigen gegevens kunnen bevatten
object — singleton en companion objects voor fabrieksmethoden

Samen vervangen deze patronen veel standaardcode uit Java en maken ze een duidelijke, veilige modellering van toestanden mogelijk.

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: 36
Lessen: 152

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Dataklassen en sealed classes” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Android Academy, waaronder “Dataklassen en sealed classes”, 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 Android Academy bevat in totaal 4 lessen.

Wat leer ik in “Dataklassen en sealed classes”?

Gebruik dataklassen voor waardegelijkheid en copy() en sealed classes voor uitputtende typehiërarchieën en een overzichtelijke modellering van toestanden. Je oefent met Android 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 Android Academy te beginnen?

Ervaring vooraf is niet nodig. Android 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 3 van 4.

Hoe lang duurt de les “Dataklassen en sealed classes”?

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 Android Academy?

Ja. Elke les over Android 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

Null safety
Klassen en objecten
Dataklassen en sealed classes
Extension functions en higher-order functions

← Terug naar Android Academy