Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Corpo de classe específico de uma constante enum

Em Java SE 21, uma constante de um `enum` pode passar argumentos ao construtor e definir o seu comportamento num corpo de classe próprio.

Versão: Java SE 21

Sintaxe

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.

Em RED(30) { ... }, os parênteses contêm os argumentos do construtor e as chavetas delimitam o corpo de classe da constante. Este corpo opcional declara implicitamente uma subclasse anónima, direta e final de Signal. Não pode declarar construtores nem métodos abstract.

As constantes separam-se por vírgulas. Se houver outras declarações a seguir à lista no corpo do enum, um ponto e vírgula ; separa-as da lista. Durante a inicialização da classe, os argumentos de cada constante são passados ao construtor do enum selecionado pelas regras habituais de resolução de sobrecarga. Sem parênteses, considera-se que a lista de argumentos está vazia. Um construtor de enum sem modificador de acesso é private. Neste exemplo, Signal(int seconds) guarda o argumento no campo de instância private final int seconds.

Se um enum tiver um método abstrato, tem de ter pelo menos uma constante, e cada constante tem de fornecer uma implementação concreta do método no seu próprio corpo. A falta de uma implementação é um erro de compilação. @Override permite ao compilador verificar que o método redefine efetivamente outro método. signal.next() seleciona a implementação da constante referenciada por signal. Um método de instância declarado no corpo de uma constante só pode ser invocado de fora do enum que a contém se redefinir um método acessível desse enum.

Exemplos

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()` devolve a duração guardada para o sinal atual e `next()` devolve a constante seguinte, que já existe. `Signal.values()` devolve as constantes pela ordem de declaração.

Lições relacionadas

  • Java · Lição 9 · Intermédio · Versão: 2

Fontes