En Java, les énumérations (énumérations) sont un type spécial utilisé pour définir un groupe de constantes nommées.

• Les énumérations contribuent à la lisibilité, à la maintenabilité et à la sécurité des types dans les programmes en attribuant des noms significatifs aux valeurs entières.
• Principalement utile lorsque nous disposons d'un petit ensemble de valeurs possibles pour un élément comme les directions, les jours de la semaine, etc.

Créer une énumération

Syntaxe:

combien de villes aux États-Unis

enum NomEnum {

CONSTANTE1 CONSTANTE2 CONSTANTE3;

}

bordure en utilisant CSS

enum TrafficLight {  RED GREEN YELLOW; } public class Test{    public static void main(String[] args){    TrafficLight x = TrafficLight.RED;  System.out.println(x);  } } 

RED 

Déclaration d'énumération en Java

La déclaration Enum peut être effectuée en dehors d'une classe ou à l'intérieur d'une classe mais pas à l'intérieur d'une méthode.

1. Déclaration hors cours

Comme nous l'avons vu dans l'exemple ci-dessus, les énumérations peuvent être déclarées en dehors d'une classe et accessibles directement

2. Déclaration à l'intérieur d'une classe

Les énumérations peuvent également être déclarées dans une classe mais pas dans une méthode.

public class Test {  enum Color {  RED  GREEN  BLUE;  }  // Driver method  public static void main(String[] args) {  Color c1 = Color.RED;  System.out.println(c1);  } } 

RED 

Propriétés d'Enum en Java

Il existe certaines propriétés suivies par Enum comme mentionné ci-dessous :

liste liée et liste de tableaux

• Type de cours : Implémenté en interne en tant que classe.
• Constantes d'énumération : Chaque constante est un objet de type enum.
• Prise en charge du commutateur : Peut être utilisé dans les instructions switch.
• Modificateurs implicites : Les constantes sont des finales statiques publiques.
• Héritage: Les énumérations ne peuvent pas étendre les classes mais peuvent implémenter des interfaces.

Énumération dans une instruction Switch

Les énumérations peuvent être utilisées dans les instructions switch pour gérer différents cas en fonction des constantes enum.

import java.io.*; class GFG{    // Enum Declared  enum Color {  RED  GREEN  BLUE  YELLOW;  }  public static void main(String[] args){    Color var_1 = Color.YELLOW;  // Switch case with Enum  switch (var_1) {  case RED:  System.out.println('Red color');  break;  case GREEN:  System.out.println('Green color');  break;  case BLUE:  System.out.println('Blue color');  break;  default:  System.out.println('Other color');  }  } } 

Other color 

Enum avec méthodes et constructeur

Les énumérations peuvent avoir des constructeurs et des méthodes exécutés séparément pour chaque constante

enum Color{  RED GREEN BLUE;  private Color(){    System.out.println('Constructor called for: ' + this);  }  public void display(){    System.out.println('Color is: ' + this);  } } public class Test{    public static void main(String[] args){    Color c1 = Color.RED;  c1.display();  } } 

Constructor called for: RED Constructor called for: GREEN Constructor called for: BLUE Color is: RED 

Enum avec des méthodes abstraites

Les énumérations peuvent déclarer des méthodes abstraites que chaque constante doit implémenter.

enum Day{    MONDAY{    public String getNumber(){  return '1st day';     }  }  FRIDAY{    public String getNumber(){  return '5th day';     }  };    public abstract String getNumber(); } public class EnumTest {  public static void main(String[] args){    System.out.println(Day.MONDAY.getNumber());   System.out.println(Day.FRIDAY.getNumber());  } } 

1st day 5th day 

Itération des énumérations à l'aide de valeurs()

Utilisez EnumType.values() pour parcourir toutes les constantes d'énumération.

déclaration de cas Verilog

enum Color{  RED GREEN BLUE;   } public class Test{    public static void main(String[] args){    for (Color c : Color.values()){    System.out.println(c);  }  } } 

RED GREEN BLUE 

Enum et EnumSet (itération de plage spécifique)

EnumSet.range() permet une itération sur une plage spécifique de constantes d'énumération.

import java.util.EnumSet; public class EnumSetExample{    enum Day{    SUNDAY MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY SATURDAY;     }  public static void main(String[] args){    EnumSet<Day> workDays = EnumSet.range(Day.TUESDAY Day.FRIDAY);  for (Day d : workDays){    System.out.println(d);  }  } } 

TUESDAY WEDNESDAY THURSDAY FRIDAY 

Création d'une classe avec un membre Enum

Nous pouvons combiner des énumérations avec des classes régulières pour organiser la logique de votre programme. Une énumération peut être une variable membre dans une classe et les méthodes peuvent effectuer des actions basées sur la valeur de l'énumération.

/*package whatever //do not write package name here */ import java.io.*; enum Day {  MONDAY  TUESDAY  WEDNESDAY  THURSDAY  FRIDAY  SATURDAY  SUNDAY } public class EnumTest {  // Enum member variable  Day day;  // constructor which takes enum value  public EnumTest(Day day) { this.day = day; }  // method to execute action as per enum value  public void tellItLikeItIs()  {  switch (day) {  case MONDAY:  System.out.println('Mondays are tough');  break;  case TUESDAY:  System.out.println('Tuesday are better');  break;  case WEDNESDAY:  System.out.println('Wednesday are okay');  break;  case THURSDAY:  System.out.println('Thursdays are hopeful');  break;  case FRIDAY:  System.out.println('Fridays are exciting');  break;  case SATURDAY:  System.out.println('Saturdays are relaxing');  break;  case SUNDAY:  System.out.println('Sunday are for rest');  break;  default:  System.out.println('Everyday are good');  break;  }  }  public static void main(String[] args)  {  EnumTest firstDay = new EnumTest(Day.MONDAY);  firstDay.tellItLikeItIs();  EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);  thirdDay.tellItLikeItIs();  EnumTest fifthDay = new EnumTest(Day.FRIDAY);  fifthDay.tellItLikeItIs();  EnumTest sixthDay = new EnumTest(Day.SATURDAY);  sixthDay.tellItLikeItIs();  EnumTest seventhDay = new EnumTest(Day.SUNDAY);  seventhDay.tellItLikeItIs();  } } 

Mondays are tough Wednesday are okay Fridays are exciting Saturdays are relaxing Sunday are for rest 

Explication:

• La classe EnumTest dans le code ci-dessus est créée avec un membre de type Day. Il a un constructeur qui prend l'énumération Day comme argument et l'attribue.
• La classe a la méthode tellItLikeItIs() qui imprime le message en fonction de la valeur du jour.
• La méthode principale inclut des objets d'EnumTest utilisant différentes valeurs d'énumération Day et appelant la méthode tellItLikeItIs() sur chacun.

NOTE: Le nouveau mot-clé est utilisé car EnumTest est une classe normale et non une énumération, nous créons donc des instances et transmettons la valeur de l'énumération à son constructeur.