Que sont les énumérations en Java ?

En Java, les énumérations ou enum sont un type spécial de classe qui représente un groupe de constantes (valeurs immuables), c'est-à-dire un ensemble fixe de valeurs qui ne changent pas au fil du temps , donc toutes les valeurs possibles sont connues au moment de la compilation, par exemple les jours de la semaine, les mois de l'année, les couleurs, etc.

Puisqu'une énumération est un type de classe, vous pourriez penser que nous devons l'instancier pour l'utiliser, cependant, cela n'est pas nécessaire, bien qu'elle ait les mêmes capacités qu'une classe normale, telles que des attributs, des méthodes, des constructeurs et même en implémentant des interfaces, la seule considération est que vous ne pouvez pas implémenter le concept d'héritage dans une énumération. Son objectif principal est de définir nos propres types de données (Enumerated Data Types). Certaines propriétés à mettre en évidence d'une énumération sont :

• Chaque énumération en interne est implémentée en tant que classe utilisant le type de classe.
• Chaque constante d'une énumération représente un objet de type enum.
• Toutes les énumérations étendent implicitement java.lang.Enum, comme une classe ne peut s'étendre qu'à partir d'un parent, une énumération ne peut pas s'étendre à partir d'une autre classe.
• Chaque constante dans une énumération est implicitement de type public static final.
• Ils peuvent être utilisés dans des structures de contrôle telles que des interrupteurs.
• Une méthode main() peut être déclarée dans une énumération.
• La méthode toString() est remplacée pour renvoyer le nom de la constante.

Déclaration d'une énumération

Nous pouvons déclarer une énumération à l'intérieur ou à l'extérieur d'une classe, ou dans un fichier séparé, mais pas à l'intérieur d'une méthode. La syntaxe pour déclarer une énumération est la suivante :

enum NombreEnum {
    CONSTANTE1, CONSTANTE2, CONSTANTE3, ...
}

Par convention les constantes d'une énumération sont écrites en majuscules.
Généralement, la première ligne d'une énumération est la déclaration des constantes, suivie des attributs, méthodes et constructeurs si nécessaire.

// Enum declarado fuera de una clase
enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {}
}

// Enum declarado dentro de una clase
public class Main {
    public static void main(String[] args) {}

    enum Color {
        RED, GREEN, BLUE;
    }
}

Pour accéder à l'une des constantes d'une énumération, il suffit d'utiliser le nom de l'énumération suivi d'un point et du nom de la constante.

Color color = Color.RED;

Ce n'est peut-être pas si nécessaire, mais si nous avons besoin d'obtenir le nom d'une constante telle qu'elle a été déclarée, nous pouvons utiliser la méthode name(), bien que parfois elle soit omise par la méthode toString() au cas où nous en aurions besoin. quelque chose de plus descriptif.

System.out.println(Color.RED.name()); // RED
System.out.println(Color.RED); // RED

Obtenir des constantes à partir d'une énumération

Nous pouvons obtenir toutes les constantes d'une énumération en utilisant la méthode values(), qui renvoie un tableau avec toutes les constantes.

enum NombreEnum {
    CONSTANTE1, CONSTANTE2, CONSTANTE3, ...
}

Dans le cas où nous avons besoin d'obtenir une constante en fonction de son nom, soit parce que nous la recevons en entrée, soit parce que nous l'obtenons à partir d'un fichier ou d'une base de données, nous pouvons utiliser la méthode valueOf(), il suffit de considérer que cela La méthode est sensible à la casse, donc si le nom ne correspond à aucune constante, une IllegalArgumentException sera levée.

// Enum declarado fuera de una clase
enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {}
}

Précédemment, nous avons vu comment obtenir toutes les constantes sous forme de tableau, donc vous vous demandez peut-être s'il est possible d'obtenir l'index d'une constante, la réponse est oui, nous pouvons utiliser la méthode ordinal() pour obtenir l'index d'une constante, tout comme dans un tableau l'index commence à zéro.

