0Pricing
Java Academy · Lezione

Definizione e utilizzo degli enum

Dichiari i tipi enum, utilizzi le relative costanti e li iteri con values() e ordinal().

Definizione e utilizzo degli enum è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Definire e usare gli enum

Un enum (enumerazione) è una classe speciale che rappresenta un insieme fisso di costanti. Gli enum sono sicuri rispetto ai tipi, leggibili e più potenti delle costanti statiche int.

Dichiarare un enum

Usi la parola chiave enum per dichiarare un'enumerazione. Ogni costante è implicitamente public static final e un'istanza del tipo enum.

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)

Iterare con values()

EnumType.values() restituisce tutte le costanti nell'ordine di dichiarazione. Lo usi per iterare sulle costanti o creare menu.

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 analisi

Enum.valueOf(name) converte una String nella costante corrispondente. Genera IllegalArgumentException se non viene trovata.

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; }
}

Usare gli enum in switch

Gli enum funzionano perfettamente nelle istruzioni e nelle espressioni switch. Le moderne espressioni switch rendono l'instradamento degli enum conciso ed esaustivo.

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

Enum con if/else

Usi == per confrontare le costanti enum: sono istanze singleton, quindi l'uguaglianza dei riferimenti funziona correttamente.

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

Enum nelle collezioni

Gli enum possono essere memorizzati nelle collezioni standard. Usi EnumSet e EnumMap per una memorizzazione basata su enum ad alte prestazioni (argomento trattato in una lezione successiva).

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

Gli enum implementano interfacce

Gli enum possono implementare interfacce, consentendo di associare un comportamento a ogni costante o di definire un contratto comune per tutte le costanti.

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());
}

Enum come macchina a stati

Gli enum sono particolarmente adatti alle macchine a stati. Ogni costante rappresenta uno stato e i metodi definiscono le transizioni valide.

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

Buone pratiche per gli enum

Segua queste buone pratiche quando usa gli enum:

  • Usi nomi in maiuscolo separati da underscore per le costanti (convenzione)
  • Preferisca gli enum alle costanti int o String per garantire la sicurezza dei tipi
  • Usi espressioni switch per un instradamento esaustivo
  • Aggiunga campi e metodi agli enum quando le costanti contengono dati

Esercitazione pratica: codici di stato HTTP

Un enum realistico che modella le categorie dei codici di stato HTTP, con un metodo factory che parte dal codice numerico.

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 rapida

Qual è l'output del seguente codice?

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

Riepilogo: definire e usare gli enum

Punti chiave:

  • Gli enum definiscono un insieme fisso di costanti denominate con sicurezza dei tipi
  • values() scorre tutte le costanti; ordinal() restituisce l'indice a partire da zero
  • valueOf() converte una String nella costante corrispondente
  • Usi == (non equals) per confrontare le istanze degli enum
  • Gli enum funzionano molto bene nelle espressioni switch per un instradamento esaustivo
  • Gli enum possono implementare interfacce per associare un comportamento a ogni costante

Domande Frequenti

La lezione «Definizione e utilizzo degli enum» è gratuita?

Sì — il testo completo di «Definizione e utilizzo degli enum» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Definizione e utilizzo degli enum»?

Dichiari i tipi enum, utilizzi le relative costanti e li iteri con values() e ordinal(). Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Definizione e utilizzo degli enum»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Definizione e utilizzo degli enum
  2. Enum con campi e metodi
  3. Espressioni switch con gli enum
  4. EnumSet ed EnumMap
← Torna a Java Academy