Java Academy · Lezione

Enum con campi e metodi

Aggiungere comportamenti agli enum

Enum con campi e metodi è 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.

Gli enum sono classi complete

Un enum Java è molto più di un elenco di costanti. È una vera classe, le cui istanze sono le costanti.

Questo significa che gli enum possono avere campi, costruttori e metodi, proprio come qualsiasi altra classe.

public class Main {
    enum Direction { NORTH, SOUTH, EAST, WEST }
    public static void main(String[] args) {
        Direction d = Direction.NORTH;
        System.out.println(d + " is a " + d.getClass().getSuperclass().getSimpleName());
    }
}

Aggiungere un campo

È possibile associare dati a ogni costante. Dichiari un campo final e un costruttore, quindi passi i valori tra parentesi dopo ogni costante.

public class Main {
    enum Planet {
        EARTH(9.81), MARS(3.71), JUPITER(24.79);
        private final double gravity;
        Planet(double gravity) { this.gravity = gravity; }
        double gravity() { return gravity; }
    }
    public static void main(String[] args) {
        System.out.println("Mars gravity: " + Planet.MARS.gravity());
    }
}

Il costruttore degli enum è privato

I costruttori degli enum sono implicitamente private. Non è possibile usare new su un enum; la JVM crea le costanti una sola volta al caricamento della classe.

Questo garantisce un insieme fisso e finito di istanze.

public class Main {
    enum Coin {
        PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
        private final int cents;
        Coin(int cents) { this.cents = cents; }
        int cents() { return cents; }
    }
    public static void main(String[] args) {
        int total = Coin.QUARTER.cents() + Coin.DIME.cents();
        System.out.println("Total cents: " + total);
    }
}

Più campi

Una costante può contenere diversi dati. Qui ogni pianeta memorizza sia la massa sia il raggio.

public class Main {
    enum Planet {
        EARTH(5.976e24, 6.37814e6),
        MARS(6.421e23, 3.3972e6);
        private final double mass, radius;
        Planet(double mass, double radius) { this.mass = mass; this.radius = radius; }
        double surfaceGravity() {
            final double G = 6.67300E-11;
            return G * mass / (radius * radius);
        }
    }
    public static void main(String[] args) {
        System.out.printf("Earth g = %.2f%n", Planet.EARTH.surfaceGravity());
    }
}

Metodi di istanza

I metodi degli enum possono calcolare risultati a partire dai campi della costante stessa, proprio come i normali metodi di istanza.

public class Main {
    enum Size {
        SMALL(8), MEDIUM(12), LARGE(16);
        private final int ounces;
        Size(int ounces) { this.ounces = ounces; }
        int ounces() { return ounces; }
        double liters() { return ounces * 0.0295735; }
    }
    public static void main(String[] args) {
        System.out.printf("Large = %.2f L%n", Size.LARGE.liters());
    }
}

name e ordinal integrati

Ogni enum dispone di name() (l'identificatore esatto) e ordinal() (la posizione a indice zero).

È preferibile memorizzare dati propri invece di affidarsi a ordinal(), che diventa inaffidabile se si riordinano le costanti.

public class Main {
    enum Day { MON, TUE, WED }
    public static void main(String[] args) {
        for (Day d : Day.values()) {
            System.out.println(d.name() + " -> ordinal " + d.ordinal());
        }
    }
}

values e valueOf

Il compilatore genera due helper statici:

values() restituisce un array contenente tutte le costanti.
valueOf(String) cerca una costante per nome e genera un'eccezione se non la trova.

public class Main {
    enum Status { ACTIVE, PAUSED, CLOSED }
    public static void main(String[] args) {
        System.out.println("count: " + Status.values().length);
        Status s = Status.valueOf("PAUSED");
        System.out.println("parsed: " + s);
    }
}

Sovrascrivere toString

È possibile sovrascrivere toString() per assegnare etichette più intuitive, mantenendo il nome della costante nel codice.

public class Main {
    enum Priority {
        LOW, MEDIUM, HIGH;
        @Override public String toString() {
            return name().charAt(0) + name().substring(1).toLowerCase();
        }
    }
    public static void main(String[] args) {
        for (Priority p : Priority.values()) System.out.println(p);
    }
}

Enum in switch

Gli enum si integrano bene con switch. Le moderne espressioni switch offrono controlli di esaustività ed eliminano il fall-through.

public class Main {
    enum Traffic { RED, YELLOW, GREEN }
    static String action(Traffic t) {
        return switch (t) {
            case RED -> "Stop";
            case YELLOW -> "Slow down";
            case GREEN -> "Go";
        };
    }
    public static void main(String[] args) {
        System.out.println(action(Traffic.GREEN));
    }
}

Map statiche per la ricerca

Un modello comune consiste in una map statica che consente di risalire da un campo alla costante, costruita una sola volta in un inizializzatore statico.

import java.util.HashMap;
import java.util.Map;

public class Main {
    enum Op {
        PLUS("+"), MINUS("-");
        private final String symbol;
        Op(String symbol) { this.symbol = symbol; }
        private static final Map<String, Op> BY_SYMBOL = new HashMap<>();
        static { for (Op o : values()) BY_SYMBOL.put(o.symbol, o); }
        static Op fromSymbol(String s) { return BY_SYMBOL.get(s); }
    }
    public static void main(String[] args) {
        System.out.println(Op.fromSymbol("-"));
    }
}

Gli enum implementano interfacce

Un enum può implementare un'interfaccia, consentendo alle costanti di integrarsi nel codice generico.

public class Main {
    interface Describable { String describe(); }
    enum Animal implements Describable {
        DOG, CAT;
        public String describe() { return "A " + name().toLowerCase(); }
    }
    public static void main(String[] args) {
        Describable d = Animal.DOG;
        System.out.println(d.describe());
    }
}

Verifica rapida

Verifichi la Sua comprensione dei campi degli enum.

Riepilogo

Ha imparato che gli enum sono classi complete:

Le costanti possono contenere campi impostati tramite un costruttore privato.
Gli enum possono avere metodi di istanza e sovrascrivere toString().
values() e valueOf() vengono generati automaticamente.
Gli enum possono implementare interfacce e preferiscono i campi a ordinal().

Prossimamente: comportamento specifico per costante con metodi astratti.

public class Main {
    enum Greeting { HELLO; String text() { return "Hi"; } }
    public static void main(String[] args) {
        System.out.println("Enum fields recap: " + Greeting.HELLO.text());
    }
}

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»?

Aggiungere comportamenti agli enum 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 «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

← Torna a Java Academy