Java Language Déclarer et utiliser un enum de base


Exemple

Enum peut être considéré comme du sucre syntaxique pour une classe scellée qui n'est instanciée que plusieurs fois au moment de la compilation pour définir un ensemble de constantes.

Un simple enum pour énumérer les différentes saisons serait déclaré comme suit:

public enum Season {
    WINTER,
    SPRING,
    SUMMER,
    FALL
}

Bien que les constantes enum ne doivent pas nécessairement être en majuscules, la convention Java stipule que les noms des constantes sont entièrement en majuscules, les mots étant séparés par des traits de soulignement.


Vous pouvez déclarer un Enum dans son propre fichier:

/**
 * This enum is declared in the Season.java file.
*/
public enum Season {
    WINTER,
    SPRING,
    SUMMER,
    FALL
}

Mais vous pouvez également le déclarer dans une autre classe:

 public class Day {

    private Season season;

    public String getSeason() {
        return season.name();
    }

    public void setSeason(String season) {
        this.season = Season.valueOf(season);
    }

    /**
     * This enum is declared inside the Day.java file and 
     * cannot be accessed outside because it's declared as private.
     */
    private enum Season {
        WINTER,
        SPRING,
        SUMMER,
        FALL
    }

}

Enfin, vous ne pouvez pas déclarer un Enum dans un corps de méthode ou un constructeur:

public class Day {

    /**
     * Constructor
    */
    public Day() {
        // Illegal. Compilation error
        enum Season {
            WINTER,
            SPRING,
            SUMMER,
            FALL
        }
    }

    public void aSimpleMethod() {
        // Legal. You can declare a primitive (or an Object) inside a method. Compile!
        int primitiveInt = 42;

        // Illegal. Compilation error.
        enum Season {
            WINTER,
            SPRING,
            SUMMER,
            FALL
        }

        Season season = Season.SPRING;
    }
    
}

Les constantes énumérées en double ne sont pas autorisées:

public enum Season {
    WINTER,
    WINTER, //Compile Time Error : Duplicate Constants
    SPRING,
    SUMMER,
    FALL
} 

Chaque constante d'énum est public , static et final par défaut. Comme chaque constante est static , il est possible d'y accéder directement en utilisant le nom enum.

Les constantes enum peuvent être transmises comme paramètres de méthode:

public static void display(Season s) {
    System.out.println(s.name());  // name() is a built-in method that gets the exact name of the enum constant
}

display(Season.WINTER);  // Prints out "WINTER"

Vous pouvez obtenir un tableau des constantes enum en utilisant la méthode values() . Les valeurs sont garanties dans l'ordre de déclaration dans le tableau renvoyé:

Season[] seasons = Season.values();

Remarque: cette méthode alloue un nouveau tableau de valeurs à chaque appel.


Pour parcourir les constantes énumérées:

public static void enumIterate() {
    for (Season s : Season.values()) {
        System.out.println(s.name());
    }
}

Vous pouvez utiliser des énumérations dans une déclaration de switch :

public static void enumSwitchExample(Season s) {
    switch(s) {
        case WINTER:
            System.out.println("It's pretty cold");
            break;
        case SPRING:
            System.out.println("It's warming up");
            break;
        case SUMMER:
            System.out.println("It's pretty hot");
            break;
        case FALL:
            System.out.println("It's cooling down");
            break;
    }
}

Vous pouvez également comparer les constantes énumérées en utilisant == :

Season.FALL == Season.WINTER    // false
Season.SPRING == Season.SPRING  // true

Une autre façon de comparer les constantes d'énumération consiste à utiliser les equals() comme ci-dessous, ce qui est considéré comme une mauvaise pratique car vous pouvez facilement tomber dans des pièges comme suit:

Season.FALL.equals(Season.FALL); // true
Season.FALL.equals(Season.WINTER); // false
Season.FALL.equals("FALL"); // false and no compiler error

De plus, bien que l'ensemble d'instances dans l' enum ne puisse pas être modifié au moment de l'exécution, les instances elles-mêmes ne sont pas intrinsèquement immuables car, comme toute autre classe, une enum peut contenir des champs mutables.

public enum MutableExample {
    A,
    B;

    private int count = 0;

    public void increment() {
        count++;
    }

    public void print() {
        System.out.println("The count of " + name() + " is " + count);
    }
}

// Usage:
MutableExample.A.print();       // Outputs 0
MutableExample.A.increment();
MutableExample.A.print();       // Outputs 1 -- we've changed a field   
MutableExample.B.print();       // Outputs 0 -- another instance remains unchanged

Cependant, une bonne pratique consiste à rendre les instances d' enum immuables, c'est-à-dire que lorsqu'elles n'ont pas de champs supplémentaires ou que tous ces champs sont marqués comme final et qu'ils sont immuables eux-mêmes. Cela garantira que pour une durée de vie de l'application, une enum ne enum pas de mémoire et qu'il est prudent d'utiliser ses instances sur tous les threads.


Enums implémentent implicitement Serializable et Comparable car la classe Enum fait:

public abstract class Enum<E extends Enum<E>>
extends Object
implements Comparable<E>, Serializable