enumerazioni

[newutente]

Sto studiando le enumerazioni e in particolar modo quando vanno utilizzate e vorrei sapere se questo pezzo di codice può essere considerato valido:

public enum AzioneEnum
{
      AVANTI, INDIETRO, FERMO;
}

public class Classe
{
...

     public void esegui(enum azione)
     {
             switch(azione)
             {
                     case AzioneEnum.AVANTI:
                                   vaiAvanti();
                     break;

                     case AzioneEnum.INDIETRO:
                                   vaiIndietro();
                     break;
 
                     case AzioneEnum.FERMO:
                                   fermati();
                     break;    
             }
     }

...
}

[andbin]

quando vanno utilizzate

Sono molto utili quando si vuole avere un set finito e noto a priori di valori. Prima di Java 5 si potevano usare delle costanti int (o altro tipo) ma ... ovviamente era più problematico.
Casi validi: nomi dei giorni, nomi dei mesi, nomi dei pezzi degli scacchi, ecc.....

e vorrei sapere se questo pezzo di codice può essere considerato valido

La definizione della enum è corretta. Non è obbligatorio in questo caso il ";" dopo FERMO. Il ";" è invece obbligatorio se nella enum si vogliono mettere altri membri (costruttori, campi, metodi, ecc.... sì, se non lo sai una enum può essere ben di più che i soli nomi delle costanti).

Mettere "Enum" come suffisso comunque non è una convenzione standard o strettamente necessaria.

     public void esegui(enum azione)

Qui no, non devi ripetere enum, devi mettere tipo e nome del parametro, es.:

public void esegui(AzioneEnum azione)

case AzioneEnum.AVANTI:

Il case NON deve contenere il tipo della enum ... solo la costante.

case AVANTI:

Il compilatore "sa" il tipo della enum dalla espressione nello switch. È proibito mettere il tipo della enum proprio perché comunque non puoi usare costanti di altre enum!

[newutente]

Quindi il codice corretto è questo:

public enum AzioneEnum
{
      AVANTI, INDIETRO, FERMO;
}

public class Classe
{
...

     public void esegui(AzioneEnum azione)
     {
             switch(azione)
             {
                     case AVANTI:
                                   vaiAvanti();
                     break;

                     case INDIETRO:
                                   vaiIndietro();
                     break;
 
                     case FERMO:
                                   fermati();
                     break;    
             }
     }

...
}

Io però non capisco una cosa. Come posso utilizzare le costanti AVANTI, INDIETRO e FERMO presenti nella enumerazione se non le ho neanche inizializzate?
Mi riferisco ovviamente all'esempio di sopra ma anche a questa istruzione:

System.out.println(AzioneEnum.AVANTI);

che secondo il manuale restituisce questo output:

AVANTI

E' vero che nella enumerazione, se non sbaglio, non posso avere un'istruzione di inizializzazione di una costante ma allora come faccio ad avere quell'output?

[andbin]

Quindi il codice corretto è questo:

Sì, tecnicamente corretto.

Come posso utilizzare le costanti AVANTI, INDIETRO e FERMO presenti nella enumerazione se non le ho neanche inizializzate?

Le costanti letterali della enum (i tuoi AVANTI, ecc...) sono riferimenti ad oggetti già istanziati!
Queste costanti sono alla fin fine campi static e final della enum che sono dello stesso tipo della enum e vengono inizializzati in automatico assegnando istanze distinte della enum.

Il compilatore traduce la enum in una cosa che è molto molto simile a:

public final class AzioneEnum extends java.lang.Enum<AzioneEnum> {
    public static final AzioneEnum AVANTI = new AzioneEnum("AVANTI");
    public static final AzioneEnum INDIETRO = new AzioneEnum("INDIETRO");
    public static final AzioneEnum FERMO = new AzioneEnum("FERMO");
}

Preciso che il codice sopra è molto fittizio, quello che viene generato a livello di bytecode è, ripeto, molto simile ma non esattamente uguale a questo. C'è dell'altro infatti, ci sono altre cose generate.

Serve solo per far capire che quei AVANTI ecc... sono campi con già un valore, un oggetto della enum.

Quindi la espressione AzioneEnum.AVANTI è il riferimento ad un oggetto già esistente!

[newutente]

Quindi in poche parole i valori di una enumerazione altro non sono che oggetti del tipo della enumerazione che contengono una stringa. Giusto?

[andbin]

Quindi in poche parole i valori di una enumerazione altro non sono che oggetti del tipo della enumerazione che contengono una stringa. Giusto?

Sì, è così. E anzi, per essere precisi ciascuna istanza della enum ha un "name" (ottenibile dal name() ) ma ha anche un "ordinal" (la posizione all'interno della enum, ottenibile da ordinal() ). Quindi se volessimo abbozzare in modo più vicino alla realtà la dichiarazione delle costanti, dovrebbe essere molto simile a:

public static final AzioneEnum AVANTI = new AzioneEnum("AVANTI", 0);
public static final AzioneEnum INDIETRO = new AzioneEnum("INDIETRO", 1);
public static final AzioneEnum FERMO = new AzioneEnum("FERMO", 2);

Questi comunque sono dettagli molto interni delle enum. A parte queste finezze, credo che ora tu abbia una idea più chiara delle enum!

[newutente]

si ora ho un'idea più chiara.