Come funzionano gli enum in Java?

Question

Accepted Answer

Un **enum** definisce un tipo con un **insieme fisso di costanti denominate**. Gli enum Java sono molto più potenti delle semplici liste di costanti in altri linguaggi — sono classi complete che possono avere campi, costruttori e metodi.

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

Gli enum forniscono **type safety** — `Day today = Day.MONDAY` può contenere solo valori validi di `Day`, a differenza dell'uso di interi o stringhe arbitrarie come costanti (che consentono valori non validi e errori di battitura).

## Metodi enum incorporati

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

## Enum con campi, costruttori e metodi (la parte potente)

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

Ogni costante enum è un'istanza, configurata tramite il costruttore — permettendoti di associare dati e comportamento a ogni costante. Questo è unico e potente rispetto agli enum della maggior parte dei linguaggi.

## Gli enum possono implementare interfacce e avere comportamento per costante

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

## Gli enum sono singleton ideali

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

## Perché è importante

Gli enum Java sono un modo robusto e type-safe per rappresentare insiemi fissi di costanti correlate (stati, giorni, ruoli, operazioni) — molto superiore all'alternativa soggetta a errori dei costanti `int`/`String`, che consentono valori non validi e non offrono alcun controllo di tipo.

La loro potenza unica — campi, costruttori, metodi, implementazione di interfacce e comportamento per costante — ti consente di associare dati e logica a ogni costante, modellando i concetti del dominio in modo elegante (ad esempio pianeti con massa/gravità, operazioni con le loro operazioni matematiche).

Forniscono anche l'idioma singleton più sicuro.

Comprendere gli enum oltre semplici liste di costanti — come classi complete con stato e comportamento — abilita una modellazione del dominio più pulita e sicura ed è una funzionalità Java sottoutilizzata ma preziosa, nonché un argomento comune nei colloqui.