Wat zijn de kenmerken van werken met Enum-klassen in…

Enum-klasse — dit is een speciaal type klasse dat wordt gebruikt om een set constanten weer te geven.

Kenmerken:

Definitie van constanten: Elke constante van de enumeratie is een instantie van de enum-klasse.
```
enum class Color {
    RED, GREEN, BLUE
}
```

Eigenschappen en methoden: Enum-klassen kunnen eigenschappen en methoden hebben. Elke constante kan deze op verschillende manieren implementeren.

enum class Status(val description: String) {
    SUCCESS("Operatie geslaagd"),
    ERROR("Er is een fout opgetreden"),
    PENDING("In afwachting")
}

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

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

Anonieme klassen: Elke enum-constante kan worden gedeclareerd met een anonieme klasse die eigen implementaties van methoden of eigenschappen biedt.

enum class State {
    IDLE {
        override fun signal() = READY
    },
    READY {
        override fun signal() = IDLE
    }; // Puntkomma is verplicht voordat klassenleden worden gedeclareerd

    abstract fun signal(): State
}

Implementatie van interfaces: Enum-klassen kunnen interfaces implementeren.

interface Printable {
    fun printName()
}

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

Ingebouwde eigenschappen: Elke constante heeft ingebouwde eigenschappen name (naam van de constante als string) en ordinal (positie van de constante in de declaratie, beginnend vanaf 0).

enum class Priority {
    LOW, MEDIUM, HIGH
}

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

Ingebouwde functies:

enumValues<T>(): Geeft een array van alle constanten in de enum-klasse.
enumValueOf<T>(name: String): Geeft de enum-constante met de opgegeven naam. Werpt IllegalArgumentException als de constante niet wordt gevonden.

fun main() {
    val allPriorities = enumValues<Priority>()
    println(allPriorities.joinToString()) // Output: LOW, MEDIUM, HIGH

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

Gebruik in when-uitdrukkingen: Ideaal voor gebruik in when. De compiler waarschuwt als niet alle takken worden afgedekt (bij gebruik als uitdrukking met teruggekeerde waarde).

fun processStatus(status: Status) {
    when (status) {
        Status.SUCCESS -> println("Succes")
        Status.ERROR -> println("Fout")
        Status.PENDING -> println("Wachten")
    }
}

Enums in Kotlin zijn krachtiger dan hun Java-tegenhangers, omdat ze eigenschappen kunnen toevoegen, methoden kunnen hebben en interfaces kunnen implementeren.

Wat zijn de kenmerken van werken met Enum-klassen in Kotlin?