Effective Java

---

CHAPTER 6
ENUMS AND ANNOTATIONS
176
Item 38: Emulate extensible enums with interfaces
In almost all respects, enum types are superior to the typesafe enum pattern
described in the first edition of this book [Bloch01]. On the face of it, one excep-
tion concerns extensibility, which was possible under the original pattern but is
not supported by the language construct. In other words, using the pattern, it was
possible to have one enumerated type extend another; using the language feature,
it is not. This is no accident. For the most part, extensibility of enums turns out to
be a bad idea. It is confusing that elements of an extension type are instances of
the base type and not vice versa. There is no good way to enumerate over all of the
elements of a base type and its extensions. Finally, extensibility would complicate
many aspects of the design and implementation.
That said, there is at least one compelling use case for extensible enumerated
types, which is 
operation codes,
also known as 
opcodes.
An opcode is an enumer-
ated type whose elements represent operations on some machine, such as the
Operation
type in Item 34, which represents the functions on a simple calculator.
Sometimes it is desirable to let the users of an API provide their own operations,
effectively extending the set of operations provided by the API.
Luckily, there is a nice way to achieve this effect using enum types. The basic
idea is to take advantage of the fact that enum types can implement arbitrary inter-
faces by defining an interface for the opcode type and an enum that is the standard
implementation of the interface. For example, here is an extensible version of the
Operation
type from Item 34: