ENUMERACIÓN EN JAVA

En Java, las enumeraciones (enums) son un tipo especial que se utiliza para definir un grupo de constantes con nombre.

Las enumeraciones ayudan a mejorar la legibilidad, el mantenimiento y la seguridad de tipos en los programas al asignar nombres significativos a valores enteros.
Principalmente útil cuando tenemos un pequeño conjunto de valores posibles para un elemento como direcciones, días de la semana, etc.

Creando una enumeración

Sintaxis:

enum NombreEnum {

CONSTANTE1 CONSTANTE2 CONSTANTE3;

}

Java

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

Producción

RED

Declaración de enumeración en Java

La declaración de enumeración se puede realizar fuera de una clase o dentro de una clase, pero no dentro de un método.

1. Declaración fuera de clase

Como hemos visto en el ejemplo anterior, las enumeraciones se pueden declarar fuera de una clase y se puede acceder a ellas directamente

2. Declaración dentro de una clase

Las enumeraciones también se pueden declarar dentro de una clase pero no dentro de un método.

Java

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

Producción

RED

Propiedades de Enum en Java

Hay ciertas propiedades seguidas por Enum como se menciona a continuación:

Tipo de clase: Implementado internamente como una clase.
Constantes de enumeración: Cada constante es un objeto del tipo enum.
Soporte de interruptor: Se puede utilizar en declaraciones de cambio.
Modificadores implícitos: Las constantes son finales estáticas públicas.
Herencia: Las enumeraciones no pueden ampliar las clases, pero pueden implementar interfaces.

Enum en una declaración de cambio

Las enumeraciones se pueden usar en declaraciones de cambio para manejar diferentes casos según las constantes de enumeración.

Java

    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'  );      }      }   }

Producción

Other color

Enum con métodos y constructor

Las enumeraciones pueden tener constructores y métodos ejecutados por separado para cada constante

Java

    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  ();      }   }

Producción

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

Enum con métodos abstractos

Las enumeraciones pueden declarar métodos abstractos que cada constante debe implementar.

Java

    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  ());      }   }

Producción

1st day 5th day

Iterando enumeraciones usando valores()

Utilice EnumType.values() para recorrer todas las constantes de enumeración.

Java

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

Producción

RED GREEN BLUE

Enum y EnumSet (iteración de rango específico)

EnumSet.range() permite la iteración sobre un rango específico de constantes de enumeración.

Java

    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  );      }      }   }

Producción

TUESDAY WEDNESDAY THURSDAY FRIDAY

Crear una clase con un miembro de enumeración

Podemos combinar enumeraciones con clases regulares para organizar la lógica de su programa. Una enumeración puede ser una variable miembro de una clase y los métodos pueden realizar acciones basadas en el valor de la enumeración.

Java

    /*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  ();      }   }

Producción

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

Explicación:

La clase EnumTest en el código anterior se crea con un miembro de tipo Día. Tiene un constructor que toma Day enum como argumento y lo asigna.
La clase tiene el método tellItLikeItIs() que imprime el mensaje según el valor del día.
El método principal incluye objetos de EnumTest que utilizan diferentes valores de enumeración de Día y llaman al método tellItLikeItIs() en cada uno.

NOTA: La nueva palabra clave se usa porque EnumTest es una clase normal, no una enumeración, por lo que creamos instancias y pasamos el valor de enumeración a su constructor.