// Enum declarado dentro de una clase
public class Main {
    public static void main(String[] args) {}

    enum Color {
        RED, GREEN, BLUE;
    }
}

Utiliser une énumération sur un commutateur

L'un des avantages de l'utilisation d'une énumération est que nous pouvons l'utiliser dans une structure de contrôle de commutateur, ce qui nous permet de simplifier le code et de le rendre plus lisible.

Color color = Color.RED;

Attributs et constructeurs dans une énumération

Chacune des constantes d'une énumération peut avoir des attributs personnalisés, tout comme dans une classe normale, il suffit de considérer qu'il doit y avoir un constructeur qui initialise les attributs, de cette façon lors du chargement des constantes, ce sera appelé implicitement au constructeur correspondant. Sachant que chaque constante est un objet de type enum dans la déclaration il faut passer les valeurs des attributs selon le constructeur.

System.out.println(Color.RED.name()); // RED
System.out.println(Color.RED); // RED

Pour cette énumération, nous avons 3 constantes, chacune avec 3 attributs, nom, niveau et description, en plus d'un attribut de code commun à toutes les constantes, mais il n'a pas besoin d'être initialisé dans le constructeur, puisqu'il est une valeur constante. Chacun des attributs peut avoir différents modificateurs d'accès, tout dépend de nos besoins.

Méthodes dans une énumération

En considérant l'exemple précédent, nous pouvons en déduire que puisque chaque attribut est de type privé, nous avons besoin d'un moyen d'y accéder, nous pouvons donc déclarer des méthodes getter pour chacun des attributs.

Color[] colors = Color.values();

for (Color color : colors) {
    System.out.println(color);
}

On peut aussi déclarer des méthodes utilitaires dans une énumération, par exemple, une méthode qui permet d'obtenir une constante basée sur un niveau. Il suffit de considérer que la méthode doit être statique, puisqu'on ne peut pas instancier une énumération.

enum NombreEnum {
    CONSTANTE1, CONSTANTE2, CONSTANTE3, ...
}

Méthodes abstraites dans une énumération

Nous avons déjà vu comment implémenter des méthodes dans une énumération, mais si nous avons besoin que chaque constante implémente une méthode différemment, nous pouvons déclarer une méthode abstraite et chaque constante doit l'implémenter à sa manière, en considérant qu'avec cela la syntaxe change un peu dans la déclaration des constantes. Par exemple, déclarons une méthode abstraite showPermissions() qui imprime les autorisations de chaque constante via la console.

// Enum declarado fuera de una clase
enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {}
}

Interfaces dans une énumération

Une énumération peut implémenter une ou plusieurs interfaces, de la même manière qu'une classe normale, il suffit de séparer les interfaces par une virgule.

// Enum declarado dentro de una clase
public class Main {
    public static void main(String[] args) {}

    enum Color {
        RED, GREEN, BLUE;
    }
}

EnumSet et EnumMap

Java propose deux classes pour travailler avec enum, EnumSet et EnumMap, qui sont respectivement plus efficaces que les classes HashSet et HashMap, car elles sont conçues pour fonctionner avec enum. EnumSet est une collection d'éléments uniques d'une énumération, tandis qu'EnumMap est une implémentation de Map qui utilise une énumération comme clé.

Color color = Color.RED;

Exemple complet

Nous avons déjà vu les différentes caractéristiques d'une énumération, voyons maintenant un exemple où nous les utilisons toutes.

System.out.println(Color.RED.name()); // RED
System.out.println(Color.RED); // RED

Conclusion

Les énumérations sont une fonctionnalité très utile en Java, car elles nous permettent de définir nos propres types de données, ce qui nous aide à rendre notre code plus lisible et maintenable, tout en nous permettant de travailler avec des constantes plus efficacement. Bien qu'il ne s'agisse pas d'une fonctionnalité nouvelle, il est important de la connaître et de savoir l'utiliser, car dans de nombreux cas, elle peut nous aider à simplifier notre code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!