Java Enums (Enum)

Dans ce tutoriel, nous allons apprendre les énumérations en Java. Nous allons apprendre à créer et utiliser les énumérations et les classes d'énumération à l'aide d'exemples.

En Java, une énumération est un type qui a un ensemble de valeurs possibles fixes. Nous utilisons la cléwort enum pour déclarer une énumération. Par exemple,

enum Size {　
　　　SMALL, MEDIUM, LARGE, EXTRALARGE　
}

Dans ce cas, nous avons créé une énumération nommée Size.

Les valeurs entre les accolades sont appelées valeurs d'énumération (constantes). Ce sont les seules valeurs que le type d'énumération peut conserver.

Attention :Les constantes d'énumération sont généralement représentées en majuscules.

Laisons-nous prendre un exemple simple.

enum Size {
　　　SMALL, MEDIUM, LARGE, EXTRALARGE
}
class Main {
　　　public static void main(String[] args) {
　　　　　　System.out.println(Size.SMALL);
　　　　　　System.out.println(Size.MEDIUM);
　　　}
}

Résultat de la sortie

SMALL
MEDIUM

Il peut être vu à partir de l'exemple ci-dessus que nous accédons aux valeurs constantes en utilisant les noms d'énumération.

De même, nous pouvons créer une variable de type enum. Par exemple,

Size pizzaSize;

Dans ce cas, pizzaSize est une variable de type Size. Elle ne peut assigner4valeurs.

pizzaSize = Size.SMALL;
pizzaSize = Size.MEDIUM;
pizzaSize = Size.LARGE;
pizzaSize = Size.EXTRALARGE;

Exemple1：Classe enum Java

enum Size {
　SMALL, MEDIUM, LARGE, EXTRALARGE
}
class Test {
　Size pizzaSize;
　public Test(Size pizzaSize) {
　　　this.pizzaSize = pizzaSize;
　}
　public void orderPizza() {
　　　switch(pizzaSize) {
　　　　　case SMALL:
　　　　　　　System.out.println("Je commande une pizza de taille petite.");
　　　　　　　break;
　　　　　case MEDIUM:
　　　　　　　System.out.println("Je commande une pizza de taille moyenne.");
　　　　　　　break;
　　　　　default:
　　　　　　　System.out.println("Je ne sais pas quelle commande passer.");
　　　　　　　break;
　　　}
　}
}
class Main {
　public static void main(String[] args) {
　　　Test t1　= new Test(Size.MEDIUM);
　　　t1.orderPizza();
　}
}

Résultat de la sortie

Je commande une pizza de taille moyenne.

Dans le programme ci-dessus, nous avons créé un type enum Size. Ensuite, nous avons déclaré une variable de type Size appelée pizzaSize.

La variable pizzaSize ne peut assigner4valeurs (SMALL, MEDIUM, LARGE, EXTRALARGE).

La variable pizzaSize a assigné la constante MEDIUM. Sur cette base, une situation de la commande switch case sera imprimée.

Classe enum Java

En Java, le type enum est considéré comme un type spécial de classe. Il est dans Java 5Introduit dans la version.

Une classe enum peut contenir des méthodes et des champs comme une classe classique.

enum Size {
　　　　constant1, constant2, ..., constantN;
　　　　//Méthodes et champs
}

Les constantes enum sont toujours par défaut public static final.

Lors de la création d'une classe enum, le compilateur crée également une instance (objet) pour chaque constante enum.

Exemple2：Classe enum

enum Size{
　　　SMALL, MEDIUM, LARGE, EXTRALARGE;
　　　public String getSize() {
　　　　　　//ceci renverra l'objet SMALL
　　　　　　switch(this) {
　　　　　　　　　case SMALL:
　　　　　　　　　　return "small";
　　　　　　　　　case MEDIUM:
　　　　　　　　　　return "medium";
　　　　　　　　　case LARGE:
　　　　　　　　　　return "large";
　　　　　　　　　case EXTRALARGE:
　　　　　　　　　　return "extra large";
　　　　　　　　　default:
　　　　　　　　　　return null;
　　　　　　}
　　　}
　　　public static void main(String[] args) {
　　　　　　//Appel de la méthode getSize() avec l'objet SMALL
　　　　　　System.out.println("La taille de la pizza est ",　+　Size.SMALL.getSize());
　　　}
}

Résultat de la sortie

La taille de la pizza est small

Dans l'exemple ci-dessus, nous avons créé une classe d'énumération Size. Elle possède quatre constantes SMALL, MEDIUM, LARGE et EXTRALARGE.

Comme Size est une classe d'énumération, le compilateur crée automatiquement une instance pour chaque constante d'énumération.

À l'intérieur de la méthode main(), nous avons utilisé l'instance SMALL pour appeler la méthode getSize().

Comme les classes conventionnelles, les classes d'énumération peuvent également contenir un constructeur. Pour plus d'informations, veuillez consulterJava enum constructor.

Les méthodes de la classe d'énumération

Les classes d'énumération contiennent quelques méthodes prédéfinies qui peuvent être utilisées à tout moment.

La méthode ordinal()

La méthode ordinal() retourne la position de la constante d'énumération. Par exemple,

ordinal(SMALL)　
//retourne 0

La méthode compareTo()

La méthode compareTo() compare les constantes d'énumération en fonction de leur valeur d'ordre. Par exemple,

Size.SMALL.compareTo(Size.MEDIUM)
　//retourne ordinal(SMALL)　-　ordinal(MEDIUM)

La méthode toString()

La méthode toString() retourne la représentation sous forme de chaîne de la constante d'énumération. Par exemple,

SMALL.toString()
//retourne "SMALL"

La méthode name()

La méthode name() retourne sous forme de chaîne le nom de définition de la constante d'énumération. La valeur retournée par la méthode name() est final. Par exemple,

name(SMALL)
//retourne "SMALL"

La méthode valueOf()

La méthode valueOf() utilise une chaîne de caractères et retourne la constante d'énumération ayant le même nom de chaîne. Par exemple,

Size.valueOf("SMALL")
//retourne la constante SMALL

La méthode values()

La méthode values() retourne un tableau de type d'énumération contenant toutes les constantes d'énumération. Par exemple,

Size[] enumArray = Size.value();

Pourquoi utiliser l'énumération Java ?

In Java, enums were introduced to replace the use of int constants.

Suppose we used a collection of int constants.

class Size {
　　　public final static int SMALL =　1;
　　　public final static int MEDIUM =　2;
　　　public final static int LARGE =　3;
　　　public final static int EXTRALARGE =　4;
}

　Here, if we print the constants, the problem arises. This is because it only prints numbers, which may not be helpful.

Therefore, we can simply use enums instead of using int constants. For example,

enum Size {
　　　SMALL, MEDIUM, LARGE, EXTRALARGE
}

This makes our code more intuitive.

Similarly, enums provide compile-time type safety.

If we declare a variable of the Size type (as shown in the example above), we can ensure that the variable will hold one of the four values. If we try to pass a value outside of these four, the compiler will throw an error.