enum Palabra clave en Java

La palabra clave enum en Java se utiliza para definir un conjunto de constantes con nombre. Es un tipo de datos especial que permite que una variable sea un conjunto de constantes predefinidas, lo que hace que el código sea más legible y fácil de mantener. Los Enums se suelen utilizar para representar una colección de constantes relacionadas, como los días de la semana, los meses del año o los estados de un proceso.

Utilización

Los Enums permiten definir una colección de constantes de forma segura. Pueden incluir métodos y campos, y pueden implementar interfaces.

Syntax

enum EnumName {
    CONSTANT1, CONSTANT2, CONSTANT3;
}

• EnumName: El nombre del enum.
• CONSTANT1, CONSTANT2, CONSTANT3: Las constantes definidas dentro del enum.

Ejemplos

Ejemplo 1: Enum básico

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is: " + today);
    }
}

En este ejemplo, se define un enum Day con constantes que representan los días de la semana. A la variable today se le asigna el valor Day.MONDAY, y el programa imprime el día actual.

Ejemplo 2: Enum con métodos

enum Size {
    SMALL, MEDIUM, LARGE;

    public String getSize() {
        switch (this) {
            case SMALL: return "Small Size";
            case MEDIUM: return "Medium Size";
            case LARGE: return "Large Size";
            default: return "Unknown Size";
        }
    }
}

public class EnumWithMethodExample {
    public static void main(String[] args) {
        Size size = Size.MEDIUM;
        System.out.println("Selected size: " + size.getSize());
    }
}

Este ejemplo muestra un enum Size con un método getSize() que devuelve una representación de cadena del tamaño. A la variable size se le asigna Size.MEDIUM, y el programa imprime la descripción del tamaño correspondiente.

Ejemplo 3: Enum con campos y constructor

enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double getMass() {
        return mass;
    }

    public double getRadius() {
        return radius;
    }
}

public class EnumWithFieldsExample {
    public static void main(String[] args) {
        for (Planet planet : Planet.values()) {
            System.out.printf("Planet: %s, Mass: %f, Radius: %f%n", planet, planet.getMass(), planet.getRadius());
        }
    }
}

En este ejemplo, el enum Planet tiene los campos mass y radius, un constructor para inicializar estos campos y métodos getter para acceder a ellos. El programa recorre todas las constantes enum e imprime sus detalles.

Consejos y buenas prácticas

• Uso para Constantes: Utiliza enums para definir un conjunto fijo de constantes, mejorando la legibilidad y mantenibilidad del código.
• Tipo Seguridad: Los Enums proporcionan seguridad de tipo en comparación con las definiciones constantes tradicionales que utilizan final static.
• Declaraciones de cambio: Los Enums funcionan perfectamente con las sentencias switch, lo que hace que el código sea más limpio.

  switch (size) {
      case SMALL:
          // Handle small size
          break;
      case MEDIUM:
          // Handle medium size
          break;
      case LARGE:
          // Handle large size
          break;
  }

• Implementar interfaces: Los Enums pueden implementar interfaces, lo que permite un código más flexible y reutilizable.

  interface Describable {
      String getDescription();
  }
  
  enum Color implements Describable {
      RED, GREEN, BLUE;
  
      @Override
      public String getDescription() {
          return "Color: " + this.name();
      }
  }

• Evita el uso excesivo: Aunque los enums son potentes, evita utilizarlos en exceso para simples constantes. Utilízalos cuando haya un conjunto claro de constantes relacionadas.