Comment fonctionnent les enums en Java ?

Question

Accepted Answer

Un **enum** définit un type avec un **ensemble fixe de constantes nommées**. Les enums Java sont bien plus puissants que de simples listes de constantes dans d'autres langages — ce sont des classes à part entière qui peuvent avoir des champs, des constructeurs et des méthodes.

## Enum de base

```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");
}
```

Les enums offrent une **sécurité de type** — `Day today = Day.MONDAY` ne peut contenir que des valeurs `Day` valides, contrairement à l'utilisation d'entiers ou de chaînes arbitraires comme constantes (qui permettent des valeurs invalides et des fautes de frappe).

## Méthodes enum intégrées

```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 avec champs, constructeurs et méthodes (la partie puissante)

```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
```

Chaque constante enum est une instance, configurée via le constructeur — ce qui vous permet d'associer des données et un comportement à chaque constante. C'est unique et puissant comparé aux enums de la plupart des langages.

## Les enums peuvent implémenter des interfaces et avoir un comportement par 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
```

## Les enums sont des singletons idéaux

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

## Pourquoi c'est important

Les enums Java offrent un moyen robuste et type-safe de représenter des ensembles fixes de constantes liées (états, jours, rôles, opérations) — bien supérieur à l'alternative sujette aux erreurs des constantes `int`/`String`, qui permettent des valeurs invalides et n'offrent aucune vérification de type.

Leur pouvoir unique — champs, constructeurs, méthodes, implémentation d'interfaces et comportement par constante — vous permet d'attacher des données et de la logique à chaque constante, modélisant les concepts de domaine élégamment (par exemple, planètes avec masse/gravité, opérations avec leurs mathématiques).

Ils fournissent également le modèle singleton le plus sûr.

Comprendre les enums au-delà de simples listes de constantes — comme des classes complètes avec état et comportement — permet une modélisation de domaine plus claire et plus sûre, et c'est une fonctionnalité Java souvent sous-utilisée mais précieuse, ainsi qu'un sujet d'entretien fréquent.