0Pricing
Java Academy · Lezione

Enum con campi e metodi

Aggiunga campi, costruttori e metodi agli enum per incapsularne il comportamento.

Enum con campi e metodi è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Enum con campi e metodi

Le costanti enum possono contenere dati. Aggiunga i campi dichiarandoli e definendo un costruttore. Il costruttore è automaticamente privato.

Dichiarare campi negli enum

Ogni costante enum chiama il costruttore quando la classe viene caricata. I valori dei campi vengono impostati una sola volta e sono immutabili (quando vengono dichiarati final).

enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS  (4.869e+24, 6.0518e6),
    EARTH  (5.976e+24, 6.37814e6),
    MARS   (6.421e+23, 3.3972e6);

    private final double mass;    // kilograms
    private final double radius;  // meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double mass()   { return mass; }
    public double radius() { return radius; }
}

Aggiungere metodi agli enum

I tipi enum possono contenere tutti i metodi che inserirebbe in una classe, incluse proprietà calcolate.

enum Planet {
    EARTH(5.976e+24, 6.37814e6);
    // ... constructor and fields ...
    static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }

    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

double earthWeight = 75.0;
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values())
    System.out.printf("Weight on %s: %.2f%n", p, p.surfaceWeight(mass));

Metodi astratti nelle costanti enum

Ogni costante può fornire una propria implementazione di un metodo astratto dichiarato nel corpo dell'enum.

enum Operation {
    PLUS  { public double apply(double x, double y) { return x + y; } },
    MINUS { public double apply(double x, double y) { return x - y; } },
    TIMES { public double apply(double x, double y) { return x * y; } },
    DIVIDE{ public double apply(double x, double y) { return x / y; } };

    public abstract double apply(double x, double y);
}

System.out.println(Operation.PLUS.apply(3, 4));   // 7.0
System.out.println(Operation.TIMES.apply(3, 4));  // 12.0

Enum con etichette testuali

Un modello comune consiste nell'assegnare a ogni costante un'etichetta leggibile dall'utente, memorizzata in un campo.

enum UserRole {
    GUEST("Guest User"),
    MEMBER("Registered Member"),
    ADMIN("Administrator"),
    SUPERADMIN("Super Administrator");

    private final String label;

    UserRole(String label) { this.label = label; }

    public String label() { return label; }

    public static UserRole fromLabel(String lbl) {
        for (UserRole r : values())
            if (r.label.equalsIgnoreCase(lbl)) return r;
        throw new IllegalArgumentException(lbl);
    }
}

System.out.println(UserRole.ADMIN.label()); // Administrator

Enum con più campi

Gli enum possono avere tutti i campi necessari. In questo caso un enum di valute memorizza sia il codice ISO sia il simbolo.

enum Currency {
    USD("US Dollar", "$"),
    EUR("Euro", "\u20ac"),
    GBP("British Pound", "\u00a3"),
    JPY("Japanese Yen", "\u00a5");

    public final String name;
    public final String symbol;

    Currency(String name, String symbol) {
        this.name = name;
        this.symbol = symbol;
    }

    public String format(double amount) {
        return String.format("%s%.2f", symbol, amount);
    }
}

System.out.println(Currency.EUR.format(99.99)); // \u20ac99.99

Sovrascrivere toString()

Sovrascriva toString() in un enum per restituire una rappresentazione testuale personalizzata invece del nome della costante.

enum HttpMethod {
    GET, POST, PUT, PATCH, DELETE;

    @Override
    public String toString() {
        return name().toUpperCase();
    }

    public boolean hasBody() {
        return this == POST || this == PUT || this == PATCH;
    }
}

HttpMethod m = HttpMethod.POST;
System.out.println(m);            // POST
System.out.println(m.hasBody());  // true
System.out.println(HttpMethod.GET.hasBody()); // false

Enum con convalida

I costruttori degli enum possono convalidare i propri argomenti per impedire stati non validi.

enum DiscountTier {
    BRONZE(5), SILVER(10), GOLD(20), PLATINUM(30);

    public final int percentage;

    DiscountTier(int percentage) {
        if (percentage < 0 || percentage > 100)
            throw new IllegalArgumentException("Invalid: " + percentage);
        this.percentage = percentage;
    }

    public double apply(double price) {
        return price * (1 - percentage / 100.0);
    }
}

System.out.println(DiscountTier.GOLD.apply(100.0)); // 80.0

Singleton con enum

Un enum con una sola costante è il modo più sicuro per implementare un Singleton in Java: è sicuro rispetto alla serializzazione e all'uso concorrente per impostazione predefinita.

enum AppConfig {
    INSTANCE;

    private String dbUrl = "jdbc:postgresql://localhost/mydb";
    private int maxConnections = 20;

    public String getDbUrl() { return dbUrl; }
    public int getMaxConnections() { return maxConnections; }

    public void setDbUrl(String url) { this.dbUrl = url; }
}

// Access the singleton
AppConfig config = AppConfig.INSTANCE;
System.out.println(config.getDbUrl());

Enum nei modelli di dominio

Gli enum sono ampiamente usati nei modelli di dominio per rappresentare categorie sicure rispetto ai tipi: stato dell'ordine, metodo di pagamento, tipo di notifica e così via.

enum PaymentMethod {
    CREDIT_CARD("Credit Card", true),
    DEBIT_CARD("Debit Card", true),
    PAYPAL("PayPal", false),
    CRYPTO("Cryptocurrency", false),
    BANK_TRANSFER("Bank Transfer", false);

    public final String displayName;
    public final boolean instantCharge;

    PaymentMethod(String displayName, boolean instantCharge) {
        this.displayName = displayName;
        this.instantCharge = instantCharge;
    }
}

Campo enum o valore calcolato

I campi memorizzano dati fissi, mentre i metodi calcolano valori dinamici. Usi i campi per i dati costanti e i metodi per i valori derivati.

enum DayType {
    MONDAY(false), TUESDAY(false), WEDNESDAY(false),
    THURSDAY(false), FRIDAY(false),
    SATURDAY(true), SUNDAY(true);

    private final boolean weekend;
    DayType(boolean weekend) { this.weekend = weekend; }

    public boolean isWeekend()  { return weekend; }
    public boolean isWeekday()  { return !weekend; }

    public static long weekdayCount() {
        return java.util.Arrays.stream(values())
            .filter(DayType::isWeekday).count();
    }
}
System.out.println(DayType.weekdayCount()); // 5

Verifica rapida

In che modo il costruttore di un enum differisce dal costruttore di una classe normale?

Riepilogo: enum con campi e metodi

Punti chiave:

  • Aggiunga campi e un costruttore per associare dati a ogni costante
  • I costruttori degli enum sono implicitamente privati
  • I metodi astratti consentono a ogni costante di fornire una propria implementazione
  • Sovrascriva toString() per visualizzare nomi personalizzati
  • Gli enum con una sola costante sono la migliore implementazione del pattern Singleton
  • Gli enum si integrano naturalmente nei modelli di dominio come categorie sicure rispetto ai tipi

Domande Frequenti

La lezione «Enum con campi e metodi» è gratuita?

Sì — il testo completo di «Enum con campi e metodi» è 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 «Enum con campi e metodi»?

Aggiunga campi, costruttori e metodi agli enum per incapsularne il comportamento. 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 2 di 4.

Quanto tempo richiede la lezione «Enum con campi e metodi»?

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