Re: enums

Roedy Green wrote:


An enum is an implicitly final class [1], inheriting from
java.lang.Enum, with some extra variables and methods, as defined by the
JLS. In summary, the following declaration:

public enum RandomEnum {
    VALUE1, VALUE2;
}

is equivalent to this:

public final class RandomEnum extends Enum<RandomEnum> {
    public static final RandomEnum VALUE1 = new RandomEnum("VALUE1", 0);
    public static final RandomEnum VALUE2 = new RandomEnum("VALUE2", 1);

    private RandomEnum(String name, int ordinal) {
        super(name, ordinal);
    }

    public static RandomEnum[] values() {
        return new RandomEnum[] {VALUE1, VALUE2};
    }

    public static RandomEnum valueOf(String name) {
        return Enum.valueOf(RandomEnum.class, name);
    }
}

Summarizing from the JLS, in rough order that it is stated:
* Enums cannot have an "extends <foo>" clause. Enums cannot have generic
type parameters.
* You can never say new <enum type>().
* Enums can not be constructed through reflection (!).
* Serialization and cloning (through java.lang.Enum) is special.
** i.e. VALUE1 and VALUE2 in the above example are the only RandomEnum's
in existence, at least until you modify the source.
* You cannot explicitly declare it to be abstract or final.
* An enum cannot have an abstract method unless all enum constants'
bodies implement the method. An enum cannot have an abstract method if
it has no enum constants with bodies, or if at least one enum constant
does not have a body.
* You cannot have a local enum: it must be nested.
* You cannot have a finalizer. Enums cannot be finalized.
* An enum E extends java.lang.Enum<E>. Normal logic for class extensions
apply here.
* Enums have implicit fields (the names of the constants), and implicit
methods (as shown in the above example).
* These implicit fields act as if they are declared at the top of the
class, i.e., they are initialized first. To protect the developer,
certain actions are forbidden because they would not work properly under
this rule anyways. In particular:
** It is a compile-time error to access a non-compile-time constant in
the initialization of an enum time.
** It is a compile-time error to access an enum constant other than ones
listed before the constant currently being defined. (Note: I do not know
how the values or valueOf methods would interact at this point. So it
would be worth checking out what this class prints out:

public enum EnumTest {
    A, B, C, D, E, F;
    EnumTest() {
      System.out.println(EnumTest.values());
    }
}
)

 > Can they extend something.

No. They extend Enum implicitly and cannot explicitly extend anything
(parser error).

 > Can they implement something? Can they implement Iterable?

Yes.


Some interesting enums that will not compile:

public enum EnumTest {
   A(B.ordinal() * 10), B(2);
   private int realValue;
   EnumTest(int value) {realValue = value;}
}
enum Color {
         RED, GREEN, BLUE;
         static final Map<String,Color> colorMap =
        new HashMap<String,Color>();
         Color() {
             colorMap.put(toString(), this);
         }
     } // Disclaimer: from JLS

Whereas these will compile:
public enum EnumTest {
   A(1), B(A.ordinal() * 10);
   private int realValue;
   EnumTest(int value) {realValue = value;}
}
enum Color {
         RED, GREEN, BLUE;
         static final Map<String,Color> colorMap =
        new HashMap<String,Color>();
         static {
             for (Color c : Color.values())
                 colorMap.put(c.toString(), c);
         }
     } // Disclaimer: from JLS

[1] Okay, to be perfectly clear. The enum type itself is final iff all
of its constants do not have bodies. I'm not sure about finality of enum
constant bodies (probably final), or about abstractness if the original
type has no constants without bodies (I would assume so). Playing around
with javap would help here.
--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth