Java Academy · Aula

Definição e Uso de Enumerações

Declare tipos enum, use suas constantes e percorra seus valores com values() e ordinal().

Definição e Uso de Enumerações é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Definindo e usando enumerações

Uma enumeração é uma classe especial que representa um conjunto fixo de constantes. Enumerações oferecem segurança de tipos, são legíveis e mais poderosas do que constantes estáticas int.

Declarando uma enumeração

Use a palavra-chave enum para declarar uma enumeração. Cada constante é implicitamente public static final e uma instância do tipo da enumeração.

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

Day today = Day.WEDNESDAY;
System.out.println(today);          // WEDNESDAY
System.out.println(today.name());   // WEDNESDAY
System.out.println(today.ordinal()); // 2 (zero-based index)

Iterando com values()

EnumType.values() retorna todas as constantes na ordem em que foram declaradas. Use-o para iterar ou criar menus.

enum Planet { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE }

for (Planet p : Planet.values()) {
    System.out.println(p.ordinal() + ": " + p);
}
// 0: MERCURY
// 1: VENUS
// 2: EARTH
// ...

// Count constants
System.out.println(Planet.values().length); // 8

valueOf() e análise

Enum.valueOf(name) converte uma String na constante correspondente. Lança IllegalArgumentException se ela não for encontrada.

enum Status { PENDING, ACTIVE, SUSPENDED, CLOSED }

String input = "ACTIVE";
Status s = Status.valueOf(input);
System.out.println(s); // ACTIVE

try {
    Status bad = Status.valueOf("UNKNOWN");
} catch (IllegalArgumentException e) {
    System.out.println("Invalid status: UNKNOWN");
}

// Safe parse pattern
static Status safeFrom(String name) {
    try { return Status.valueOf(name.toUpperCase()); }
    catch (IllegalArgumentException e) { return Status.PENDING; }
}

Usando enumerações em seleções

As enumerações funcionam perfeitamente em instruções e expressões de seleção. As expressões de seleção modernas tornam o encaminhamento por enumeração conciso e exaustivo.

enum OrderStatus { CREATED, PROCESSING, SHIPPED, DELIVERED, CANCELLED }

OrderStatus status = OrderStatus.SHIPPED;

String message = switch (status) {
    case CREATED     -> "Order received, awaiting payment";
    case PROCESSING  -> "Payment confirmed, preparing shipment";
    case SHIPPED     -> "On the way — track your package";
    case DELIVERED   -> "Delivered! Enjoy your order";
    case CANCELLED   -> "Order cancelled";
};
System.out.println(message); // On the way — track your package

Enumerações com condicionais

Use == para comparar constantes de enumeração — elas são instâncias únicas, portanto a igualdade de referências funciona corretamente.

enum UserRole { GUEST, MEMBER, ADMIN, SUPERADMIN }

UserRole role = UserRole.ADMIN;

if (role == UserRole.ADMIN || role == UserRole.SUPERADMIN) {
    System.out.println("Access granted to admin panel");
} else {
    System.out.println("Access denied");
}

// Enum comparison: never use .equals() for enums
// == is correct and more readable

Enumerações em coleções

Enumerações podem ser armazenadas em coleções padrão. Use EnumSet e EnumMap para armazenamento de alto desempenho baseado em enumerações (abordado em uma lição posterior).

import java.util.*;

enum Permission { READ, WRITE, DELETE, ADMIN }

Set<Permission> userPerms = new HashSet<>();
userPerms.add(Permission.READ);
userPerms.add(Permission.WRITE);

System.out.println(userPerms.contains(Permission.DELETE)); // false
System.out.println(userPerms.contains(Permission.READ));   // true

List<Permission> allPerms = Arrays.asList(Permission.values());
System.out.println(allPerms.size()); // 4

Enumerações implementam interfaces

Enumerações podem implementar interfaces, permitindo associar um comportamento a cada constante ou definir um contrato comum para todas as constantes.

interface Describable {
    String describe();
}

enum Season implements Describable {
    SPRING, SUMMER, FALL, WINTER;

    public String describe() {
        return switch (this) {
            case SPRING -> "Mild and rainy";
            case SUMMER -> "Hot and sunny";
            case FALL   -> "Cool with falling leaves";
            case WINTER -> "Cold and snowy";
        };
    }
}

for (Season s : Season.values()) {
    System.out.println(s + ": " + s.describe());
}

Enumeração como máquina de estados

Enumerações são uma escolha natural para máquinas de estados. Cada constante representa um estado, e os métodos definem transições válidas.

enum TrafficLight {
    RED, YELLOW, GREEN;

    public TrafficLight next() {
        return switch (this) {
            case RED    -> GREEN;
            case GREEN  -> YELLOW;
            case YELLOW -> RED;
        };
    }
}

TrafficLight light = TrafficLight.RED;
for (int i = 0; i < 6; i++) {
    System.out.println(light);
    light = light.next();
}
// RED, GREEN, YELLOW, RED, GREEN, YELLOW

Boas práticas para enumerações

Siga estas boas práticas ao usar enumerações:

Use nomes em MAIÚSCULAS para as constantes (convenção)
Prefira enumerações a constantes int ou String para obter segurança de tipos
Use expressões de seleção para encaminhamento exaustivo
Adicione campos e métodos às enumerações quando as constantes carregarem dados

Prático: códigos de status HTTP

Uma enumeração realista que modela categorias de status HTTP com um método de fábrica a partir do código numérico.

enum HttpStatus {
    OK(200), CREATED(201), BAD_REQUEST(400),
    UNAUTHORIZED(401), NOT_FOUND(404), SERVER_ERROR(500);

    public final int code;

    HttpStatus(int code) { this.code = code; }

    public static HttpStatus from(int code) {
        for (HttpStatus s : values())
            if (s.code == code) return s;
        throw new IllegalArgumentException("Unknown HTTP code: " + code);
    }

    public boolean isSuccess() { return code >= 200 && code < 300; }
}

HttpStatus s = HttpStatus.from(404);
System.out.println(s + " (" + s.code + ") success=" + s.isSuccess());
// NOT_FOUND (404) success=false

Verificação rápida

Qual é a saída do código a seguir?

enum Color { RED, GREEN, BLUE }
System.out.println(Color.GREEN.ordinal());

Recapitulação: definindo e usando enumerações

Principais conclusões:

Enumerações definem um conjunto fixo de constantes nomeadas com segurança de tipos
values() itera por todas as constantes; ordinal() fornece o índice começando em zero
valueOf() converte uma String na constante correspondente
Use == (não equals) para comparar instâncias de enumeração
Enumerações funcionam muito bem em expressões de seleção para encaminhamento exaustivo
Enumerações podem implementar interfaces para associar um comportamento a cada constante

Perguntas Frequentes

A aula “Definição e Uso de Enumerações” é grátis?

Sim — o texto completo de “Definição e Uso de Enumerações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Definição e Uso de Enumerações”?

Declare tipos enum, use suas constantes e percorra seus valores com values() e ordinal(). Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Definição e Uso de Enumerações”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy