Enumerazioni in Java

Enumerazioni

Nella sua forma più semplice, una enumerazione è una lista di costanti dotate di un nome che definiscono un nuovo tipo di dato e i suoi valori possibili.

Pertanto, un oggetto enumerazione può contenere solo un valore che è stato dichiarato nella lista. Altri valori non sono consentiti. In altre parole, un'enumerazione fornisce un modo per specificare esplicitamente gli unici valori che un tipo di dato può legalmente avere.

Le enumerazioni sono comunemente utilizzate per definire un insieme di valori che rappresentano una collezione di elementi. Ad esempio, si potrebbe utilizzare un'enumerazione per rappresentare i codici di errore che possono risultare da qualche operazione, come successo, fallimento, o in attesa; o una lista degli stati in cui un dispositivo potrebbe trovarsi, come in esecuzione, fermato, o in pausa. Nelle prime versioni di Java, tali valori erano definiti utilizzando variabili final, ma le enumerazioni offrono un approccio di gran lunga superiore.

Sebbene le enumerazioni Java potrebbero, a prima vista, apparire simili alle enumerazioni in altri linguaggi, questa somiglianza risulta solo superficiale perché, in Java, un'enumerazione definisce un tipo di classe.

Rendendo le enumerazioni delle classi, le capacità dell'enumerazione vengono notevolmente ampliate. Ad esempio, in Java, un'enumerazione può avere costruttori, metodi e variabili di istanza. A causa della loro potenza e flessibilità, le enumerazioni sono ampiamente utilizzate in tutta la libreria standard di Java.

Fondamenti delle Enumerazioni

Un'enumerazione viene creata utilizzando la parola chiave enum. Per esempio, ecco una semplice enumerazione che elenca varie varietà di mele:

// Un'enumerazione di varietà di mele.
enum Mela {
    Jonathan, Golden, Melannurca, Winesap, Cortland
}

Gli identificatori Jonathan, Golden, e così via, sono chiamati costanti di enumerazione. Ognuna è implicitamente dichiarata come un membro public, static final di Mela. Inoltre, il loro tipo è il tipo dell'enumerazione in cui sono dichiarate, che è Mela in questo caso. Quindi, nel linguaggio di Java, queste costanti sono chiamate auto-tipizzate, in cui "auto" si riferisce all'enumerazione che le racchiude.

Una volta che abbiamo definito un'enumerazione, possiamo creare una variabile di quel tipo. Tuttavia, anche se le enumerazioni definiscono un tipo di classe, non istanziamo un enum usando new. Invece, dichiariamo e utilizziamo una variabile di enumerazione più o meno nello stesso modo in cui facciamo con uno dei tipi primitivi. Per esempio, questo dichiara mela come una variabile di tipo enumerazione Mela:

Mela mela;

Poiché mela è di tipo Mela, gli unici valori che possono essere assegnati (o che può contenere) sono quelli definiti dall'enumerazione. Per esempio, questo assegna ad mela il valore Melannurca:

mela = Mela.Melannurca;

Notare che il simbolo Melannurca è preceduto da Mela.

Due costanti di enumerazione possono essere confrontate per uguaglianza utilizzando l'operatore relazionale ==. Per esempio, questa istruzione confronta il valore in mela con la costante Melannurca:

if(mela == Mela.Melannurca) // ...

Un valore di enumerazione può anche essere utilizzato per controllare un'istruzione switch. Naturalmente, tutte le istruzioni case devono utilizzare costanti dallo stesso enum di quello utilizzato dall'espressione switch. Per esempio, questo switch è perfettamente valido:

