Kotlin Academy · Lektion

Enums mit when

Vollständige Fallbehandlung

Lektion 3 von 413 Schritte

Enums mit when ist eine kostenlose Kotlin 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 Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Enums passen gut zu when

Der Ausdruck when ist die natürliche Möglichkeit, anhand eines Enums zu verzweigen. Jede Konstante erhält ihren eigenen Zweig.

enum class Light { RED, YELLOW, GREEN }

fun action(l: Light) = when (l) {
    Light.RED -> "Stop"
    Light.YELLOW -> "Slow"
    Light.GREEN -> "Go"
}

fun main() {
    println(action(Light.GREEN))
}

Vollständigkeit

Wenn when als Ausdruck für ein Enum verwendet wird und jede Konstante abdeckt, ist kein else-Zweig erforderlich. Der Compiler überprüft die Vollständigkeit.

enum class Coin { HEADS, TAILS }

fun flip(c: Coin) = when (c) {
    Coin.HEADS -> "Win"
    Coin.TAILS -> "Lose"
}

fun main() {
    println(flip(Coin.HEADS))
}

Der Compiler passt auf

Wenn Sie später eine neue Konstante hinzufügen, aber einen Zweig vergessen, meldet der Compiler einen Fehler. Dadurch lassen sich Enums zusammen mit when sehr sicher weiterentwickeln.

enum class Size { S, M, L }

fun label(s: Size) = when (s) {
    Size.S -> "Small"
    Size.M -> "Medium"
    Size.L -> "Large"
}

fun main() {
    println(label(Size.M))
}

Konstanten importieren

Sie können Enum-Member importieren, um innerhalb von when das Typpräfix wegzulassen und die Zweige kürzer zu machen.

enum class Dir { UP, DOWN }

import Dir.UP
import Dir.DOWN

fun move(d: Dir) = when (d) {
    UP -> "y + 1"
    DOWN -> "y - 1"
}

fun main() {
    println(move(Dir.UP))
}

Zweige zusammenfassen

Mehrere Konstanten können denselben Zweig verwenden, wenn Sie sie durch Kommas getrennt auflisten.

enum class Day { MON, TUE, WED, SAT, SUN }

fun kind(d: Day) = when (d) {
    Day.SAT, Day.SUN -> "Weekend"
    else -> "Weekday"
}

fun main() {
    println(kind(Day.SAT))
}

Unterschiedliche Typen zurückgeben

Jeder Zweig kann einen Wert erzeugen. Das gesamte when wird dann zu diesem Wert.

enum class Tier { FREE, PRO }

fun limit(t: Tier): Int = when (t) {
    Tier.FREE -> 10
    Tier.PRO -> 1000
}

fun main() {
    println(limit(Tier.PRO))
}

when ohne Argument

Sie können auch anhand von Bedingungen verzweigen. Bei Enums ist jedoch die Form mit Subjekt am übersichtlichsten und ermöglicht die Vollständigkeitsprüfung.

enum class Mood { HAPPY, SAD }

fun emoji(m: Mood) = when (m) {
    Mood.HAPPY -> ":)"
    Mood.SAD -> ":("
}

fun main() {
    println(emoji(Mood.HAPPY))
}

Seiteneffekte in Zweigen

Zweige können Anweisungen ausführen und nicht nur Werte zurückgeben.

enum class Cmd { START, STOP }

fun run(c: Cmd) {
    when (c) {
        Cmd.START -> println("Starting...")
        Cmd.STOP -> println("Stopping...")
    }
}

fun main() {
    run(Cmd.START)
}

else möglichst vermeiden

Die Verwendung von else verhindert die Vollständigkeitsprüfung: Eine neue Konstante würde stillschweigend in else fallen. Bevorzugen Sie bei Enums explizite Zweige.

enum class State { ON, OFF }

fun text(s: State) = when (s) {
    State.ON -> "on"
    State.OFF -> "off"
}

fun main() {
    println(text(State.OFF))
}

Ein realistischer Router

Benutzerrollen auf Berechtigungen abzubilden, ist eine übersichtliche Anwendung von vollständig abdeckendem when.

enum class Role { ADMIN, USER, GUEST }

fun canDelete(r: Role) = when (r) {
    Role.ADMIN -> true
    Role.USER -> false
    Role.GUEST -> false
}

fun main() {
    println(canDelete(Role.ADMIN))
}

Mit Eigenschaften kombinieren

Sie können anhand eines Enums verzweigen und innerhalb der Zweige auch dessen Eigenschaften verwenden.

enum class Coin(val cents: Int) { PENNY(1), DIME(10) }

fun describe(c: Coin) = when (c) {
    Coin.PENNY -> "Worth ${c.cents}"
    Coin.DIME -> "Worth ${c.cents}"
}

fun main() {
    println(describe(Coin.DIME))
}

Kurze Überprüfung

Testen Sie Ihr Verständnis von Enums mit when.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben gelernt, Enums mit when zu kombinieren:

when für ein Enum kann ohne else vollständig sein.
Der Compiler stellt sicher, dass alle Konstanten abgedeckt sind.
Fassen Sie Konstanten mit Kommas zusammen. Jeder Zweig liefert einen Wert.
Vermeiden Sie else, damit die Sicherheit durch die Vollständigkeitsprüfung erhalten bleibt.

enum class Light { RED, GREEN }

fun go(l: Light) = when (l) {
    Light.RED -> false
    Light.GREEN -> true
}

fun main() {
    println(go(Light.GREEN))
}

Kostenlos starten

Lerne Kotlin mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 51
Lektionen: 203

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Enums mit when“ kostenlos?

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

Was lerne ich in „Enums mit when“?

Vollständige Fallbehandlung Du übst Kotlin 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 Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin 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 „Enums mit when“?

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 Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin 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

← Zurück zu Kotlin Academy