It means that the type argument for enum has to derive from an enum which itself has the same type argument. How can this happen? By making the type argument the new type itself. So if I’ve got an enum called StatusCode, it would be equivalent to:
public class StatusCode extends Enum<StatusCode>
Now if you check the constraints, we’ve got Enum<StatusCode> – so E=StatusCode. Let’s check: does E extend Enum<StatusCode>? Yes! We’re okay.
You may well be asking yourself what the point of this is 🙂 Well, it means that the API for Enum can refer to itself – for instance, being able to say that Enum<E> implements Comparable<E>. The base class is able to do the comparisons (in the case of enums) but it can make sure that it only compares the right kind of enums with each other. (EDIT: Well, nearly – see the edit at the bottom.)
I’ve used something similar in my C# port of ProtocolBuffers. There are “messages” (immutable) and “builders” (mutable, used to build a message) – and they come as pairs of types. The interfaces involved are:
public interface IBuilder<TMessage, TBuilder>
where TMessage : IMessage<TMessage, TBuilder>
where TBuilder : IBuilder<TMessage, TBuilder>
public interface IMessage<TMessage, TBuilder>
where TMessage : IMessage<TMessage, TBuilder>
where TBuilder : IBuilder<TMessage, TBuilder>
This means that from a message you can get an appropriate builder (e.g. to take a copy of a message and change some bits) and from a builder you can get an appropriate message when you’ve finished building it. It’s a good job users of the API don’t need to actually care about this though – it’s horrendously complicated, and took several iterations to get to where it is.
EDIT: Note that this doesn’t stop you from creating odd types which use a type argument which itself is okay, but which isn’t the same type. The purpose is to give benefits in the right case rather than protect you from the wrong case.
So if Enum weren’t handled “specially” in Java anyway, you could (as noted in comments) create the following types:
public class First extends Enum<First> {}
public class Second extends Enum<First> {}
Second would implement Comparable<First> rather than Comparable<Second>… but First itself would be fine.