La création d'un type Enum permet de limiter les valeurs des variables de ce type à une liste de valeurs prédéfinies.

public enum EnumSample1
{
    ITEM_A,
    ITEM_B;
}

Le mot clé enum indique au compilateur qu'il s'agit d'une instruction spéciale qui nécessite d'être traduite en un code plus développé.
Le code précédent va être traduit en un code +- sous la forme suivante :

public final class EnumSample1 extends java.lang.Enum {
    public static final EnumSample1 ITEM_A = new EnumSample1("ITEM_A", 0);
    public static final EnumSample1 ITEM_B = new EnumSample1("ITEM_B", 1);

    private EnumSample1(String s, int i) {
        super(s, i);
    }
}

Il faut noter qu'il n'est pas possible d'hériter de la classe Enum, le compilateur se plaindra en affichant le message suivant : "The type EnumSample1 may not subclass Enum explicitly".

Comme les enums héritent implicitement de la classe java.lang.Enum, il est possible de redéfinir certaines méthodes de cette classe ou de la classe Objet (exemple la méthode toString).
Il faut, cependant, noter que certaines méthodes ont été redéfinies dans la classe java.lang.Enum et ont été marquées comme finale (exemple la méthode equals) et donc il n'est pas possible de les redéfinir dans les enums.

Sachant que l'implémentation interne du type Enum importe peu aux développeurs, je vais me concentrer dans le reste de cete page sur des exemples d'utilisation des enums.

1. Exemple 1

   package com.mtitek.enums;
   
   enum EnumSample1 {
       ITEM_A,
       ITEM_B;
   }
   
   public class EnumSample1Test {
       public static void main(String[] args) {
           EnumSample1 myEnumSample1 = EnumSample1.ITEM_B;
   
           switch(myEnumSample1) {
               case ITEM_A :
                   System.out.println(EnumSample1.ITEM_A.name() + " : " +  EnumSample1.ITEM_A.ordinal());
                   break;
               case ITEM_B :
                   System.out.println(EnumSample1.ITEM_B.name() + " : " +  EnumSample1.ITEM_B.ordinal());
                   break;
           }
   
           if(myEnumSample1.equals(EnumSample1.ITEM_A)) {
               System.out.println(EnumSample1.ITEM_A.name() + " : " +  EnumSample1.ITEM_A.ordinal());
           } else if(myEnumSample1.equals(EnumSample1.ITEM_B)) {
               System.out.println(EnumSample1.ITEM_B.name() + " : " +  EnumSample1.ITEM_B.ordinal());
           }
   
           if(myEnumSample1 == EnumSample1.ITEM_A) {
               System.out.println(EnumSample1.ITEM_A.name() + " : " +  EnumSample1.ITEM_A.ordinal());
           } else if(myEnumSample1 == EnumSample1.ITEM_B) {
               System.out.println(EnumSample1.ITEM_B.name() + " : " +  EnumSample1.ITEM_B.ordinal());
           }
       }
   }

   Résultat d'exécution du code :

   ITEM_B : 1
   ITEM_B : 1
   ITEM_B : 1

2. Exemple 2
   Il est possible de déclarer un constructeur global pour l'enum (la classe), mais il n'est pas possible de déclarer un constructeur local pour une énumération (élément de l'enum).
   Il est possible de déclarer des attributs (d'instance et statiques) pour l'enum (la classe).
   

   package com.mtitek.enums;
   
   enum EnumSample2 {
       ITEM_A,
       ITEM_B(),
       ITEM_C(100);
   
       // premier constructeur de l'enum
       EnumSample2() {
           this(0);
       }
   
       // deuxième constructeur de l'enum
       EnumSample2(Integer value) {
           setValue(value);
       }
   
       public Integer getValue() {
           return value;
       }
   
       public void setValue(Integer value) {
           this.value = value;
       }
   
       // attribut d'instance
       private Integer value;
   
       // attribut statique
       public final static Integer ENUM_ID = 99999;
   }
   
   public class EnumSample2Test {
       public static void main(String[] args) {
           System.out.println(EnumSample2.ITEM_A.name() + " : " +  EnumSample2.ITEM_A.ordinal() + " : " + EnumSample2.ITEM_A.getValue());
           System.out.println(EnumSample2.ITEM_B.name() + " : " +  EnumSample2.ITEM_B.ordinal() + " : " + EnumSample2.ITEM_B.getValue());
           System.out.println(EnumSample2.ITEM_C.name() + " : " +  EnumSample2.ITEM_C.ordinal() + " : " + EnumSample2.ITEM_C.getValue());
   
           System.out.println("ENUM_ID : " + EnumSample2.ENUM_ID);
       }
   }

   Résultat d'exécution du code :

   ITEM_A : 0 : 0
   ITEM_B : 1 : 0
   ITEM_C : 2 : 100
   ENUM_ID : 99999

3. Exemple 3
   Il est possible de déclarer des méthodes globales pour l'enum (la classe), qui seront visibles en dehors de l'enum (la visibilité dépendra des modificateurs d'accès).
   
   Il est possible de déclarer des méthodes locales pour les énumérations (éléments de l'enum), mais elles ne seront pas visibles en dehors du code des énumérations.
   
   Il est possible de déclarer des méthodes globales abstraites pour l'enum (la classe), mais dans ce cas elles doivent être implémentées par toutes les énumérations.
   
   Il est possible de déclarer des variables locales pour les énumérations (éléments de l'enum), mais elles ne seront pas visibles en dehors du code des énumérations.
   

   package com.mtitek.enums;
   
   enum EnumSample3 {
       ITEM_A {
           // variable locale
           int v1 = 0;
   
           @Override
           public String getGlobalToString() {
               return name() + " : " + ordinal() + " : Global";
           }
       },
       ITEM_B() {
           @Override
           public String getGlobalToString() {
               return name() + " : " + ordinal() + " : Global : " + getLocalToString();
           }
   
           // La méthode est locale et elle est visible uniquement à l'intérieur de l'énumération ITEM_B
           public String getLocalToString() {
               return "Local";
           }
       };
   
       public abstract String getGlobalToString();
   }
   
   public class EnumSample3Test {
       public static void main(String[] args) {
           System.out.println(EnumSample3.ITEM_A.getGlobalToString());
           System.out.println(EnumSample3.ITEM_B.getGlobalToString());
       }
   }

   Résultat d'exécution du code :

   ITEM_A : 0 : Global
   ITEM_B : 1 : Global : Local