When you create an enum, an associated class is produced for you by the compiler. This class is automatically inherited from java.lang.Enum.
The ordinal( ) method produces an int indicating the declaration order of each enum instance, starting from zero.
Using static imports with enums
Is it better to be explicit and qualify all enum instances? It probably depends on the complexity of your code.
Adding methods to an enum
Except for the fact that you can’t inherit from it, an enum can be treated much like a regular class.
You may want to produce different descriptions for an enumeration than the default toString( ).
If you are going to define methods you must end the sequence of enum instances with a semicolon.
Java forces you to define the instances as the first thing in the enum.
The constructor can only be used to create the enum instances that you declare inside the enum definition.
The compiler won’t let you use it to create any new instances once the enum definition is complete.
Overriding enum methods
Overriding the toString( ) method for an enum is the same as overriding it for a regular class.
enums in switch statements
Ordinarily, a switch only works with an integral value, but since enums have an established integral order and the order of an instance can be produced with the ordinal( ) method, enums can be used in switch statements.
Although normally you must qualify an enum instance with its type, you do not have to do this in a case statement.
The compiler does not complain that there is no default statement inside the switch.
On the other hand, if you are calling return from case statements, the compiler will complain if you don’t have a default.
The mystery of values()
If you look at Enum, you’ll see that there is no values( ) method, even though we’ve been using it.
values( ) is a static method that is added by the compiler.
In the output, you can see that Explore has been made final by the compiler, so you cannot inherit from an enum.
Because values( ) is a static method inserted into the enum definition by the compiler, if you upcast an enum type to Enum, the values( ) method will not be available.
Even if values( ) is not part of the interface of Enum, you can still get the enum instances via the Class object.
Implements, not inherits
All enums extend java.lang.Enum. Since Java does not support multiple inheritance, this means that you cannot create an enum via inheritance.
It is possible to create an enum that implements one or more interfaces.
Using interfaces for organization
The motivation for inheriting from an enum comes partly from wanting to extend the number of elements in the original enum, and partly from wanting to create subcategories by using subtypes.
You can achieve categorization by grouping the elements together inside an interface and creating an enumeration based on that interface.
Another, more compact, approach to the problem of categorization is to nest enums within enums.
Using EnumSet instead of flags
An enum requires that all its members be unique, so it would seem to have set behavior, but since you can’t add or remove elements it’s not very useful as a set.
Internally, it is represented by (if possible) a single long that is treated as a bit-vector, so it’s extremely fast and efficient.
EnumSets are built on top of longs, a long is 64 bits, and each enum instance requires one bit to indicate presence or absence. This means you can have an EnumSet for an enum of up to 64 elements without going beyond the use of a single long.
Using EnumMap
An EnumMap is a specialized Map that requires that its keys be from a single enum.
An EnumMap can be implemented internally as an array.
You can only call put( ) for keys that are in your enum, but other than that it’s like using an ordinary Map.
The order of elements in the EnumMap is determined by their order of definition in the enum.
An EnumMap allows you to change the value objects, whereas constant-specific methods are fixed at compile time.
Constant-specific methods
You define one or more abstract methods as part of the enum, then define the methods for each enum instance.
You can look up and call methods via their associated enum instance.
Each instance is a distinct type.
You cannot treat enum instances as class types.
Because they are static, enum instances of inner enums do not behave like ordinary inner classes.
It is possible to override constant-specific methods, instead of implementing an abstract method.
Chain of Responsibility with enums
In the Chain of Responsibility design pattern, you create a number of different ways to solve a problem and chain them together.
When a request occurs, it is passed along the chain until one of the solutions can handle the request.
Each strategy is tried in turn until one succeeds or they all fail.
State machines with enums
Enumerated types can be ideal for creating state machines.
Because enums restrict the set of possible cases, they are quite useful for enumerating the different states and inputs.
Multiple dispatching
Java only performs single dispatching.
If you are performing an operation on more than one object whose type is unknown, Java can invoke the dynamic binding mechanism on only one of those types.
If you want double dispatching, there must be two method calls: the first to determine the first unknown type, and the second to determine the second unknown type.
Generally, you’ll set up a configuration such that a single method call produces more than one virtual method call and thus services more than one type in the process.
Dispatching with enums
You can’t use enum instances as argument types.
There are a number of different approaches to implementing multiple dispatching which benefit from enums.
Using constant-specific methods
Because constant-specific methods allow you to provide different method implementations for each enum instance, they might seem like a perfect solution for setting up multiple dispatching.
Dispatching with EnumMaps
It’s possible to perform a "true" double dispatch using the EnumMap class, which is specifically designed to work very efficiently with enums.
Using a 2-D array
A two-dimensional array mapping the competitors onto the outcomes produces the smallest and most straightforward solution.
It’s not quite as "safe" as the previous examples because it uses an array.
