name
and valueOf
simply use the text of the enum constants, while toString may
be overridden to provide any content, if desired

for enum constants, equals and == amount to the same
thing, and can be used interchangeably

enum constants are implicitly public static final

the order of appearance of enum constants is called their "natural order",
and defines the order used by other items as well : compareTo,
iteration order of values , EnumSet, EnumSet.range.

enums have a built-in
serialization
mechanism, which can't be overridden. The mechanism uses the
name
and valueOf methods.

Warning:

As with any class, it's easy to provide methods in an enum type which
change the state of an enum constant. Thus, the term "enum constant" is
rather misleading. What is constant is the identity of the enum
element, not its state. Perhaps a better term would have been "enum element"
instead of "enum constant".

Constructors for an enum type should be declared as private. The
compiler allows non private declares for constructors, but this seems misleading
to the reader, since new can never be used with enum types.

(This discussion closely follows the techniques described in the first edition of Effective
Java.)

Prior to JDK 1.5, type-safe enumerations can be implemented as a regular
Java class. They come in various styles, corresponding to the features
they include:

a List of VALUES, for iterating over all values of the
enumeration

implementing a valueOf method for parsing text into an enumeration
element

implementing Comparable

implementing Serializable

Exporting a List of VALUES is highly recommended. It
gives users an Iterator for cycling through all possible values.
The alternative (hard-coding particular values of the enumeration) will
break when those values change or are extended to include new values.

Comparison of two objects belonging to an enumeration is the same in
all styles :

the Object.equals method is never overridden

either equals or == can be used to perform comparisons,
since they amount to the same thing

Example 1

VerySimpleSuit is a minimal type-safe enumeration. It is almost
as simple as defining a set of related Strings or ints,
apart from the private, empty constructor.