0Pricing
Android Academy · Lektion

Datenklassen und versiegelte Klassen

Verwenden Sie Datenklassen für wertbasierte Gleichheit und copy() sowie versiegelte Klassen für vollständige Typhierarchien und eine übersichtliche Modellierung von Zuständen.

Datenklassen und versiegelte Klassen ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Datenklassen?

Eine Datenklasse in Kotlin ist eine Klasse, deren Hauptzweck darin besteht, Daten zu speichern. Der Compiler generiert automatisch nützliche Methoden für Sie:

  • equals() — zwei Instanzen nach ihrem Wert vergleichen
  • hashCode() — konsistenter Hashwert auf Grundlage der Eigenschaften
  • toString() — lesbare Zeichenkettendarstellung
  • copy() — eine geänderte Kopie erstellen
  • Unterstützung für Destrukturierung

Eine Data Class deklarieren

Fügen Sie das Schlüsselwort data vor class ein. Alle Eigenschaften müssen sich im primären Konstruktor befinden:

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() — Ein Feld ändern

copy() erstellt eine neue Instanz mit einigen geänderten Eigenschaften. Das Original wird nicht geändert (Immutabilität):

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

Destrukturierende Deklarationen

Data Classes unterstützen die Destrukturierung — Eigenschaften werden mithilfe der vom Compiler generierten componentN()-Funktionen in Variablen entpackt:

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

Was sind Sealed Classes?

Eine Sealed Class ist eine eingeschränkte Klassenhierarchie — alle Unterklassen müssen in derselben Datei definiert werden. Dadurch ist die Menge der möglichen Typen zur Compile-Zeit bekannt.

Verwenden Sie Sealed Classes, um eine endliche Menge von Zuständen darzustellen, etwa Netzwerkergebnisse, UI-Zustände oder Navigationsereignisse.

Syntax von Sealed Classes

Deklarieren Sie Unterklassen direkt innerhalb der Klasse oder in derselben Datei:

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 (vollständig)

Die Stärke von Sealed Classes: when ist vollständig. Der Compiler zwingt Sie, jeden Untertyp zu behandeln — kein Fall wird vergessen:

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 im Vergleich zu Enum

Beide stellen eine feste Menge von Werten dar, aber:

  • Enum — jede Konstante ist eine einzelne Instanz und enthält keine zusätzlichen Daten pro Variante
  • Sealed Class — jede Variante kann unterschiedliche Daten enthalten und eine Klasse oder ein Objekt sein

Verwenden Sie Enum, wenn die Varianten keine Daten benötigen. Verwenden Sie eine Sealed Class, wenn die Varianten unterschiedliche Eigenschaften benötigen.

Object-Deklarationen (Singletons)

object erstellt ein Singleton — eine einzige Instanz, die verzögert und threadsicher erzeugt wird:

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

Ein Companion Object befindet sich innerhalb einer Klasse und stellt klassenbezogene Member bereit (ähnlich wie static in Java). Es wird häufig für Factory-Methoden verwendet:

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
}

Data Classes in einer echten App

Kombinieren Sie Data Classes mit Sealed Classes, um Zustände übersichtlich zu modellieren:

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

Schnelltest

Welche Aussage beschreibt am besten, wodurch sich Sealed Classes von regulären abstrakten Klassen unterscheiden?

Zusammenfassung: Data & Sealed Classes

Sie verfügen jetzt über zwei leistungsstarke Kotlin-Werkzeuge:

  • data class — wertbasierte Gleichheit, copy(), Destrukturierung, automatisch generiertes toString()
  • sealed class — endliche Typhierarchie, vollständiges when, jede Variante kann eigene Daten enthalten
  • object — Singleton, Companion Objects für Factory-Methoden

Zusammen ersetzen diese Muster den Java-Boilerplate-Code und ermöglichen eine übersichtliche, sichere Zustandsmodellierung.

Häufig gestellte Fragen

Ist die Lektion „Datenklassen und versiegelte Klassen“ kostenlos?

Ja — der vollständige Text von „Datenklassen und versiegelte Klassen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Datenklassen und versiegelte Klassen“?

Verwenden Sie Datenklassen für wertbasierte Gleichheit und copy() sowie versiegelte Klassen für vollständige Typhierarchien und eine übersichtliche Modellierung von Zuständen. Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Datenklassen und versiegelte Klassen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Null-Sicherheit
  2. Klassen und Objekte
  3. Datenklassen und versiegelte Klassen
  4. Erweiterungs- und höherwertige Funktionen
← Zurück zu Android Academy