// Usa un enum per controllare un'istruzione switch.
switch(mela) {
    case Jonathan:
        // ...
    case Winesap:
        // ...

Notare che nelle istruzioni case, i nomi delle costanti di enumerazione sono utilizzati senza essere qualificati dal nome del loro tipo di enumerazione. Cioè, viene utilizzato Winesap, non Mela.Winesap. Questo perché il tipo dell'enumerazione nell'espressione switch ha già implicitamente specificato il tipo enum delle costanti case. Non c'è bisogno di qualificare le costanti nelle istruzioni case con il nome del loro tipo enum. In fatto, tentare di farlo causerà un errore di compilazione.

Quando una costante di enumerazione viene visualizzata, per esempio in un'istruzione println(), il suo nome viene emesso in output. Per esempio, data questa istruzione:

System.out.println(Mela.Winesap);

il nome Winesap viene visualizzato.

Il seguente programma mette insieme tutti i pezzi e dimostra l'enumerazione Mela:

// Un'enumerazione di varietà di mele.
enum Mela {
    Jonathan, Golden, Melannurca, Winesap, Cortland
}

class DemoEnum {

    public static void main(String[] args) {
        Mela mela;
        mela = Mela.Melannurca;

        // Output di un valore enum.
        System.out.println("Valore di mela: " + mela);
        System.out.println();

        mela = Mela.Golden;

        // Confronta due valori enum.
        if(mela == Mela.Golden)
            System.out.println("mela contiene Golden.\n");

        // Usa un enum per controllare un'istruzione switch.
        switch(mela) {
            case Jonathan:
                System.out.println("Jonathan è rossa.");
                break;
            case Golden:
                System.out.println("Golden è gialla.");
                break;
            case Melannurca:
                System.out.println("Melannurca è rossa.");
                break;
            case Winesap:
                System.out.println("Winesap è rossa.");
                break;
            case Cortland:
                System.out.println("Cortland è rossa.");
            break;
            default:
                System.out.println("Mela sconosciuta.");
        }
    }

}

L'output del programma è mostrato qui:

Valore di mela: Melannurca

mela contiene Golden.

Golden è gialla.

I Metodi values e valueOf

Tutte le enumerazioni contengono automaticamente due metodi predefiniti: values() e valueOf().

Le loro forme generali sono mostrate qui:

public static tipo_enum [ ] values()
public static tipo_enum valueOf(String str)

Il metodo values() restituisce un array che contiene una lista delle costanti di enumerazione.

Il metodo valueOf() restituisce la costante di enumerazione il cui valore corrisponde alla stringa passata in str.

In entrambi i casi, tipo_enum è il tipo dell'enumerazione. Per esempio, nel caso dell'enumerazione Mela mostrata in precedenza, il tipo di ritorno di Mela.valueOf("Winesap") è Winesap.

Il seguente programma dimostra i metodi values() e valueOf():

// Usa i metodi di enumerazione incorporati.

// Un'enumerazione di varietà di mele.
enum Mela {
    Jonathan, Golden, Melannurca, Winesap, Cortland
}

class DemoEnum2 {

    public static void main(String[] args)
    {
        Mela mela;
        System.out.println("Qui ci sono tutte le costanti Mela:");

        // usa values()
        Mela[] tutteLeMele = Mela.values();

        for(Mela a : tutteLeMele)
            System.out.println(a);

        System.out.println();

        // usa valueOf()
        mela = Mela.valueOf("Winesap");
        System.out.println("mela contiene " + mela);
    }

}

L'output del programma è mostrato qui:

Qui ci sono tutte le costanti Mela:
Jonathan
Golden
Melannurca
Winesap
Cortland

mela contiene Winesap

Nota che questo programma usa un ciclo for in stile for-each per scorrere attraverso l'array di costanti ottenuto chiamando values(). Per motivi illustrativi, la variabile tutteLeMele è stata creata e gli è stato assegnato un riferimento all'array di enumerazione. Tuttavia, questo passaggio non è necessario perché il for avrebbe potuto essere scritto come mostrato qui, eliminando la necessità della variabile tutteLeMele:

for(Mela a : Mela.values())
    System.out.println(a);

Ora, si noti come il valore corrispondente al nome Winesap è stato ottenuto chiamando valueOf().

mela = Mela.valueOf("Winesap");

Come spiegato, valueOf() restituisce il valore di enumerazione associato al nome della costante rappresentato come stringa.