Saltar a contenido

🧭 Enum en Java

📚 Índice

  1. 🔰 ¿Qué es realmente un enum?
  2. 🧱 Enum básico
  3. 📦 Enum con atributos y constructor
  4. ⚙️ Enum con métodos
  5. 🎭 Enum con comportamiento (polimorfismo)
  6. 🔌 Enum implementando interfaces
  7. 🧠 Métodos especiales de los enum
  8. 🔀 Uso de enum con switch moderno
  9. ⚠️ Restricciones de los enum
  10. 🚀 Buenas prácticas modernas
  11. 🧠 Conclusión
  12. 💳 Ejemplo real: sistema de pagos

🔰 1. ¿Qué es realmente un enum?

En Java, un enum es una clase especial que representa un conjunto fijo de constantes.

Pero además puede tener:

  • 📦 Atributos
  • 🏗 Constructores
  • ⚙️ Métodos
  • 🎭 Polimorfismo
  • 🔌 Implementar interfaces

Todos los enum extienden (heredan) implícitamente java.lang.Enum.

🧱 2. Enum básico

Este enum ya lo vimos en el tema de tipos de datos, de forma básica. 

enum Dia {
    LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO
}

Uso:

Dia hoy = Dia.LUNES;

📦 3. Enum con atributos y constructor

Aunque muchas veces se usan los enum solo como una lista de constantes, en realidad cada constante es un objeto. Por eso, un enum puede tener atributos, constructores y métodos, igual que una clase normal.

  • 🔹 Los constructores de un enum siempre son privados (aunque no lo escribas).

Esto permite asociar información adicional a cada constante.

Por ejemplo, imagina que queremos representar niveles de prioridad y asignar a cada uno un número:

enum Prioridad {

    //1️⃣ Cada constante del enum se crea como si fuera un objeto:
    BAJA(1),
    MEDIA(2),
    ALTA(3);
    /*
    Eso significa que Java está haciendo algo conceptualmente parecido a esto:
        new Prioridad(1)
        new Prioridad(2)
        new Prioridad(3)
    */

    private final int nivel;

    //2️⃣ El valor que aparece entre paréntesis se pasa al constructor del enum.
    Prioridad(int nivel) {
        //3️⃣ Ese constructor guarda el valor en el atributo nivel.
        this.nivel = nivel;
    }

    //4️⃣ Después podemos acceder a ese dato con un método:
    public int getNivel() {
        return nivel;
    }
}

public static void main(String[] args) {
    Prioridad p = Prioridad.ALTA;
    System.out.println(p.getNivel());  // 3
}

⚙️ 4. Enum con métodos

Un enum en Java es realmente una clase especial. Por eso, además de constantes, puede tener métodos, igual que cualquier otra clase.

Esto permite que cada constante del enum tenga comportamientos asociados.

enum EstadoPedido {

    PENDIENTE,
    ENVIADO,
    ENTREGADO;

    public boolean esFinal() {
        //this representa la constante actual del enum.
        return this == ENTREGADO;
    }
}

public static void main(String[] args) {
    EstadoPedido estado = EstadoPedido.ENVIADO;
    System.out.println(estado.esFinal());
}

🎭 5. Enum con comportamiento (polimorfismo)

enum también puede tener comportamiento distinto para cada constante.

Esto permite aplicar polimorfismo dentro de un enum.

✨ Ejemplo simple

enum Operacion {

    SUMA {
        @Override
        int aplicar(int a, int b) {
            return a + b;
        }
    },

    RESTA {
        @Override
        int aplicar(int a, int b) {
            return a - b;
        }
    };

    abstract int aplicar(int a, int b);
}

Uso:

public class Main {
    public static void main(String[] args) {

        Operacion op = Operacion.SUMA;

        System.out.println(op.aplicar(5, 3)); // 8
    }
}

📌 Cada constante del enum implementa su propio comportamiento.

🧠 ¿Por qué usar comportamiento en enum?

Ventajas:

  • 🎯 Evita if o switch gigantes
  • 🧱 Mantiene el comportamiento cerca del tipo
  • 🎭 Permite polimorfismo
  • 🧹 Código más limpio y mantenible

🔌 6. Enum implementando interfaces

enum también puede implementar interfaces. Esto significa que el enum puede comprometerse a implementar ciertos métodos definidos en una interfaz.

interface Calculable {
    int aplicar(int a, int b);
}

