Les énumérations

Chapitres traités    Les types énumérés Les classes d'énumération

Très souvent, nous avons besoin d'utiliser des constantes. Les constantes demande une syntaxe relativement longue à saisir. Par ailleurs, certaines constantes correspondent à un tronc commun qu'il serait souhaitable de regrouper dans une même entité. C'est notamment le cas avec les cartes à jouer, les jours de la semaine, etc.

Les énumérations permettent d'associer un ensemble de constantes et d'en faire un nouveau type. Les variables de ce nouveau type ne peuvent alors prendre une valeur, uniquement dans la liste des énumérations proposées.

Les types énumérés

Une variable ne doit quelquefois contenir qu'un jeu de valeurs limités. Vous pouvez par exemple réaliser un logiciel manipulant un jeu de cartes. La couleur des cartes étant respectivement Pique, Coeur, Carreau ou Trèfle. Bien sûr, ces couleurs de carte pourraient être codées sous forme d'entier 1, 2, 3, 4. Mais cette configuration est sujette à erreur. Une variable représentant la couleur de carte dans ce contexte peut trop facilement contenir une valeur erronée comme 0 ou 10.

Depuis le JDK 5.0, vous pouvez définir votre propre type énuméré dès qu'une situation se présente. Un type énuméré possède un nombre fini de valeurs nommées. Par exemple :

enum Couleur {Pique, Coeur, Carreau, Trèfle};

Vous pouvez maintenant déclarer des variables de ce nouveau type :

Couleur carte = Couleur.Coeur;

Les classes d'énumération

Le type Couleur que nous venons de définir est en fait une classe. la classe possède exactement quatre instances ; il n'est pas possible de construire de nouveaux objets. Vous n'avez donc jamais besoin d'utiliser la méthode equals() pour les valeurs de type énumérés. Utiliser simplement == pour les comparer.

Vous pouvez, si vous le souhaitez, ajouter des constructeurs, des méthodes et des attributs à un type énuméré. Bien entendu, les constructeurs ne sont invoqués que lorsque les constantes énumérées sont construites.

enum Couleur {
    Pique("P") , Coeur("Co") , Carreau("Ca") , Trèfle("T") ;   // création (construction) de chaque énumérateur (4 objets de type Couleur)
    private String abréviation;
    
    private Couleur(String abréviation) { this.abréviation = abréviation; }
    public String getAbrévation() { return abréviation; }
}

La classe Enum

Tous les types énumérés sont des sous-classes de la classe Enum. Ils héritent de plusieurs méthodes de cette classe.

La méthode la plus utile est toString(), qui renvoie le nom de la constante énumérée. Par exemple, Couleur.Coeur.toString() renvoie la chaîne "Coeur".

L'inverse de toString() est la méthode statique valueOf() :

Couleur carte = (Couleur) Enum.valueOf(Couleur.class, "Coeur") ; // carte <-- Couleur.Coeur

Chaque type énuméré possède une méthode de valeurs statiques qui renvoie un tableau de toutes les valeurs de l'énumération :

Couleur[] values = Couleur.values() ;

Exemple d'utilisation de l'énumération Couleur :

import java.util.Scanner;
import static java.lang.System.*;

public class Enumération {
   public static void main(String[] args) {
      Scanner clavier = new Scanner(in);
      out.print("Choisissez votre couleur de carte :  (Pique, Coeur, Carreau, Trèfle) : ");
      Couleur couleurCarte = Enum.valueOf(Couleur.class, clavier.next());
      
      out.println("Couleur de la carte : "+couleurCarte);
      out.println("abréviation : "+couleurCarte.getAbréviation());
      
      switch (couleurCarte) {
         case Pique : 
         case Trèfle : out.println("Le noir est à l'honneur"); break;
         case Coeur :  
         case Carreau :   out.println("Rouge"); break;
      }
      for (Couleur couleur : Couleur.values())
         out.println(couleur);
   }   
}

enum Couleur {
    Pique("P") , Coeur("Co") , Carreau("Ca") , Trèfle("T") ;   
    private String abréviation;
    
    private Couleur(String abréviation) { this.abréviation = abréviation; }
    public String getAbrévation() { return abréviation; }
}

Exploitation de ce programme :