Les classes Enum suscitent beaucoup de controverse dans le monde Android pour un certain nombre de raisons, mais elles s’avèrent toujours utilisées par des développeurs expérimentés jour après jour. Pourquoi en est-il ainsi ?
(Heads up : alors que la syntaxe du code ici va être en Kotlin, toutes les informations ici s’appliquent également aux classes d’enum Java)
Qu’est-ce qu’une classe Enum ?
En termes simples, une Enum est un type de classe spécial qui contient une liste de constantes. L’utilisation la plus courante de ceci est de représenter différents types d’un objet particulier, ou quand une variable ne peut être qu’une seule d’un certain ensemble de valeurs.
enum class Direction { NORTH, SOUTH, EAST, WEST}
Les constantes d’une enum ne nécessitent pas nécessairement une valeur. Sans valeur, elles peuvent être utilisées en validation à travers des ifs et des instructions switch.
val directionToTreasure = Direction.NORTHwhen(directionToTreasure) { Direction.NORTH -> indicateNorth() Direction.SOUTH -> indicateSouth() Direction.EAST -> indicateEast() Direction.WEST -> indicateWest()}
Probablement pas la meilleure façon de gérer ces fonctions d’indication, mais vous avez l’idée. Au moins, ce sera beaucoup de plaisir
Leur utilisation peut cependant être étendue pour inclure des valeurs attachées à chaque constante.
enum class Color(val rgb: Int) { RED(0xFF0000) GREEN(0x00FF00) BLUE(0x0000FF)}
Lorsque vous utilisez les classes d’enum de cette façon, vous pouvez obtenir leur valeur comme suit:
val shirtColour = Color.BLUEval color: Int = shirtColour.rgb
Que peut faire d’autre une Enum ?
Pour le dire en quelques mots, un putain de lot
Premièrement, au lieu de constantes, les enums peuvent être implémentés des classes anonymes avec leurs propres méthodes et en surchargeant les méthodes de base.
enum class ProtocolState yadayada {}
Ils peuvent également implémenter des interfaces d’une manière similaire
enum class IntArithmetics yadayada {}
Finalement, l’enum a deux constantes qui vous fournissent des valeurs assez utiles.
val name: String // The name of the constantval ordinal: Int // The position of the constant in the list of valuesif (shirtColour.name == "BLUE") { // Do some blue stuff}
En fait, grâce à l’utilisation de ces constantes, vous pouvez également mapper de manière pratique entre les types enum et String/Int.
Enum -> Int
yourEnum.ordinal
Int -> Enum
EnumType.values()
String -> Enum
EnumType.valueOf(yourString)
Enum -> String
yourEnum.name
Crédits à ce gars sur StackOverflow pour avoir partagé ce mapping
Quel est le but des classes Enum ?
Je vous comprends, ce n’est pas la chose la plus simple, mais je vais vous renseigner.
Pour la plupart, les classes enum sont utilisées pour produire un code plus lisible. Lorsque vous avez un objet qui peut avoir plusieurs types différents, il est beaucoup plus concis de les identifier avec une valeur lisible qu’un nombre entier arbitraire.
// Bad codewhen(direction) { 0 -> goNorth() 1 -> goSouth() 2 -> goEast() 3 -> goWest()}// Good codewhen(direction) { Direction.NORTH -> goNorth() Direction.SOUTH -> goSouth() Direction.EAST -> goEast() Direction.WEST -> goWest()}
Un autre but utile des Enums sont lorsque vous avez des données qui entrent comme une chaîne de caractères, mais vous devez éventuellement le mapper à une valeur int, comme lorsque votre API donne le type de votre objet, mais vous devez le passer dans un adaptateur RecyclerView qui nécessite un Int pour les types de vue. J’ai personnellement utilisé cette méthode dans ma classe d’enum pour que cela se produise.
@JvmStaticfun getType(type: String): BlockType? = when(type) { "hero" -> ContentHero "products" -> ContentProductList else -> null }
Pourquoi vous ne devriez pas utiliser les classes d’enum
Je parie que maintenant vous pensez « Attendez une seconde. Vous m’avez tout dit sur la façon d’utiliser les Enums et maintenant vous allez juste me dire de ne pas les utiliser ? ». Ecoutez-moi, mon pote.
C’est simple, les Enums sont chers, mon pote ! Je sais que les téléphones mobiles s’améliorent de jour en jour, mais d’une part, il y a encore trop de gens avec des téléphones moins puissants et d’autre part, la façon dont nous faisons des applications et les bibliothèques que nous utilisons utilisent plus de mémoire également.
Ce sont de vieilles nouvelles. Les enums seraient un problème de mémoire pour les téléphones fonctionnant avec Dalvik, mais cela a fondamentalement été abandonné au profit de l’ART (Android Runtime Machine). Ajouté au fait que même les gens dans les pays plus pauvres ont des téléphones assez puissants, et que Proguard peut maintenant optimiser le code mieux que jamais, il est sûr de dire que les Enums ne causent plus de problème de performance.
Il y a encore quelques alternatives que vous pouvez utiliser qui peuvent obtenir des résultats similaires à une classe Enum.
Constants
Les constantes sont super concises aussi. Elles détiennent une seule valeur et lui donnent un nom. Ils sont également extrêmement légers.
*Def
L’annotation *Def est également excellente si vous avez une variable qui ne prend que certaines valeurs.
@IntDef({RED, GREEN, BLUE})
Pourquoi toujours choisir les Enums sur ces alternatives ?
Là où l’enum brille beaucoup plus que ses frères et sœurs fonctionnels est l’exhaustivité. Lorsqu’il est utilisé avec Kotlin, vous pouvez utiliser une instruction switch comme ceci
val foo = when(someEnum) {}
Et lorsque vous le faites, vous êtes obligé de gérer un cas pour chaque constante de votre enum, sinon votre code ne compilera pas. Avec les constantes et les annotations *def, le mieux que vous obtenez donné sont des avertissements lint. Les enums conduisent simplement à un code plus sûr.
(Crédits à u/-manabreak de Reddit pour cela)
Alors, tant que votre utilisation des enums conduit à un code plus concis pour votre application et surtout dans le cas de Kotlin, une meilleure sécurité de cas, par tous les moyens, énumérer à votre cœur.