TOC

Travailler avec des enums à Kotlin

Travailler avec Enums à 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é.

Enum constants today aren’t just mere collections of constants - ils 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 to the Kotlin Language.

2. Enums Kotlin de base

Examinons les bases des enums de Kotlin.

2.1. Définition des énumérations

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

enum class CardType {
    SILVER, GOLD, PLATINUM
}

2.2. Initialisation des constantes Enum

Enums in Kotlin, just like in Java, can have a constructor. Puisque les constantes enum sont des instances d'une classeEnum, 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érer les constantes en tant que classes anonymes

Nous pouvons définir un comportement de constante d'enum 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 deEnum.

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

Voyons comment nous pouvons le mettre en œuvre: 

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 appeler les méthodes écrasées des classes constantes anonymes avec: 

val cashbackPercent = CardType.SILVER.calculateCashbackPercent()

4. Enums Implémentation d'interfaces

Supposons qu'il existe une interfaceICardLimit qui définit les limites de cartes de différents types de cartes: 

interface ICardLimit {
    fun getCreditLimit(): Int
}

Voyons maintenant comment notre énumération 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 nomString, nous utilisons la fonction statiquevalueOf(): 

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

5.2. Itération à travers les constantes Enum

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

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

5.3. Méthodes statiques

Pour ajouter une fonction «statique» à une énumération, nous pouvons utiliser uncompanion object: 

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

Nous pouvons maintenant appeler cette fonction avec: 

val cardType = CardType.getCardTypeByName("SILVER")

Notez que Kotlin n'a pas de concept de méthodesstatic. 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 présente les enums en kotlin et ses principales caractéristiques.

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

L'implémentation de tous ces exemples et extraits de code se trouve dansthe GitHub project. Ceci est un projet Maven, il devrait donc être facile à importer et à exécuter tel quel.

Related