Android Academy · Lektion

Dataklasser och sealed-klasser

Använd dataklasser för värdebaserad likhet och copy(), och sealed-klasser för uttömmande typhierarkier och tydlig modellering av tillstånd.

Lektion 3 av 413 steg

Dataklasser och sealed-klasser är en gratis lektion i Android Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Android Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Android Academy innehåller totalt 4 lektioner.

Vad är dataklasser?

En dataklass i Kotlin är en klass vars främsta syfte är att lagra data. Kompilatorn genererar automatiskt användbara metoder åt Er:

equals() — jämför två instanser efter värde
hashCode() — konsekvent hash baserad på egenskaperna
toString() — läsbar strängrepresentation
copy() — skapar en ändrad kopia
Stöd för destrukturering

Deklarera en dataklass

Lägg till nyckelordet data före class. Alla egenskaper måste finnas i primärkonstruktorn:

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() — ändra ett fält

copy() skapar en ny instans med vissa ändrade egenskaper. Originalet ändras inte (oföränderlighet):

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)
}

Destrukturerande deklarationer

Dataklasser stöder destrukturering — packa upp egenskaper i variabler med hjälp av componentN()-funktioner som kompilatorn genererar:

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")
    }
}

Vad är sealed classes?

En sealed class är en begränsad klasshierarki — alla underklasser måste definieras i samma fil. Därmed är mängden möjliga typer känd vid kompilering.

Använd sealed classes för att representera en ändlig mängd tillstånd, till exempel nätverksresultat, UI-tillstånd eller navigeringshändelser.

Syntax för sealed class

Deklarera underklasser direkt inuti klassen eller i samma fil:

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 (uttömmande)

Det kraftfulla med sealed classes är att when är uttömmande. Kompilatorn tvingar dig att hantera varje undertyp — inga fall glöms bort:

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 jämfört med enum

Båda representerar en fast mängd värden, men:

Enum — varje konstant är en enda instans utan extra data per variant
Sealed class — varje variant kan innehålla olika data och vara en klass eller ett objekt

Använd enum när varianterna inte behöver någon data. Använd sealed class när varianterna behöver olika egenskaper.

Objektdeklarationer (singletons)

object skapar en singleton — en enda instans som skapas lazy och är trådsäker:

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

Ett companion object finns inuti en klass och tillhandahåller medlemmar på klassnivå (ungefär som Javas static). Det används ofta för factory-metoder:

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
}

Dataklasser i en riktig app

Kombinera dataklasser med sealed classes för tydlig tillståndsmodellering:

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")
    )))
}

Snabb kontroll

Vilket påstående beskriver bäst vad som skiljer sealed classes från vanliga abstrakta klasser?

Besvara frågan i den interaktiva lektionen

Sammanfattning: data- och sealed classes

Nu har du två kraftfulla Kotlin-verktyg:

data class — värdebaserad likhet, copy(), destrukturering och automatiskt genererad toString()
sealed class — ändlig typhierarki, uttömmande when, där varje variant kan innehålla sin egen data
object — singleton, samt companion objects för factory-metoder

Tillsammans ersätter dessa mönster Javas standardkod och möjliggör tydlig och säker tillståndsmodellering.

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 36
Lektioner: 152

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Dataklasser och sealed-klasser” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Android Academy, inklusive ”Dataklasser och sealed-klasser”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Android Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Dataklasser och sealed-klasser”?

Använd dataklasser för värdebaserad likhet och copy(), och sealed-klasser för uttömmande typhierarkier och tydlig modellering av tillstånd. Ni övar på Android Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Android Academy?

Du behöver inga förkunskaper. Utbildningen i Android Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Dataklasser och sealed-klasser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Android Academy-lektionen?

Ja. Varje Android Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Nullsäkerhet
Klasser och objekt
Dataklasser och sealed-klasser
Extensionsfunktioner och högre ordningens funktioner

← Tillbaka till Android Academy