Welche Eigenschaften hat die Arbeit mit Enum-Klassen…

Enum-Klasse — ist ein spezieller Typ von Klasse, der verwendet wird, um eine Menge von Konstanten darzustellen.

Eigenschaften:

Definition von Konstanten: Jede Konstante der Enumeration ist eine Instanz der Enumeration-Klasse.
```
enum class Color {
    RED, GREEN, BLUE
}
```

Eigenschaften und Methoden: Enum-Klassen können Eigenschaften und Methoden haben. Jede Konstante kann sie unterschiedlich implementieren.

enum class Status(val description: String) {
    SUCCESS("Operation erfolgreich"),
    ERROR("Ein Fehler ist aufgetreten"),
    PENDING("Warten")
}

enum class Direction {
    NORTH, SOUTH, EAST, WEST;

    fun getOpposite(): Direction {
        return when (this) {
            NORTH -> SOUTH
            SOUTH -> NORTH
            EAST -> WEST
            WEST -> EAST
        }
    }
}

Anonyme Klassen: Jede Enumeration-Konstante kann mit einer anonymen Klasse deklariert werden, die ihre eigenen Methoden- oder Eigenschafts-Implementierungen bereitstellt.

enum class State {
    IDLE {
        override fun signal() = READY
    },
    READY {
        override fun signal() = IDLE
    }; // Das Semikolon ist vor der Deklaration der Klassenmitglieder erforderlich

    abstract fun signal(): State
}

Implementierung von Schnittstellen: Enum-Klassen können Schnittstellen implementieren.

interface Printable {
    fun printName()
}

enum class Shape : Printable {
    CIRCLE {
        override fun printName() {
            println("Kreis")
        }
    },
    SQUARE {
        override fun printName() {
            println("Quadrat")
        }
    }
}

Eingebaute Eigenschaften: Jede Konstante hat eingebaute Eigenschaften name (Name der Konstante als String) und ordinal (Position der Konstante in der Deklaration, beginnend bei 0).

enum class Priority {
    LOW, MEDIUM, HIGH
}

fun main() {
    println(Priority.MEDIUM.name)    // Ausgabe: MEDIUM
    println(Priority.HIGH.ordinal) // Ausgabe: 2
}

Eingebaute Funktionen:
- enumValues<T>(): Gibt ein Array aller Konstanten in der Enum-Klasse zurück.
- enumValueOf<T>(name: String): Gibt die Konstanten der Enum-Klasse mit dem angegebenen Namen zurück. Wirft IllegalArgumentException, wenn die Konstante nicht gefunden wird.
```
fun main() {
    val allPriorities = enumValues<Priority>()
    println(allPriorities.joinToString()) // Ausgabe: LOW, MEDIUM, HIGH

    val highPriority = enumValueOf<Priority>("HIGH")
    println(highPriority) // Ausgabe: HIGH
}
```

Verwendung in when-Ausdrücken: Ideal für die Verwendung in when. Der Compiler warnt, wenn nicht alle Zweige abgedeckt sind (bei Verwendung als Ausdruck mit Rückgabewert).

fun processStatus(status: Status) {
    when (status) {
        Status.SUCCESS -> println("Erfolg")
        Status.ERROR -> println("Fehler")
        Status.PENDING -> println("Warten")
    }
}

Enum in Kotlin sind mächtiger als ihre Java-Äquivalente, da sie Eigenschaften, Methoden hinzufügen und Schnittstellen implementieren können.

Welche Eigenschaften hat die Arbeit mit Enum-Klassen in Kotlin?