Travailler avec des énumérations dans Kotlin

1. Vue d'ensemble

Dans ce didacticiel, nous allons approfondir les énumérations Kotlin.

Avec l'évolution des langages de programmation, l'utilisation et l'application des énumérations ont également progressé.

Aujourd'hui, les constantes Enum ne sont pas simplement de simples collections de constantes - elles peuvent avoir des propriétés, implémenter des interfaces et bien plus encore.

Pour les débutants de Kotlin, consultez cet article sur les bases de Kotlin - Introduction au langage Kotlin.

2. Enums de base Kotlin

Regardons les bases des énumérations dans Kotlin.

2.1. Définition des énumérations

Définissons une énumération comme ayant trois constantes décrivant les types de cartes de crédit:

enum class CardType { SILVER, GOLD, PLATINUM }

2.2. Initialisation des constantes Enum

Les énumérations en Kotlin, tout comme en Java, peuvent avoir un constructeur. Étant donné que les constantes enum sont des instances d'une classe Enum , les constantes peuvent être initialisées en passant des valeurs spécifiques au constructeur.

Spécifions les valeurs de couleur à différents types de cartes:

enum class CardType(val color: String) { SILVER("gray"), GOLD("yellow"), PLATINUM("black") }

Nous pouvons accéder à la valeur de couleur d'un type de carte spécifique avec:

val color = CardType.SILVER.color

3. Énumération des constantes en tant que classes anonymes

Nous pouvons définir un comportement de constante d'énumération spécifique en les créant en tant que classes anonymes. Les constantes doivent alors remplacer les fonctions abstraites définies dans la définition Enum .

Par exemple, pour chaque type de carte, nous pouvons avoir un calcul de remise en argent différent.

Voyons comment nous pouvons l'implémenter:

enum class CardType { SILVER { override fun calculateCashbackPercent() = 0.25f }, GOLD { override fun calculateCashbackPercent() = 0.5f }, PLATINUM { override fun calculateCashbackPercent() = 0.75f }; abstract fun calculateCashbackPercent(): Float }

Nous pouvons invoquer les méthodes surchargées des classes constantes anonymes avec:

val cashbackPercent = CardType.SILVER.calculateCashbackPercent()

4. Enums Implémentation des interfaces

Disons qu'il existe une interface ICardLimit qui définit les limites de carte de différents types de cartes:

interface ICardLimit { fun getCreditLimit(): Int }

Voyons maintenant comment notre enum peut implémenter cette interface:

enum class CardType : ICardLimit { SILVER { override fun getCreditLimit() = 100000 }, GOLD { override fun getCreditLimit() = 200000 }, PLATINUM { override fun getCreditLimit() = 300000 } }

Pour accéder à la limite de crédit d'un type de carte, nous pouvons utiliser la même approche que dans l'exemple précédent:

val creditLimit = CardType.PLATINUM.getCreditLimit()

5. Constructions Enum courantes

5.1. Obtenir des constantes Enum par nom

Pour obtenir une constante enum par son nom String , nous utilisons la fonction statique valueOf () :

val cardType = CardType.valueOf(name.toUpperCase())

5.2. Itération des constantes Enum

Pour parcourir toutes les constantes enum, nous utilisons la fonction statique values ​​() :

for (cardType in CardType.values()) { println(cardType.color) }

5.3. Méthodes statiques

Pour ajouter une fonction «statique» à une énumération, nous pouvons utiliser un objet compagnon :

companion object { fun getCardTypeByName(name: String) = valueOf(name.toUpperCase()) }

Nous pouvons maintenant invoquer cette fonction avec:

val cardType = CardType.getCardTypeByName("SILVER")

Notez que Kotlin n'a pas de concept de méthodes statiques . Ce que nous avons montré ici est un moyen d'obtenir les mêmes fonctionnalités qu'en Java, mais en utilisant les fonctionnalités de Kotlin.

6. Conclusion

Cet article fait une introduction aux énumérations en langage Kotlin et à ses principales fonctionnalités.

Nous avons introduit quelques concepts simples comme la définition des énumérations et l'initialisation des constantes. Nous avons également montré des fonctionnalités avancées telles que la définition des constantes enum en tant que classes anonymes et les enums implémentant des interfaces.

L'implémentation de tous ces exemples et extraits de code se trouve dans le projet GitHub. Il s'agit d'un projet Maven, il devrait donc être facile à importer et à exécuter tel quel.