Programmation Java/Énumérations

Java 5 introduit une nouvelle structure de données appelée énumérations. Cette structure permet de contenir une série de données constantes ayant un type sûr, ce qui veut dire que ni le type, ni la valeur réelle de chaque constante n'est précisé. Il est possible de comparer des valeurs d'une énumération entre elles à l'aide des opérateurs de comparaison et de l'instruction switch.

Programmation Java

Version imprimable

[ Modifier le sommaire ]

Objets comparables et clés

Exceptions

Exemple :

enum Animal { KANGOUROU, TIGRE, CHIEN, SERPENT, CHAT };

class Test
{
    public static void main(String[] args)
    {
        String aniMsg;
        Animal bebete = Animal.TIGRE;
        switch(bebete)
        {
            case KANGOUROU :
                aniMsg = "kangourou";
                break;
            case TIGRE :
                aniMsg = "tigre";
                break;
            case CHIEN :
                aniMsg = "chien";
                break;
            case SERPENT :
                aniMsg = "serpent";
                break;
            case CHAT :
                aniMsg = "chat";
                break;
        }
        System.out.println("L'animal est un "+aniMsg);
    }
}

Membres

Les énumérations sont en fait compilées sous forme de classes, éventuellement internes.

Une énumération peut donc avoir des constructeurs et méthodes. Ses constructeurs sont obligatoirement privés car aucune nouvelle instance ne peut être créée.

enum Animal
{
    // Il faut appeler l'un des constructeurs déclarés :
    KANGOUROU("kangourou", false),
    TIGRE("tigre", false),
    CHIEN("chien", true),
    SERPENT("serpent", false, "tropical"),
    CHAT("chat", true); // <- NB: le point-virgule pour mettre fin à la liste des constantes !

    // Membres :
    private final String environnement;
    private final String nom;
    private final boolean domestique;

    Animal(String nom, boolean domestique)
    { this(nom, domestique, null); }

    Animal(String nom, boolean domestique, String environnement)
    {
        this.nom = nom;
        this.domestique = domestique;
        this.environnement = environnement;
    }

    public String getNom(){ return this.nom; }
    public String getEnvironnement(){ return this.environnement; }
    public boolean isDomestique(){ return this.domestique; }
};

class Test
{
    public static void main(String[] args)
    {
        Animal bebete = Animal.TIGRE;
        System.out.print("L'animal est un "+bebete.getNom());
        System.out.print(bebete.isDomestique()?" (domestique)":" (sauvage)");
        String env = bebete.getEnvironnement();
        if (env!=null)
            System.out.print(" vivant dans un milieu "+env);
        System.out.println();
    }
}

Héritage

Les énumérations sont compilées sous forme de classes finales, ce qui signifie qu'aucune classe ou énumération ne peut en hériter.

Méthodes utiles

Les énumérations possèdent des méthodes communes permettant notamment la conversion entre un membre de l'énumération et un entier ou une chaîne de caractères.

ordinal()

Obtenir l'index de la valeur selon l'ordre de déclaration (premier = 0).

Exemple :

Animal.CHIEN.ordinal() /* -> 2 */

name()

Obtenir le nom de la valeur.

Exemple :

Animal.CHAT.name() /* -> "CHAT" */

valueOf(String s)

(méthode statique) Obtenir la valeur dont le nom est spécifié en paramètre.

Exemple :

Animal.valueOf("CHAT") /* -> Animal.CHAT */

values()

(méthode statique) Obtenir un tableau contenant toutes les valeurs déclarées.

Exemple :

Animal.values()[2] /* -> Animal.CHIEN */

Les énumérations implémentent l'interface java.lang.Comparable et possède donc les méthodes equals et compare pour comparer deux valeurs (ordonnées selon ordinal() par défaut).

Ensemble de valeurs énumérées

Les ensembles (set en anglais) font partie des classes de collection de l'API Java. Il existe une classe spécifique pour les ensembles de valeurs énumérées nommée EnumSet. Cette classe hérite de la classe abstraite java.util.AbstractSet.

Voir les ensembles.

Utilisation comme clé de table associative

Étant donné qu'une énumération ne peut avoir d'autres instances que celles déclarées, elle convient bien comme type de clé dans les tables associatives, comme les collections de classe Map. Exemple :

public void dialogueAnimal()
{
    Map<Animal,String> cri_par_animal = new HashMap<>();
    cri_par_animal.put(Animal.TIGRE, "Grr");
    cri_par_animal.put(Animal.CHAT, "Miaou");

    Animal a = Animal.TIGRE, b = Animal.CHAT;
    System.out.println("Le "+a+" dit « "+cri_par_animal.get(a)+" ! »");
    System.out.println("Le "+b+" répond « "+cri_par_animal.get(b)+" ! »");
}