Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Cuerpo de clase específico de una constante enum

En Java SE 21, una constante de un `enum` puede pasar argumentos al constructor y definir su comportamiento en un cuerpo de clase propio.

Versión: Java SE 21

Sintaxis

EnumConstant ::= Annotation* Identifier [ '(' [ ArgumentList ] ')' ] [ ClassBody ]
ArgumentList ::= Expression ( ',' Expression )*

Here [ ... ] means optional, * means zero or more, and quoted punctuation is literal. ClassBody is the constant's { ... } body.

En RED(30) { ... }, los paréntesis contienen los argumentos del constructor y las llaves delimitan el cuerpo de clase de la constante. Este cuerpo opcional declara implícitamente una subclase anónima, directa y final de Signal. No puede declarar constructores ni métodos abstract.

Las constantes se separan con comas. Si hay más declaraciones después de la lista en el cuerpo del enum, un punto y coma ; las separa de la lista. Durante la inicialización de la clase, los argumentos de cada constante se pasan al constructor seleccionado mediante las reglas habituales de resolución de sobrecargas. Si se omiten los paréntesis, la lista de argumentos se considera vacía. Un constructor de enum sin modificador de acceso es private. Aquí, Signal(int seconds) guarda el argumento en el campo de instancia private final int seconds.

Si un enum tiene un método abstracto, debe tener al menos una constante, y cada constante debe proporcionar una implementación concreta del método en su propio cuerpo. Si falta una implementación, se produce un error de compilación. @Override permite que el compilador compruebe que el método realmente sobrescribe otro método. signal.next() selecciona la implementación de la constante a la que se refiere signal. Un método de instancia declarado en el cuerpo de una constante solo se puede invocar desde fuera del enum que la contiene si sobrescribe un método accesible de ese enum.

Ejemplos

public class Main {
    enum Signal {
        RED(30) {
            @Override
            Signal next() { return GREEN; }
        },
        GREEN(25) {
            @Override
            Signal next() { return YELLOW; }
        },
        YELLOW(5) {
            @Override
            Signal next() { return RED; }
        };

        private final int seconds;

        private Signal(int seconds) {
            this.seconds = seconds;
        }

        int seconds() {
            return seconds;
        }

        abstract Signal next();
    }

    public static void main(String[] args) {
        for (Signal signal : Signal.values()) {
            System.out.println(signal.name() + " (" + signal.seconds()
                    + " s) -> " + signal.next().name());
        }
    }
}

Resultado

RED (30 s) -> GREEN
GREEN (25 s) -> YELLOW
YELLOW (5 s) -> RED

`seconds()` devuelve la duración guardada para la señal actual y `next()` devuelve la siguiente constante, que ya existe. `Signal.values()` devuelve las constantes en el orden de declaración.

Lecciones relacionadas

  • Java · Lección 9 · Intermedio · Versión: 2

Fuentes