Quelles sont les caractéristiques du travail avec les…

La classe enum est un type spécial de classe utilisé pour représenter un ensemble de constantes.

Caractéristiques:

Définition des constantes: Chaque constante d'une énumération est une instance de la classe d'énumération.
```
enum class Color {
    RED, GREEN, BLUE
}
```

Propriétés et méthodes: Les classes enum peuvent avoir des propriétés et des méthodes. Chaque constante peut les implémenter différemment.

enum class Status(val description: String) {
    SUCCESS("Opération réussie"),
    ERROR("Une erreur est survenue"),
    PENDING("En attente")
}

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

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

Classes anonymes: Chaque constante d'énumération peut être déclarée avec une classe anonyme fournissant ses propres implémentations de méthodes ou propriétés.

enum class State {
    IDLE {
        override fun signal() = READY
    },
    READY {
        override fun signal() = IDLE
    }; // La point-virgule est obligatoire avant de déclarer les membres de la classe

    abstract fun signal(): State
}

Implémentation d'interfaces: La classe enum peut implémenter des interfaces.

interface Printable {
    fun printName()
}

enum class Shape : Printable {
    CIRCLE {
        override fun printName() {
            println("Cercle")
        }
    },
    SQUARE {
        override fun printName() {
            println("Carré")
        }
    }
}

Propriétés intégrées: Chaque constante possède des propriétés intégrées name (nom de la constante en tant que chaîne) et ordinal (position de la constante dans la déclaration, à partir de 0).
```
enum class Priority {
    LOW, MEDIUM, HIGH
}

fun main() {
    println(Priority.MEDIUM.name)    // Affiche: MEDIUM
    println(Priority.HIGH.ordinal) // Affiche: 2
}
```
Fonctions intégrées:
- enumValues<T>(): Renvoie un Array de toutes les constantes dans la classe enum.
- enumValueOf<T>(name: String): Renvoie la constante de la classe enum avec le nom donné. Lance IllegalArgumentException si la constante n'est pas trouvée.
```
fun main() {
    val allPriorities = enumValues<Priority>()
    println(allPriorities.joinToString()) // Affiche: LOW, MEDIUM, HIGH

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

Utilisation dans les expressions when: Idéal pour être utilisé dans when. Le compilateur avertira si toutes les branches ne sont pas couvertes (lorsqu'utilisé comme expression avec une valeur de retour).

fun processStatus(status: Status) {
    when (status) {
        Status.SUCCESS -> println("Succès")
        Status.ERROR -> println("Erreur")
        Status.PENDING -> println("En attente")
    }
}

Les enums en Kotlin sont plus puissants que leurs homologues en Java, permettant d'ajouter des propriétés, des méthodes et d'implémenter des interfaces.

Quelles sont les caractéristiques du travail avec les classes Enum en Kotlin?