In Java, l'enum è un tipo di riferimento (non lasciarti ingannare da quella piccola "e"). Puoi fare cose pulite con esso come definire i metodi. Un classico esempio di questo è il Operation enum definito come:
public enum Operation {
PLUS { double eval(double x, double y) { return x + y; } },
MINUS { double eval(double x, double y) { return x - y; } },
TIMES { double eval(double x, double y) { return x * y; } },
DIVIDE { double eval(double x, double y) { return x / y; } };
// Do arithmetic op represented by this constant
abstract double eval(double x, double y);
}
//Elsewhere:
Operation op = Operation.PLUS;
double two = op.eval(1, 1);
E puoi vedere ... sì, ha dei metodi e quindi non è un primitivo. Loro sono Oggetti.
C'è anche qualche magia che accade nel compilatore come descritto nel tutorial di Java Enum :
The compiler automatically adds some special methods when it creates an enum. For example, they have a static values method that returns an array containing all of the values of the enum in the order they are declared. This method is commonly used in combination with the for-each construct to iterate over the values of an enum type. For example, this code from the Planet class example below iterates over all the planets in the solar system.
E sarò certamente d'accordo che è fastidioso che questo non sia menzionato nel javadocs.
I valori restituiti dalla chiamata values() sono un array su cui è possibile eseguire l'iterazione.
class Demo {
enum DayOfWeek {
U, M, T, W, R, F, S
}
public static void main (String[] args) {
for (DayOfWeek day : DayOfWeek.values()) {
System.out.println(day.toString());
}
}
}
Stampa:
U
M
T
W
R
F
S
Esegui questo codice su ideone
Perché no? Bene, data la possibilità di ottenere l'array values() , riempie tutti i casi d'uso per il metodo next() ed è un po 'più potente.
Se davvero vuoi che il metodo next() richieda un po 'di un cerchio per ottenere la matrice in un oggetto Iterator (che è esso stesso una sostituzione per il tipo Enumeration - vedi javadoc ):
import java.util.*;
class Demo {
enum DayOfWeek {
U, M, T, W, R, F, S
}
public static void main (String[] args) {
Iterator days = Arrays.asList(DayOfWeek.values()).iterator();
while(days.hasNext()) {
System.out.println(days.next());
}
}
}
Esegui questo codice in ideone
Quindi, di nuovo, il motivo per cui non è lì è che non è necessario. Puoi recuperare un array dall'enumerazione in modo semplice e iterare o convertire tale array in Iterator che ti consente di chiamare next() .
C'è anche forse la confusione che si sarebbe provata a fare in modo che enum e Enumeration sembrassero troppo simili (hanno già un aspetto troppo simile) e cercano di rendere il enum più simile a Enumeration con le stesse chiamate di metodo avrebbero ulteriormente confuso le cose. Detto questo, questa è solo speculazione.
Fondamentalmente, Java enum è molto simile al C enum con la possibilità di avere alcuni metodi sul lato. È un po 'più limitato non è possibile avere numeri specifici dietro le quinte che puoi in C:
/* This is C */
enum cardsuit {
CLUBS = 1,
DIAMONDS = 2,
HEARTS = 4,
SPADES = 8
};
Le persone a volte puntano su Pascal e dicono che succ può essere chiamato su un enum lì, perché non in Java? Le enunciati Pascal sono tipi ordinali mentre i enumeri C non lo sono. Java prende in prestito da C piuttosto che da Pascal.
Non c'è niente che dice che non puoi definire la tua funzione next() o prev() . È piuttosto facile da fare dopo aver spostato un fastidio di riferimenti in avanti .
class Demo {
enum DayOfWeek {
U, M, T, W, R, F, S;
private DayOfWeek n;
private DayOfWeek p;
static {
U.n = M; U.p = S;
M.n = T; M.p = U;
T.n = W; T.p = M;
W.n = R; W.p = T;
R.n = F; R.p = W;
F.n = S; F.p = R;
S.n = U; S.p = F;
}
public DayOfWeek next() { return this.n; }
public DayOfWeek prev() { return this.p; }
}
public static void main (String[] args) {
System.out.println(DayOfWeek.M.next());
System.out.println(DayOfWeek.U.prev());
}
}
T
S
...
- L'enum è stato preso in prestito dalla tradizione C di un enum, non dalla tradizione Pascal dei tipi ordinali
- Non volevano confondere
enum con Enumeration
- Hai la possibilità di recuperare facilmente tutti i valori con un tipo iterabile
- È possibile definire un metodo
next() che funzioni in qualsiasi modo si desideri.