Strange Enum behaviour?

[Ec Kjellberg]

What happens in this (rather stupid) sample?
It looks like the static variable Enum.next is not initialised when the Enum are and therefore their member variable value is initialised with values from 0 to 2 (instead of 'a' to 'c' as one might think).

The output is at least:
a
0
1
2
a

And the code looks like:

public class EnumSample2
{
    enum Enum {
        A,B,C;
        char value;
        static char next = 'a';
        static char next() { return next++; }
        private Enum() {
            value = next();
        }
    }
    
    public static void main(String[]arr) {
        System.out.println(Enum.next);        
        System.out.println(Integer.valueOf(Enum.A.value));
        System.out.println(Integer.valueOf(Enum.B.value));
        System.out.println(Integer.valueOf(Enum.C.value));
        System.out.println(Enum.next);
    }
 
}

I assume that this is a well defined initialisation order behind this but nevertheless I was a little bit surprised.

If anyone care to elaborate a little bit and maybe explain a little I'd be very happy and maybe a little bit less confused.

Thanks // Ecka

[Steve Luke]

The enum will be translated to a class file, with each enum constant being a static constant inside the enum class declaration.

Since an enum constant is a static field, it has to be constructed inside a static block. To avoid problems with user-declared static field referring to the enum constants the static block is executed before initialization of the static fields.

If I were to write your enum as a class definition it would look like this (leaving out the built-in enum code):

public class Enum {
  char value;
 
  private Enum(...) { ...}
 
  static char next() { return next++; }
 
  //declare static Enum constants
  public static final Enum A;
  public static final Enum B;
  public static final Enum C;
 
  static {
    //initialize static Enum constanct
    A = new Enum(...);
    B = new Enum(...);
    C = new Enum(...);
    //other initializing code
  }
 
  static next = 'a';
}

So the enum constants are constructed before the static field 'next' is initialized.

[Jelle Klap]

If you really, really want to, and you really, really shouldn't, you could declare an inner class inside the enum. The inner class can declare and initialize static fields before the enum constructor runs, and make them accessible to the constructor.

public class EnumSample2 {

enum Enum {
A, B, C;

char value;

static char next() {
return EnumStatics.next++;
}
 
private Enum() {
value = next();
}

private static class EnumStatics
{
static char next = 'a';
}
}
 

public static void main(String[] arr)
{
System.out.println(Enum.next());
System.out.println(Enum.A.value);
System.out.println(Enum.B.value);
System.out.println(Enum.C.value);
System.out.println(Enum.next());
}
}

This modified version of your code sample will actually initialize the member value of Enum.A to char value 'a', Enum.B to char value 'b' and Enum.C to char value 'c', as soon as the Enum is used. The initial Enum.next() call will therefore yield char value 'd' and subsequent calls will continue to increment the value of the static field. So the output should read:
d
a
b
c
e
[ August 15, 2008: Message edited by: Jelle Klap ]

[Steve Luke]

Or move the value initializer into a user-defined static block after the next variable is defined. An example:

public class EnumSample2 {
enum Enum {
A, B, C;
char value;
static char next = 'a';
 
static char next() {
return next++;
}
 
static {
for (Enum e : values()) {
e.value = next();
}
}
 
private Enum() {
}
}
 
public static void main(String[] arr) {
System.out.println(Enum.next);
System.out.println(Character.valueOf(Enum.A.value));
System.out.println(Character.valueOf(Enum.B.value));
System.out.println(Character.valueOf(Enum.C.value));
System.out.println(Enum.next);
}
 
}

[Ilja Preuss]

Of course in this particular example, an alternative to get the needed behavior could be this:

enum Enum {
 A,B,C;
 public char getValue() {
   return name().toUpperCase().getChar(0);
 }
}

Or this:

enum Enum {
 A,B,C;
 public char getValue() {
   return (char) (ordinal() + 'a');
 }
}