Java Enum (enum)

Une enum Java est une classe spéciale qui représente généralement un ensemble de constantes, telles que les 4 saisons d'une année, les 12 mois d'une année, les 7 jours d'une semaine, et des directions comme l'est, le sud, l'ouest, le nord, etc.

Les classes enum Java sont définies à l'aide du mot-clé enum, chaque constante étant séparée par une virgule,pour les séparer.

Par exemple, définissez une classe enum pour les couleurs.

enum Color 
{ 
    RED, GREEN, BLUE; 
}

La classe enum Color ci-dessus a les constantes de couleur RED, GREEN, BLUE, représentant respectivement le rouge, le vert et le bleu.

Exemple d'utilisation :

Exemple

enum Color
{
    RED, GREEN, BLUE;
}
 
public class Test
{
    // Exécuter et afficher le résultat
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

L'exécution du code ci-dessus produit la sortie :

RED

Utilisation des énumérations dans les classes internes

Les classes d'énumération peuvent également être déclarées dans des classes internes :

Exemple

public class Test
{
    enum Color
    {
        RED, GREEN, BLUE;
    }
 
    // Exécuter et afficher le résultat
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

L'exécution du code ci-dessus produit la sortie :

RED

Chaque énumération est implémentée en interne via Class, et toutes les valeurs d'énumération sont public static final.

La classe d'énumération Color ci-dessus est transformée en l'implémentation de classe interne suivante :

class Color
{
     public static final Color RED = new Color();
     public static final Color BLUE = new Color();
     public static final Color GREEN = new Color();
}

Itération sur les éléments d'énumération

Vous pouvez utiliser une instruction for pour parcourir les éléments d'énumération :

Exemple

enum Color
{
    RED, GREEN, BLUE;
}
public class MyClass {
  public static void main(String[] args) {
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  }
}

L'exécution du code ci-dessus produit la sortie :

RED
GREEN
BLUE

Utilisation des classes enum dans switch

Les classes enum sont souvent utilisées dans les instructions switch :

Exemple

enum Color
{
    RED, GREEN, BLUE;
}
public class MyClass {
  public static void main(String[] args) {
    Color myVar = Color.BLUE;

    switch(myVar) {
      case RED:
        System.out.println("Red");
        break;
      case GREEN:
         System.out.println("Green");
        break;
      case BLUE:
        System.out.println("Blue");
        break;
    }
  }
}

L'exécution du code ci-dessus produit la sortie :

Blue

Les méthodes values(), ordinal() et valueOf()

Les classes d'énumération définies avec enum héritent par défaut de la classe java.lang.Enum et implémentent les interfaces java.lang.Serializable et java.lang.Comparable.

Les méthodes values(), ordinal() et valueOf() sont situées dans la classe java.lang.Enum :

  • values() renvoie toutes les valeurs de la classe enum.
  • La méthode ordinal() permet de trouver l'index de chaque constante enum, comme un index de tableau.
  • La méthode valueOf() renvoie la constante enum correspondant à la valeur de chaîne spécifiée.

Exemple

enum Color
{
    RED, GREEN, BLUE;
}
 
public class Test
{
    public static void main(String[] args)
    {
        // Appeler values()
        Color[] arr = Color.values();
 
        // Parcourir l'énumération
        for (Color col : arr)
        {
            // Afficher l'index
            System.out.println(col + " à l'index " + col.ordinal());
        }
 
        // Utilisez valueOf() pour renvoyer une constante d'énumération ; une IllegalArgumentException sera levée si elle n'existe pas
        System.out.println(Color.valueOf("RED"));
        // System.out.println(Color.valueOf("WHITE"));
    }
}

L'exécution du code ci-dessus produit la sortie :

RED at index 0
GREEN at index 1
BLUE at index 2
RED

Membres de la classe d'énumération

Comme les classes ordinaires, les énumérations peuvent avoir leurs propres variables, méthodes et constructeurs. Les constructeurs ne peuvent utiliser que le modificateur d'accès private, ils ne peuvent donc pas être appelés de l'extérieur.

Les énumérations peuvent contenir à la fois des méthodes concrètes et des méthodes abstraites. Si une classe d'énumération possède des méthodes abstraites, chaque instance de la classe d'énumération doit les implémenter.

Exemple

enum Color
{
    RED, GREEN, BLUE;
 
    // Constructeur
    private Color()
    {
        System.out.println("Constructeur appelé pour : " + this.toString());
    }
 
    public void colorInfo()
    {
        System.out.println("Couleur universelle");
    }
}
 
public class Test
{    
    // Sortie
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}

L'exécution du code ci-dessus produit la sortie :

Constructor called for : RED
Constructor called for : GREEN
Constructor called for : BLUE
RED
Universal Color
Autres extensions