Una enumeración es un tipo especial de tipo de datos que es básicamente una colección (conjunto) de constantes. En este tutorial aprenderemos cómo usar enumeraciones en Java y cuáles son los posibles escenarios en los que podemos usarlas.

Así es como definimos Enum

public enum Directions{
  EAST, 
  WEST, 
  NORTH, 
  SOUTH
}

Aquí tenemos una variable Indicaciones de tipo de enumeración, que es una colección de cuatro constantes ESTE, OESTE, NORTE y SUR.

Cómo asignar un valor a un tipo de enumeración?

Directions dir = Directions.NORTH;

La variable dir es de tipo Directions (que es un tipo de enumeración). Esta variable puede tomar cualquier valor, entre los cuatro valores posibles (ESTE, OESTE, NORTE, SUR). En este caso, se establece en NORTE.

Uso de tipos de enumeración en declaraciones If-Else

Así es como podemos usar una variable enum en una lógica if-else.

/* You can assign any value here out of
 * EAST, WEST, NORTH, SOUTH. Just for the
 * sake of example, I'm assigning to NORTH
 */
Directions dir = Directions.NORTH;  

if(dir == Directions.EAST) {
  // Do something. Write your logic
} else if(dir == Directions.WEST) {
     // Do something else
  } else if(dir == Directions.NORTH) {
     // Do something 
    } else {
        /* Do Something. Write logic for 
         * the remaining constant SOUTH
         */ 
      }

Ejemplo de enumeración

Este es solo un ejemplo para demostrar el uso de enumeraciones. Si comprende la parte central y los conceptos básicos, podrá escribir su propia lógica de acuerdo con los requisitos.

public enum Directions{
	  EAST, 
	  WEST, 
	  NORTH, 
	  SOUTH
}
public class EnumDemo
{
   public static void main(String args[]){
	Directions dir = Directions.NORTH;  
	if(dir == Directions.EAST) {
	    System.out.println("Direction: East");
	} else if(dir == Directions.WEST) {
	    System.out.println("Direction: West");
	  } else if(dir == Directions.NORTH) {
	      System.out.println("Direction: North");
  	    } else {
		System.out.println("Direction: South");
	      }
   }
}

Producción:

Direction: North

Uso de Enum en instrucciones de caso de interruptor

El siguiente es el ejemplo para demostrar el uso de enumeraciones en sentencias switch-case.

public enum Directions{
	  EAST, 
	  WEST, 
	  NORTH, 
	  SOUTH
}
public class EnumDemo
{
   Directions dir;
   public EnumDemo(Directions dir) {
      this.dir = dir;
   }
   public void getMyDirection() {
     switch (dir) {
       case EAST:
          System.out.println("In East Direction");
          break;
                    
       case WEST:
          System.out.println("In West Direction");
          break;
                         
       case NORTH: 
          System.out.println("In North Direction");
          break;
                        
       default:
          System.out.println("In South Direction");
          break;
     }
   }
    
    public static void main(String[] args) {
        EnumDemo obj1 = new EnumDemo(Directions.EAST);
        obj1.getMyDirection();
        EnumDemo obj2 = new EnumDemo(Directions.SOUTH);
        obj2.getMyDirection();
    }
}

Producción:

In East Direction
In South Direction

Cómo iterar a través de una variable Enum

class EnumDemo
{
    public static void main(String[] args) {
    	for (Directions dir : Directions.values()) {
    	    System.out.println(dir);
    	}
    }
}

Este código mostrará las cuatro constantes.

leer  Java Autoboxing y Unboxing con ejemplos

Campos y métodos de enumeración

Tomemos un ejemplo primero, luego lo discutiremos en detalle:

public enum Directions{
  EAST ("E"), 
  WEST ("W"), 
  NORTH ("N"), 
  SOUTH ("S")
  ; 
  /* Important Note: Must have semicolon at
   * the end when there is a enum field or method
   */
  private final String shortCode;
	  
  Directions(String code) {
      this.shortCode = code;
  }
	  
  public String getDirectionCode() {
      return this.shortCode;
  }
}
public class EnumDemo
{
    public static void main(String[] args) {
    	Directions dir = Directions.SOUTH;
    	System.out.println(dir.getDirectionCode());
    	Directions dir2 = Directions.EAST;
    	System.out.println(dir2.getDirectionCode());
    }
}

Producción:

S
E

Como puede ver en este ejemplo, tenemos un campo shortCode para cada una de las constantes, junto con un método getDirectionCode() que es básicamente un método getter para este campo. Cuando definimos una constante como esta EAST ("E"), llame al constructor enum (consulte el constructor Directions en el ejemplo anterior) con el argumento pasado. Esto establece el valor pasado como el valor para el campo constante de enumeración correspondiente [EAST(“E”) => Would call constructor Directions(“E”) => this.shortCode = code => this.shortCode = “E” => shortCode field of constant EAST is set to “E”].

Puntos importantes a tener en cuenta:

1) Al definir Enum, las constantes deben declararse primero, antes de cualquier campo o método.
2) Cuando hay campos y métodos declarados dentro de Enum, la lista de constantes de enum debe terminar con un punto y coma (;).

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *