Réponse.

En Kotlin, les énumérations (enum class) permettent de déclarer un ensemble de valeurs limitées tout en les étendant avec des méthodes et des propriétés.

Points principaux:

Une enum class est déclarée de manière similaire à Java, mais la syntaxe est plus stricte :
```
enum class Direction {
    NORTH, SOUTH, WEST, EAST
}
```
Les éléments enum sont des singletons, des instances du sous-type correspondant de la classe.

Des propriétés et des méthodes supplémentaires peuvent être définies à l'intérieur de l'enum :

enum class Color(val rgb: Int) {
    RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF);
    fun containsRed() = (rgb and 0xFF0000 != 0)
}

Chaque valeur peut être référencée par son nom (Color.RED.name), son index (ordinal) et obtenir la liste complète via values().
En Kotlin, il n'est pas possible d'hériter des enum classes, mais il est possible d'implémenter des interfaces.
La différence avec Java est qu'il n'est pas possible d'hériter explicitement des classes enum et de ne pas utiliser de listes imbriquées ;
Les enums en Kotlin ne sont pas sérialisés par défaut à l'aide des outils standards (comme Gson ou Jackson) — des adaptateurs/annotations spéciaux sont nécessaires.

Comparaison d'enums :

Les enums sont comparés via == (identité), car les éléments sont uniques.
Lors de la sérialisation, les noms peuvent changer, il est préférable de spécifier explicitement les valeurs (modèle de valeur de stockage).

Question piège.

Peut-on définir une méthode abstraite dans une enum class en Kotlin, comme en Java, afin que chaque élément la redéfinisse ?

Réponse correcte : Oui, il est possible de déclarer une méthode abstraite dans le style enum, et chaque élément doit fournir sa propre implémentation !

enum class State {
    START {
        override fun next() = RUNNING
    },
    RUNNING {
        override fun next() = STOPPED
    },
    STOPPED {
        override fun next() = STOPPED
    };
    abstract fun next(): State
}

Exemples d'erreurs réelles dues à l'ignorance des subtilités du sujet.

Histoire

Lors de la migration de Java vers Kotlin, l'équipe a tenté d'hériter d'une nouvelle enum class comme d'une classe normale — il s'est avéré que l'enum ne peut pas être héritée, ce qui a rompu l'architecture. Il a fallu changer complètement l'approche concernant la modularité des machines à états.

Histoire

Pour stocker une valeur dans la base de données, ils prenaient le nom de l'élément (enum.name), mais avec le refactoring, l'enum a renommer des éléments — les données de la base ne correspondaient plus à la nouvelle logique, il y a eu une perte de cohérence (le modèle de valeur de stockage n'a pas été mis en œuvre).

Histoire

Pour la sérialisation de l'enum class via Gson, ils ont oublié de connecter le TypeAdapter personnalisé. En production, le service a commencé à renvoyer des valeurs JSON incorrectes, car le parseur standard a sérialisé le mauvais champ (ordinal ou name), et la désérialisation ne correspondait pas entre les microservices.