Question

In Java, with Sun’s JDK 1.6, with an enum such as this:

public enum MyEnum {
    FIRST_MEMBER { public void foo() { } },
    SECOND_MEMBER { public void foo() { } }, 
    THIRD_MEMBER { public void foo() { } };
}

The compiled files are:

MyEnum$1.class  MyEnum$2.class  MyEnum$3.class  MyEnum.class 

This also means that a stack trace showing foo(), or the method call printed in JVisualVM, etc., will have something like this at the top:

mypackage.MyEnum$1.run()

The $1 in the class name is due to the members of the enum being compiled to anonymous inner classes. I am wondering if it is safe to assume that the numbers used in these class names map to the order in which the enum members are defined? If it is not, is there a standard, guaranteed way to find the enum member from the number used as the anonymous class name?

---

EDIT

In regards to the design of the enum, this was used for illustration purposes only. The real enum implements an interface, and each member provides a different implementation of the methods. Please don’t pay too much attention to what admittedly looks a bit strange.

---

EDIT #2

To clarify, I am not trying to do anything with this information programmatically (such as weird reflection nonsense). Rather, I am looking at stack traces and profiling information, and trying to map a method call on an enum member (shown as a call on an anonymous class) against the actual enum member in the source code.

Answer 1

In stacktraces, you’ll also get the line number in the source file. Assuming you have the source, that’ll reveal which constant it is. (In eclipse, simply click the line number in the console view to directly navigate to the source).

To find the constant name for a class, you could grab the class file for the enum, and disassemble the static initializer. For instance, if you compile:

enum PieceColor {
    Black {
        @Override public String toString() { return "dark";}
    },
    White {
        @Override public String toString() { return "light";}       
    }
}

and then do:

javap -c PieceColor

you get:

static {};
  Code:
   0:   new #13; //class tools/PieceColor$1
   3:   dup
   4:   ldc #15; //String Black
   6:   iconst_0
   7:   invokespecial   #16; //Method tools/PieceColor$1."<init>":(Ljava/lang/String;I)V
   10:  putstatic   #20; //Field Black:Ltools/PieceColor;
   13:  new #22; //class tools/PieceColor$2
   16:  dup
   17:  ldc #24; //String White
   19:  iconst_1
   20:  invokespecial   #25; //Method tools/PieceColor$2."<init>":(Ljava/lang/String;I)V
   23:  putstatic   #26; //Field White:Ltools/PieceColor;

But there might be a more elegant method, but if all else fails, this should do the trick.