java enum java enumeration tutorial with examples
Ce tutoriel développera la classe et le constructeur Java Enum. Nous allons apprendre à utiliser Enum à travers divers exemples de programmation Java:
Il s'agit d'une classe spéciale dont l'explication sera fournie en détail. Un aperçu de la classe Java Enum sera donné avec la liste des méthodes qu'elle prend en charge.
Des programmes suffisants qui implémentent les concepts d'énumération Java et certaines questions fréquemment posées qui peuvent être posées pendant les entretiens sont inclus dans ce didacticiel pour votre compréhension.
=> Vérifiez ici pour voir la série de formations Java pour tous.
Ce que vous apprendrez:
Énumération Java
Une énumération Java n'est rien d'autre qu'une liste de variables d'instance, de méthodes ou de constructeurs. Ce sont un groupe de constantes. Le concept d'énumération a été introduit dans JDK5. La propriété par défaut de chaque constante d'énumération est publique, statique et finale.
mot-clé enum
L'énumération est créée à l'aide d'un mot-clé appelé ' énumération ».
Vous trouverez ci-dessous la syntaxe avec laquelle nous pouvons créer une énumération.
Syntaxe:
énumération nom_type_enuméré
{
énumérateur1, énumérateur2,… énumérateurN;
}
Remarque: enum ne peut être défini qu'à l'intérieur d'une classe ou d'une interface de niveau supérieur ou dans un contexte statique. Cela ne devrait pas être à l'intérieur d'une méthode.
Exemple enum
Dans cet exemple, nous allons initialiser quatre énumérateurs, c'est-à-dire pique, cœur, diamant et club appartenant à un type énuméré appelé cartes.
Ensuite, nous essaierons d'imprimer chacun de ces énumérateurs.
/* * created an enumeration called cards * with four enumerators. */ enum cards { spade, club, heart, diamond; } public class A { public static void main(String() args) { /* * stored each of the enumerators in the * reference variables a1,a2,a3,a4 respectively. * note that the new keyword was not used here */ cards a1 = cards.spade; cards a2 = cards.club; cards a3 = cards.heart; cards a4 = cards.diamond; System.out.println('Enumerators are: '+ a1 + ',' + a2 + ',' + a3 + ',' + a4); } }
Production:
Classe Enum
Une chose que vous devez avoir remarqué dans l'exemple ci-dessus (voir les commentaires) est que nous n'avons pas utilisé de 'Nouveau mot clé' lors de l'instanciation. Bien que les énumérations définissent également une classe Enum et les constructeurs, elles n'utilisent pas de nouveau mot clé.
On peut utiliser les énumérateurs définis de la même manière que la primitive. Enum est une classe générique et toutes les énumérations héritent Enum.
Syntaxe:
// E est le type d'énumération.
class Enum
Comment utiliser Enum en Java
Voyons comment utiliser Enum dans divers scénarios à l'aide d'exemples Java:
À l'intérieur d'une classe
Enum peut être déclaré à l'intérieur ou à l'extérieur (exemple de mot clé enum) d'une classe mais pas à l'intérieur d'une méthode. Ici, nous allons montrer comment enum est déclaré dans une classe.
Dans l'exemple ci-dessous , nous avons créé une énumération à l'intérieur d'une classe, puis nous avons récupéré la valeur ou l'énumérateur à l'aide d'une variable de référence a1.
public class A { /* * created an enumeration called cards * with four enumerators. */ enum cards { spade, club, heart, diamond; } public static void main(String() args) { /* * stored each of the enumerators in the * reference variables a1. * note that the new keyword was not used here */ cards a1 = cards.heart; System.out.println('Card is: '+ a1); } }
Production:
Itération d'énumération à travers des boucles
Ici, nous allons discuter de la façon dont nous pouvons parcourir une énumération. Nous avons déclaré une énumération avec quatre énumérateurs (en dehors d'une classe). Ensuite, nous avons initialisé une boucle pour chaque (à l'intérieur d'une classe) et essayé de récupérer la valeur des énumérateurs.
/* * created an enumeration called games * with four enumerators. */ enum games { ludo, Chess, Badminton, Cricket; } public class A { public static void main(String() args) { /* * used forEach loop and stored the value in 'index' * and printed the value of each enumerator */ System.out.println('Using for each loop'); for (games index:games.values()) { System.out.println(index); } } }
Production:
quel est mon identifiant et mon mot de passe de routeur
Dans if-else
Dans le programme ci-dessous, nous avons créé une énumération avec trois énumérateurs différents, puis stocké l'énumérateur dans la variable de référence pour l'un des énumérateurs spécifiés.
Ensuite, nous avons commencé la vérification de la condition if où nous avons implémenté deux conditions spécifiées avec OR de sorte que si l'une de ces conditions est remplie, il affichera l'instruction spécifiée dans la condition if.
Sinon, il imprimera l'instruction spécifiée dans la condition else.
/* * created an enumeration called players * with three enumerators. */ enum players { sachin, virat, dhoni; } public class A { public static void main(String() args) { /* * stored enumerator in reference variable a1 for * contant dhoni */ players a1 = players.dhoni; /* * Started if statement with OR condition. * If any of these conditions are met then it will * print the statement specified inside if statement */ if(a1 == players.virat || a1 == players.sachin) { System.out.println('Sachin and Virat are greatest batsmen'); } /* * if none of the above condition is met then it will * print the below specified statement */ else { System.out.println('Dhoni is the best Captain'); } } }
Production:
Dans l'instruction Switch
Dans le programme ci-dessous, nous avons créé une énumération avec quatre recenseurs. Ensuite, nous avons stocké l'un des énumérateurs dans la variable de référence. Ensuite, nous avons initialisé une instruction Switch et vérifié chacun de ces énumérateurs.
Lors de l'occurrence de cet énumérateur particulier, il imprimera l'instruction spécifiée dans le cas particulier.
/* * created an enumeration called players * with four enumerators. */ enum players { sachin, dravid, virat, dhoni; } public class A { public static void main(String() args) { /* * stored enumerator in reference variable a1 for * contant dravid */ players a1 = players.dravid; /* * Started Switch Statement and if the element * matches with a1 then it will print the statement * specified in the case */ switch(a1) { // does not match case sachin: System.out.println('Sachin is best bastman ever'); break; // matches case dravid: System.out.println('Dravid is the best Test Batsman'); break; // does not match case virat: System.out.println('Virat is modern great'); break; // does not match case dhoni: System.out.println('Dhoni is the best captain ever'); break; } } }
Production:
Champ d'énumération et méthodes
Champ Enum
Cette section explique le champ enum en détail. Nous pouvons ajouter des champs à l'énumération Java et chaque énumérateur obtient ces champs. La valeur du champ doit être affectée au constructeur de l'énumération.
Dans la syntaxe ci-dessous, nous pouvons voir qu'une énumération a été définie avec trois énumérateurs. A côté de chaque énumérateur, nous avons défini un champ de type int. ( Par exemple. - (3), (2) et (1) respectivement).
Cela résume que Java enum a un constructeur qui prend un int. Ce constructeur définit le champ int. Lorsqu'un énumérateur est défini, cette valeur int (spécifiée pour cet énumérateur) est transmise au constructeur.
Syntaxe:
public enum A { /* * calls a contructor with value * defined on the respective enumerator */ Enumerator1(3), Enumerator2(2), Enumerator3(1) /* * semicolon needed for the last enumerator * if there is a method following it. */ ; private final int constant; private A(int constant) { this.constant = constant; } }
Remarque: Par exemple sur le champ Enum, veuillez vous référer à la section ' Constructeur Enum ».
Méthodes d'énumération
# 1) nom ()
public final String name () - Renvoie le nom de la constante appelante (inchangé ou inchangé).
# 2) égale ()
public final boolean equals (Object other) - Renvoie true si obj et l'objet appelant font référence à la même constante.
# 3) toString
public String toString () - Renvoie le nom de la constante d'appel. Ne correspond pas nécessairement au nom utilisé dans la déclaration de l’énumération.
# 4) cloner
Clone d'objet final protégé ()
throws CloneNotSupportedException - Cela signifie que l'énumération lèvera une exception lors de la tentative de clonage.
# 5) hashCode ()
public final int hashCode () - Renvoie le code de hachage de l'objet appelant.
# 6) finaliser ()
protected final void finalize () - la classe enum ne peut pas avoir de méthodes finalisées. Aucune valeur de retour.
# 7) compareTo ()
public final int compareTo (E obj) - Ceci compare l'énumération avec l'objet spécifié obj. Il retourne négatif si l'objet est inférieur à l'objet spécifié. Il renvoie positif si cet objet est supérieur à l'objet spécifié obj et il renvoie zéro si l'obj spécifié est égal à cet objet.
# 8) getDeclaringClass
public final Class getDeclaringClass () - Renvoie le type d'énumération (également connu sous le nom de classe de déclaration d'énumération) dont la constante d'appel est membre.
# 9) ordinal (), values () et valueOf ()
Toutes ces méthodes font partie du package java.lang.Enum . La méthode ordinal () renvoie l'ordre de la constante d'énumération en fonction de l'index de la constante.
La méthode values () renvoie toutes les valeurs présentes dans l'énumération. La méthode valueOf (String) renvoie la constante d'énumération de la chaîne d'entrée. Si la chaîne spécifiée ne correspond pas à la constante, elle lèvera IllegalArgumentException.
Ci-dessous est l'exemple de programmation où nous avons utilisé le même exemple (comme exemple de mot-clé enum) et implémenté le concept des trois méthodes.
/* * created an enumeration called cards * with four enumerators. */ enum cards { spade, club, heart, diamond; } public class A { public static void main(String() args) { /* * created an array arr() which will store the * value of the constants/enumerators declared in the enumeration */ cards arr() = cards.values(); /* * used forEach loop and stored the value in 'type' * and printed the value as well as index with the help of * ordinal() method */ for (cards type:arr) { System.out.println(type + ' occurs at ' + type.ordinal()); } /* * passed heart as an input String which matches with the * constant declared in 'cards' */ System.out.println(cards.valueOf('heart')); } }
Production:
Constructeur Enum
Enum (car il s'agit également d'une classe) prend en charge le constructeur pour transmettre des données lors de la création d'énumérateurs ou également connu sous le nom de constantes enum.
La propriété principale d'un constructeur enum est qu'il s'agit d'un package privé ou privé. Cela signifie qu'ils sont accessibles dans une classe ou dans un package.
Voyons l'exemple ci-dessous. Ici, nous avons utilisé à la fois la méthode i.e. et le constructeur. Tout d'abord, nous avons créé une énumération nommée «joueurs» qui compte cinq agents recenseurs et le champ.
Ensuite, nous avons un constructeur et une méthode qui renverront le nombre d'exécutions marquées par chaque joueur ou énumérateur ou constante d'énumération.
Par la suite, nous avons la classe principale dans laquelle nous avons utilisé pour chaque boucle la méthode values () pour stocker et itérer chaque énumérateur. De plus, nous avons appelé la méthode du nombre de points marqués par chaque joueur.
/* * Created enumeration players with the field. * Declared a constructor and a method to return * the number of runs scored by the players. */ enum players { dravid(10889), sachin(18426), ganguly(11363), virat(11867), dhoni(10773) ; private int runs; /* * Created enumeration players with the field. * Declared a constructor and a method to return * the number of runs scored by the players. */ enum players { dravid(10889), sachin(18426), ganguly(11363), virat(11867), dhoni(10773) ; private int runs; players(int r) { runs = r; } int getRuns() { return runs; } } /* * Used values() method to get the enumerators and a for each loop * to get the number of runs scored by each player */ public class A { public static void main(String args()) { for (players a : players.values()) System.out.println(a + ' has scored ' + a.getRuns() + ' ODI runs'); } }
Production:
Questions fréquemment posées
Q # 1) Quelle est la différence entre Iterator et Enumeration en Java?
Répondre: Ci-dessous, la différence entre Iterator et Enumeration.
Itérateur | Énumération |
---|---|
C'est un curseur générique qui est utilisé pour itérer des éléments et il est applicable à toute la classe de collection. | Ce n'est pas un curseur générique car il n'est applicable qu'aux classes héritées telles que Enum. Seule l'autorisation de lecture pour une classe de collection. |
Certaines des méthodes sont hasNext (), next () pour l'itération. | Certaines des méthodes sont hasMoreElements (), nextElement () pour l'itération. |
Nous pouvons supprimer l'élément dans une collection en utilisant l'itérateur. | Nous ne pouvons pas supprimer l'élément dans une collection à l'aide de l'énumération car il ne dispose que d'une autorisation de lecture. |
Q # 2) Comment Enum prend en charge l'héritage?
Répondre: Afterall Enum est également une classe en Java, il doit donc prendre en charge l'héritage, qui est un principe de base d'OOPS. Toutes les énumérations étendent la classe java.lang.Enum. Comme une classe ne peut étendre qu'un seul parent, la classe Enum n'en étend aucun autre.
Le toString () qui fait partie de la classe Enum (expliqué dans la section Méthode Enum) est remplacé dans la classe java.lang.Enum.
Conclusion
Dans ce didacticiel, nous avons abordé les énumérations, les énumérateurs, la classe Java Enum et le mot-clé enum avec des exemples et des explications appropriés, le cas échéant. De plus, nous avons donné un aperçu des méthodes importantes associées à la classe Enum avec le champ enum.
Un aperçu du constructeur, enum avec if-else, switch et boucles ont été fournis.
=> Visitez ici pour apprendre Java à partir de zéro.
lecture recommandée
- Tutoriel de classe de scanner Java avec des exemples
- Classe Java Integer et Java BigInteger avec exemples
- Tutoriel Java Float avec des exemples de programmation
- Qu'est-ce que le vecteur Java | Tutoriel de classe vectorielle Java avec des exemples
- TreeMap en Java - Tutoriel avec des exemples de TreeMap Java
- Java Double - Tutoriel avec des exemples de programmation
- Tutoriel sur les classes Java Array - Classe java.util.Arrays avec exemples
- Concepts C #: Constructeur, Destructeur, Classe statique, Struct & Enum