Enums em Java: um conjunto fixo de constantes nomeadas

Um conjunto fixo de valores nomeados

Alguns valores só fazem sentido como um de uma lista pequena e conhecida: os dias da semana, os naipes de um baralho, os estados em que um pedido pode estar. Você poderia modelá-los com códigos int (0 para pendente, 1 para enviado) ou com strings ("PENDING", "SHIPPED"), mas nada impede que quem chama passe 7 ou "PNEDING". Um enum fecha esse buraco — o próprio tipo só aceita os valores que você declarou.

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

public class Main {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;
        System.out.println(today);          // WEDNESDAY
        System.out.println(today == Day.WEDNESDAY);
    }
}

Day é um tipo totalmente novo. Uma variável do tipo Day pode conter exatamente uma dessas sete constantes (ou null) e nada mais. O compilador rejeita Day d = "WEDNESDAY"; ou Day d = 2;. Essa garantia é justamente o objetivo.

Cada constante (Day.MONDAY, e assim por diante) é uma única instância compartilhada, criada uma só vez. Como existe apenas um MONDAY, você compara enums com == em vez de equals — eles são o mesmo objeto.

Usando switch sobre um enum

Enums combinam naturalmente com switch. Você nem precisa qualificar cada constante com o nome do tipo dentro do switch:

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

public class Main {
    static String kind(Day d) {
        switch (d) {
            case SATURDAY:
            case SUNDAY:
                return "weekend";
            default:
                return "weekday";
        }
    }

    public static void main(String[] args) {
        System.out.println(kind(Day.SATURDAY));
        System.out.println(kind(Day.MONDAY));
    }
}

Dentro do switch, escreva case SATURDAY, não case Day.SATURDAY — o Java infere o tipo. A grande vantagem em relação a usar switch sobre uma string ou int é que, se você adicionar uma nova constante mais tarde, o seu IDE e as verificações de exaustividade podem apontar cada switch que esqueceu de tratá-la.

Percorrendo todas as constantes

Todo enum recebe automaticamente um método estático values() que retorna todas as suas constantes na ordem de declaração, além de um ordinal() que dá a posição de cada constante começando em zero:

enum Suit { HEARTS, DIAMONDS, CLUBS, SPADES }

public class Main {
    public static void main(String[] args) {
        for (Suit s : Suit.values()) {
            System.out.println(s.ordinal() + " -> " + s.name());
        }
    }
}

name() dá o identificador da constante como uma String, e values() é perfeito para montar menus ou iterar sobre opções. Um cuidado: não armazene o ordinal() em nenhum lugar persistente. Se alguém reordenar as constantes depois, os números mudam e os seus dados salvos quebram. Trate ordinal() como um detalhe de implementação, não como um identificador estável.

Enums são classes de verdade: campos e métodos

É aqui que os enums de Java vão além dos enums de inteiros nomeados de outras linguagens. Cada constante pode carregar dados, passados por um construtor, e o enum pode ter métodos. Você lista primeiro as constantes, dá a cada uma os seus argumentos de construtor e, depois de um ponto e vírgula, declara os campos, o construtor e os métodos.

enum Planet {
    MERCURY(3.303e23, 2.4397e6),
    EARTH(5.976e24, 6.37814e6);

    private final double mass;     // quilogramas
    private final double radius;   // metros

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

    double surfaceGravity() {
        final double G = 6.67300e-11;
        return G * mass / (radius * radius);
    }
}

public class Main {
    public static void main(String[] args) {
        for (Planet p : Planet.values()) {
            System.out.printf("%s gravity: %.2f%n", p, p.surfaceGravity());
        }
    }
}

Repare na estrutura: as constantes vêm primeiro e terminam com um ponto e vírgula, e então segue o restante da classe. O construtor é implicitamente private — você nunca pode escrever new Planet(...), porque as únicas instâncias permitidas são as declaradas no topo. Os campos final tornam cada constante imutável, que é exatamente o que você quer para singletons compartilhados.

De uma string e de volta

Para transformar uma string na constante correspondente, use o valueOf gerado automaticamente:

enum Status { PENDING, SHIPPED, DELIVERED }

public class Main {
    public static void main(String[] args) {
        Status s = Status.valueOf("SHIPPED");
        System.out.println(s == Status.SHIPPED);   // true

        try {
            Status bad = Status.valueOf("shipped"); // diferencia maiúsculas e minúsculas!
            System.out.println(bad);
        } catch (IllegalArgumentException e) {
            System.out.println("no constant named 'shipped'");
        }
    }
}

valueOf faz a correspondência do nome da constante de forma exata, incluindo maiúsculas e minúsculas, e lança IllegalArgumentException se não houver correspondência. Essa é a armadilha comum: "shipped" não corresponde a SHIPPED. Ao processar entrada do usuário ou dados externos, normalize primeiro o caso (input.toUpperCase()) e envolva a chamada em um try/catch, ou você vai quebrar no primeiro valor inválido.

Comportamento por constante

Às vezes cada constante precisa se comportar de forma diferente, não apenas guardar dados diferentes. Você pode dar ao enum um método abstrato e fazer cada constante fornecer a sua própria implementação em um pequeno corpo:

enum Operation {
    PLUS  { public int apply(int a, int b) { return a + b; } },
    MINUS { public int apply(int a, int b) { return a - b; } },
    TIMES { public int apply(int a, int b) { return a * b; } };

    public abstract int apply(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        for (Operation op : Operation.values()) {
            System.out.println(op + ": " + op.apply(6, 2));
        }
    }
}

Isso é às vezes chamado de padrão de "método específico de constante". Ele substitui um switch enorme sobre a constante por comportamento anexado diretamente a cada uma — adicione uma nova operação e o compilador te obriga a definir o seu apply, então você não pode esquecer nenhum caso.

Quando usar um enum

Use um enum sempre que um valor for, naturalmente, um de um conjunto pequeno, fixo e conhecido em tempo de compilação:

• Estados em um fluxo de trabalho (PENDING, SHIPPED, DELIVERED).
• Categorias, modos ou tipos (READ, WRITE, EXECUTE).
• Qualquer lugar em que você tenha sido tentado a definir um conjunto de constantes public static final int — o enum lhe dá os mesmos valores nomeados mais segurança de tipo, um toString legível e suporte a switch de graça.

Não use um enum para um conjunto aberto ou determinado em tempo de execução (nomes de usuário, uma lista de países obtida de um banco de dados). Enums são fixados em tempo de compilação; se o conjunto muda enquanto o programa roda, o que você quer é uma coleção comum.

Próximo: Generics

Você já viu values() retornando um Planet[] e, em páginas anteriores, o uso de List<Shape> — essa sintaxe <...> são os generics, a maneira de Java escrever uma classe ou método que funciona para muitos tipos mantendo total segurança de tipo. A seguir, vamos detalhar como List<String> e Map<K, V> realmente funcionam e como escrever os seus próprios tipos genéricos.