enum Operacion implements Calculable {

    MULTIPLICAR {
        public int aplicar(int a, int b) {
            return a * b;
        }
    },

    DIVIDIR {
        public int aplicar(int a, int b) {
            return a / b;
        }
    }
}

main() {
    Calculable op = Operacion.MULTIPLICAR;
    System.out.println(op.aplicar(4, 5));
}

🧠 7. Métodos especiales de los enum

Los enum en Java tienen varios métodos útiles automáticamente disponibles.

Algunos se heredan de la clase Enum y otros los genera el compilador automáticamente para cada enum.

Método De dónde sale Qué hace
values() generado por el compilador Devuelve todas las constantes del enum
valueOf(String) generado por el compilador Convierte un String en su constante
name() heredado de Enum Devuelve el nombre exacto de la constante
ordinal() heredado de Enum Devuelve la posición en el enum
compareTo() heredado de Enum Permite comparar enums

Ejemplo:

🔧 1. values() --> Devuelve todas las constantes del enum en un array.

/*LUNES
MARTES
MIERCOLES*/

for(Dia d : Dia.values()){
    System.out.println(d);
}
//📌 El orden corresponde al orden en que aparecen en el enum.

🔧 2. valueOf(String) --> Convierte un texto en una constante del enum. 

Dia d = Dia.valueOf("LUNES");

🔧 3. name() --> Devuelve el nombre exacto de la constante. 

Dia d = Dia.MARTES;
System.out.println(d.name());

🔧 4. ordinal() --> Devuelve la posición de la constante en el enum, empezando en 0. 

System.out.println(Dia.LUNES.ordinal());//0
System.out.println(Dia.MARTES.ordinal());//1

🔧 5. compareTo() -> Compara enums según su posición en el enum, es decir, según su ordinal().

  • 0 --> si son iguales
  • < 0 --> significa que el que comparas va antes que el que pones entre los ()
  • > 0 --> si el que comparas va después que el que pones entre los () 
/*LUNES --> 0
MARTES --> 1
MIERCOLES --> 2*/

//0 - 1 = -1
System.out.println(Dia.LUNES.compareTo(Dia.MARTES));//-1, Significa que LUNES aparece antes que MARTES.

//0 - 2 = -2
System.out.println(Dia.LUNES.compareTo(Dia.MIERCOLES));//-2

🔀 8. Uso con switch moderno

Los enum funcionan muy bien con switch.

String tipo = switch(dia) {

    case SABADO, DOMINGO -> "Fin de semana";
    case LUNES, MARTES, MIERCOLES, JUEVES, VIERNES -> "Laborable";

};

Esto es una switch expression moderna (Java 14+).

⚠️ 9. Restricciones de los enum

Los enum tienen algunas limitaciones:

  • ❌ No pueden extender otra clase
  • ✅ Sí pueden implementar interfaces
  • ⚠️ Los constructores siempre son privados
  • ⚠️ No se pueden crear instancias con new
  • ⚠️ El orden de las constantes define ordinal()

🚀 10. Buenas prácticas modernas

Usa enums cuando representes:

  • 🎯 Estados
  • 🎯 Tipos de operación
  • 🎯 Roles
  • 🎯 Categorías
  • 🎯 Modos de funcionamiento

Ejemplos reales:

EstadoPedido
TipoPago
NivelPrioridad
TipoUsuario
ModoJuego

🧠 Conclusión

Los enum en Java son mucho más que constantes.

Permiten:

  • 🧱 Modelar dominios cerrados
  • 🎭 Aplicar polimorfismo
  • 🧠 Escribir código más claro

Dominar bien enum es un paso importante hacia POO profesional en Java.

💳 Ejemplo real: sistema de pagos

enum TipoPago {

    TARJETA {
        @Override
        double calcularTotal(double importe) {
            return importe * 1.02; // 2% comisión
        }
    },

    BIZUM {
        @Override
        double calcularTotal(double importe) {
            return importe + 1; // comisión fija
        }
    },

    EFECTIVO {
        @Override
        double calcularTotal(double importe) {
            return importe;
        }
    };

    abstract double calcularTotal(double importe);
}

Uso:

public class MainPago {

    public static void main(String[] args) {

        double precio = 100;

        for (TipoPago t : TipoPago.values()) {
            System.out.println(t + " -> " + t.calcularTotal(precio));
        }
    }
}

📌 Aquí hay polimorfismo sin herencia explícita.