Java Language Dichiarare e usare un enum di base


Esempio

Enum può essere considerato come lo zucchero di sintassi per una classe sigillata che viene istanziata solo un numero di volte noto in fase di compilazione per definire un insieme di costanti.

Un enum semplice per elencare le diverse stagioni sarebbe dichiarato come segue:

public enum Season {
    WINTER,
    SPRING,
    SUMMER,
    FALL
}

Anche se le costanti enum non devono necessariamente essere in maiuscolo, è convenzione Java che i nomi delle costanti sono interamente in maiuscolo, con le parole separate da caratteri di sottolineatura.


Puoi dichiarare un Enum nel suo file:

/**
 * This enum is declared in the Season.java file.
*/
public enum Season {
    WINTER,
    SPRING,
    SUMMER,
    FALL
}

Ma puoi anche dichiararlo in un'altra classe:

 public class Day {

    private Season season;

    public String getSeason() {
        return season.name();
    }

    public void setSeason(String season) {
        this.season = Season.valueOf(season);
    }

    /**
     * This enum is declared inside the Day.java file and 
     * cannot be accessed outside because it's declared as private.
     */
    private enum Season {
        WINTER,
        SPRING,
        SUMMER,
        FALL
    }

}

Infine, non puoi dichiarare un Enum all'interno di un corpo o costruttore di un metodo:

public class Day {

    /**
     * Constructor
    */
    public Day() {
        // Illegal. Compilation error
        enum Season {
            WINTER,
            SPRING,
            SUMMER,
            FALL
        }
    }

    public void aSimpleMethod() {
        // Legal. You can declare a primitive (or an Object) inside a method. Compile!
        int primitiveInt = 42;

        // Illegal. Compilation error.
        enum Season {
            WINTER,
            SPRING,
            SUMMER,
            FALL
        }

        Season season = Season.SPRING;
    }
    
}

Le costanti enum duplicate non sono consentite:

public enum Season {
    WINTER,
    WINTER, //Compile Time Error : Duplicate Constants
    SPRING,
    SUMMER,
    FALL
} 

Ogni costante di enum è public , static e final di default. Poiché ogni costante è static , è possibile accedervi direttamente utilizzando il nome dell'enumerazione.

Le costanti Enum possono essere passate come parametri del metodo:

public static void display(Season s) {
    System.out.println(s.name());  // name() is a built-in method that gets the exact name of the enum constant
}

display(Season.WINTER);  // Prints out "WINTER"

È possibile ottenere un array di costanti enum utilizzando il metodo values() . I valori sono garantiti per essere nell'ordine di dichiarazione nell'array restituito:

Season[] seasons = Season.values();

Nota: questo metodo alloca un nuovo array di valori ogni volta che viene chiamato.


Per scorrere le costanti enum:

public static void enumIterate() {
    for (Season s : Season.values()) {
        System.out.println(s.name());
    }
}

È possibile utilizzare le enumerazioni in un'istruzione switch :

public static void enumSwitchExample(Season s) {
    switch(s) {
        case WINTER:
            System.out.println("It's pretty cold");
            break;
        case SPRING:
            System.out.println("It's warming up");
            break;
        case SUMMER:
            System.out.println("It's pretty hot");
            break;
        case FALL:
            System.out.println("It's cooling down");
            break;
    }
}

Puoi anche confrontare le costanti enum usando == :

Season.FALL == Season.WINTER    // false
Season.SPRING == Season.SPRING  // true

Un altro modo per confrontare le costanti enum è usando equals() come sotto, che è considerato una cattiva pratica in quanto si può facilmente cadere in insidie ​​come segue:

Season.FALL.equals(Season.FALL); // true
Season.FALL.equals(Season.WINTER); // false
Season.FALL.equals("FALL"); // false and no compiler error

Inoltre, sebbene l'insieme di istanze enum non possa essere modificato in fase di esecuzione, le istanze stesse non sono intrinsecamente immutabili poiché come qualsiasi altra classe, un enum può contenere campi mutabili come illustrato di seguito.

public enum MutableExample {
    A,
    B;

    private int count = 0;

    public void increment() {
        count++;
    }

    public void print() {
        System.out.println("The count of " + name() + " is " + count);
    }
}

// Usage:
MutableExample.A.print();       // Outputs 0
MutableExample.A.increment();
MutableExample.A.print();       // Outputs 1 -- we've changed a field   
MutableExample.B.print();       // Outputs 0 -- another instance remains unchanged

Tuttavia, una buona pratica è rendere le istanze enum immutabili, cioè quando non hanno campi aggiuntivi o tutti questi campi sono contrassegnati come final e sono immutabili. Ciò garantirà che per tutta la durata dell'applicazione l' enum non perderà memoria e che è sicuro utilizzare le sue istanze su tutti i thread.


Enum implementa implicitamente Serializable e Comparable perché la classe Enum esegue:

public abstract class Enum<E extends Enum<E>>
extends Object
implements Comparable<E>, Serializable