Phenquestions
Syntaxe:
enum public enum_namevaleur1, valeur2,… valeurN
Ici, énumérer le mot-clé est utilisé pour déclarer le type d'énumération, et les valeurs seront n'importe quelle valeur constante. Différentes utilisations du type enum en Java sont présentées dans la partie suivante de ce tutoriel.
Exemple-1 : Déclarer et itérer des valeurs d'énumération
La façon dont les valeurs enum peuvent être définies et accessibles à l'aide de la boucle 'for' est illustrée dans l'exemple suivant. Ici, les noms de sept jours de la semaine sous leur forme abrégée sont attribués en tant que valeurs d'énumération. Ensuite, la boucle 'for' est utilisée pour itérer chaque valeur des jours de la semaine et imprimer chaque valeur de chaque ligne en sortie.
classe publique enum1//Définir le type d'énumération
public enum jours de semaine
Dim, Lun, Mar, Mer, Jeu, Ven, Sam
// méthode principale ()
public static void main(String[] args)
Système.en dehors.println("La forme abrégée de 7 jours de semaine est :");
//Itération des valeurs de enum
pour (jour de la semaine : jours de la semaine.valeurs())
Système.en dehors.println(jour);
Production:
La sortie suivante apparaîtra après l'exécution du code.
Exemple-2 : Utilisation de l'énumération dans l'instruction if-else
L'exemple suivant montre l'utilisation de la variable enum avec l'instruction if-else-if. Ici, une variable enum nommée cours est déclaré avec des codes à quatre cours comme valeurs. La classe contient un constructeur qui initialisera la variable nommée cours par n'importe quelle valeur enum. Ici, un code de cours sera fourni au moment de la création de l'objet, et il sera vérifié avec chaque condition 'if' et imprimer le message où la condition retourne vrai. Si toutes les conditions retournent false, alors le message de la section else sera imprimé.
classe publique enum2//Définir le type d'énumération
cours enum publics
CSE101,CSE205,CSE308,CSE407
//Déclare une variable de type enum
cours cours;
//Déclare le constructeur
public enum2 (cours de cours)
cette.cours = cours;
une
public static void main(String[] args)
//Déclarer un objet
enum2 objet1 = nouveau enum2(cours.CSE205);
//Vérifier la valeur du cours
si(objet1.cours == cours.CSE101)
Système.en dehors.print("Le nom du cours est Computer Fundamental");
else if(objet1.cours == cours.CSE205)
Système.en dehors.print("Le nom du cours est Structure de données");
else if(objet1.cours == cours.CSE308)
Système.en dehors.print("Le nom du cours est Système d'exploitation");
else if(objet1.cours == cours.CSE407)
Système.en dehors.print("Le nom du cours est Programmation Unix");
autre
Système.en dehors.print("Le code du cours n'existe pas");
Production:
Dans le code ci-dessus, valeur enum, CSE205 est fourni au moment de la création de l'objet qui correspond à la deuxième condition 'if' et imprime le message, "Le nom du cours est Structure de données."
Exemple-3 : Utilisation de l'énumération avec le constructeur et la méthode
L'exemple suivant montre comment le constructeur enum et la méthode enum peuvent être définis et utilisés dans Java. Les douze valeurs enum avec des codes sont définies avec les douze mois sous la forme abrégée. Un constructeur d'une énumération avec un paramètre est déclaré dans le code qui initialise la variable entière privée nommée mCode. Une méthode enum nommée lireMCode() est déclaré pour retourner les valeurs de mCode. Dans le principale() méthode, six variables sont déclarées et initialisées avec une chaîne vide pour stocker les valeurs d'énumération particulières en fonction des valeurs de commutation. Ici, la boucle 'for' est utilisée pour itérer chaque valeur enum et déclarer un objet enum basé sur chaque valeur. Lorsqu'un objet enum est créé, le code de la valeur enum correspondante sera initialisé à mCode. La valeur de retour du lireMCode() méthode sera utilisée dans le commutateur pour correspondre aux valeurs de cas. Ici, un bloc particulier d'instructions est défini pour deux valeurs de cas. Par exemple, 0 et 1 seront renvoyés comme mCode pour les mois, JAN et FÉV. Les noms de ces deux mois seront stockés dans la variable s1 et imprimé la valeur en combinant avec une autre chaîne. La même tâche sera effectuée avec les cinq autres variables, s2, s3, s4, s5, et s6, pour les dix autres mois.
Selon le code, L'hiver sera imprimé pour le mois JAN et FÉV. Printemps sera imprimé pour le mois de MAR et AVR. L'été sera imprimé pour le mois de MAI et JUIN. Saison des pluies sera imprimé pour le mois de JUIL et AOT. L'automne sera imprimé pour le mois de SEP et OCT et Fin de l'automne sera imprimé pour le mois de NOV et DÉC.
classe publique enum3public enum Mois
JAN(0),FEB(1),MAR(2),ARP(3),MAI(4),JUN(5),
JUIL(6), AOT(7),SEP(8),OCT(9),NOV(10),DEC(11);
mCode int privé;
//enum constructeur
Mois(int mCode)
cette.mCode = mCode;
// méthode enum
public int readMCode()
retourne ça.mCode ;
// méthode principale ()
public static void main(String[] args)
//Initialisation des variables
Chaîne s1="",s2="",s3="",s4="",s5="",s6="" ;
//Itération des valeurs de enum
pour (Mois mois : Mois.valeurs())
//Déclarer l'objet enum
Mois m = mois ;
commutateur (m.readMCode())
cas 0 :
cas 1:
si(s1.équivaut à(""))
s1=mois.toString();
autre
s1+=" et "+mois.toString();
Système.en dehors.println(s1+" sont l'hiver.");
Pause;
cas 2 :
cas 3 :
si(s2.équivaut à(""))
s2=mois.toString();
autre
s2+=" et "+mois.toString();
Système.en dehors.println (s2+" sont Spring.");
Pause;
cas 4:
cas 5:
si(s3.équivaut à(""))
s3=mois.toString();
autre
s3+=" et "+mois.toString();
Système.en dehors.println(s3+" sont l'été.");
Pause;
cas 6 :
cas 7 :
si(s4.équivaut à(""))
s4=mois.toString();
autre
s4+=" et "+mois.toString();
Système.en dehors.println (s4+" sont la saison des pluies.");
Pause;
cas 8 :
cas 9 :
si(s5.équivaut à(""))
s5=mois.toString();
autre
s5+=" et "+mois.toString();
Système.en dehors.println (s5+" sont l'automne.");
Pause;
cas 10 :
cas 11 :
si(s6.équivaut à(""))
s6=mois.toString();
autre
s6+=" et "+mois.toString();
Système.en dehors.println (s6+" sont la fin de l'automne.");
Pause;
Production:
La sortie suivante apparaîtra après l'exécution du code ci-dessus.
Conclusion:
Lorsque nous devons travailler avec des données constantes, il est préférable d'utiliser la variable enum. Les différentes utilisations du type de données enum sont expliquées dans ce tutoriel pour découvrir les avantages de l'utilisation du type énumération en Java.
