Como funcionam enums em Java?

Question

Accepted Answer

Um **enum** define um tipo com um **conjunto fixo de constantes nomeadas**. Os enums do Java são muito mais poderosos do que simples listas de constantes em outras linguagens — são classes completas que podem ter campos, construtores e métodos.

## Enum básico

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

Day today = Day.MONDAY;

// works great in switch
switch (today) {
    case MONDAY -> System.out.println("start of week");
    case SATURDAY, SUNDAY -> System.out.println("weekend");
    default -> System.out.println("weekday");
}
```

Os enums fornecem **segurança de tipo** — `Day today = Day.MONDAY` pode conter apenas valores válidos de `Day`, diferentemente de usar ints ou strings arbitrárias como constantes (que permitem valores inválidos e erros de digitação).

## Métodos built-in de enum

```java
Day.MONDAY.name();        // "MONDAY"
Day.MONDAY.ordinal();     // 0 — position in the declaration
Day.values();             // array of all constants (iterate them)
Day.valueOf("FRIDAY");    // get a constant by name
for (Day d : Day.values()) { ... }   // iterate all values
```

## Enums com campos, construtores e métodos (a parte poderosa)

```java
public enum Planet {
    MERCURY(3.3e23, 2.4e6),    // each constant calls the constructor with arguments
    EARTH(5.97e24, 6.37e6),
    JUPITER(1.9e27, 7.1e7);

private final double mass;       // enums can have FIELDS
    private final double radius;

Planet(double mass, double radius) {   // constructor (implicitly private)
        this.mass = mass;
        this.radius = radius;
    }
    public double surfaceGravity() {        // and METHODS
        return 6.67e-11 * mass / (radius * radius);
    }
}

Planet.EARTH.surfaceGravity();   // compute using EARTH's data
```

Cada constante de enum é uma instância, configurada via construtor — permitindo associar dados e comportamento com cada constante. Isso é único e poderoso em comparação com enums da maioria das linguagens.

## Enums podem implementar interfaces e ter comportamento por constante

```java
public enum Operation {
    PLUS { 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);   // each constant implements it differently
}
Operation.PLUS.apply(2, 3);   // 5
```

## Enums são singletons ideais

```java
public enum Config { INSTANCE; /* fields/methods */ }
// enum singletons are thread-safe and serialization-safe by design
```

## Por que isso importa

Os enums do Java são uma forma robusta e type-safe de representar conjuntos fixos de constantes relacionadas (estados, dias, papéis, operações) — muito superior à alternativa propensa a erros de constantes `int`/`String`, que permitem valores inválidos e não oferecem verificação de tipo.
//t Seu poder único — campos, construtores, métodos, implementação de interfaces e comportamento por constante — permite anexar dados e lógica a cada constante, modelando conceitos de domínio elegantemente (ex: planetas com massa/gravidade, operações com sua matemática).

Eles também fornecem o idioma singleton mais seguro.

Compreender enums além de simples listas de constantes — como classes completas com estado e comportamento — permite modelagem de domínio mais limpa e segura, e é um recurso do Java frequentemente subutilizado mas valioso, além de ser um tópico comum em entrevistas.