Java Enum Class
Last modified: April 13, 2025
The java.lang.Enum class serves as the common base for all Java
enumeration types. Enums provide a way to define a set of named constants,
ensuring type safety and improving code readability and maintainability. They
eliminate the need for traditional constant definitions using static
final variables, preventing invalid values from being assigned.
Like regular classes, enums in Java can contain fields, methods, and
constructors, but they are primarily used to represent fixed sets of constants
with built-in type safety. They can implement interfaces, allowing additional
behavior customization, but cannot extend other classes since they implicitly
extend java.lang.Enum. This makes enums the ideal choice for
representing fixed sets of related constants, such as days of the week, error
codes, or configuration options.
Enum Class Methods
The Enum class provides several utility methods that help manage
and interact with enum instances. Some key methods include:
name()- Returns the name of the enum constant as a string.ordinal()- Returns the position (zero-based index) of the constant in the enum declaration.toString()- Provides a string representation of the enum constant.equals(Object obj)- Checks if two enum constants are equal.compareTo(E other)- Compares the order of two enum constants based on their ordinal values.values()- Returns an array of all declared constants in the enum (automatically generated by the compiler).valueOf(String name)- Converts a string into the corresponding enum constant, throwing an exception if the name is invalid.
By leveraging enums, developers can create structured, self-documenting code while ensuring correctness through enforced value constraints.
Basic Enum Declaration
The simplest form of enum declaration defines a set of named constants. Each constant is an instance of the enum type. Enums are implicitly public, static, and final. They can be used in switch statements and provide compile-time type safety.
enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
}
void main() {
Day today = Day.WEDNESDAY;
System.out.println("Today is: " + today);
System.out.println("Ordinal value: " + today.ordinal());
System.out.println("Name: " + today.name());
// Using enum in switch statement
switch (today) {
case MONDAY:
System.out.println("Start of work week");
break;
case WEDNESDAY:
System.out.println("Midweek");
break;
case FRIDAY:
System.out.println("Almost weekend");
break;
default:
System.out.println("Other day");
}
}
This example demonstrates a basic enum declaration and usage. The Day
enum defines seven constants representing days of the week. We show how to access
an enum constant, its ordinal value, and name. The example also demonstrates
using enums in switch statements.
Enum with Fields and Methods
Enums can have fields, methods, and constructors just like regular classes. Each enum constant can have its own instance-specific behavior. The enum constructor must be private or package-private as enum constants can only be created within the enum itself.
enum Planet {
MERCURY(3.303e+23, 2.4397e6),
VENUS(4.869e+24, 6.0518e6),
EARTH(5.976e+24, 6.37814e6),
MARS(6.421e+23, 3.3972e6),
JUPITER(1.9e+27, 7.1492e7),
SATURN(5.688e+26, 6.0268e7),
URANUS(8.686e+25, 2.5559e7),
NEPTUNE(1.024e+26, 2.4746e7);
private final double mass; // in kilograms
private final double radius; // in meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
public double surfaceGravity() {
double G = 6.67300E-11;
return G * mass / (radius * radius);
}
public double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
}
void main() {
double earthWeight = 70; // kg
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values()) {
System.out.printf("Your weight on %s is %f kg%n",
p, p.surfaceWeight(mass));
}
}
This example shows an enum with fields and methods. The Planet enum
represents planets in our solar system with mass and radius properties. Each
planet constant provides methods to calculate surface gravity and weight. The
example calculates and prints a person's weight on each planet.
Enum with Abstract Methods
Enums can declare abstract methods that must be implemented by each enum constant. This allows each constant to define its own behavior while sharing common enum functionality. This pattern is known as the constant-specific method implementation.
enum Operation {
PLUS {
public double apply(double x, double y) { return x + y; }
},
MINUS {
public double apply(double x, double y) { return x - y; }
},
TIMES {
public double apply(double x, double y) { return x * y; }
},
DIVIDE {
public double apply(double x, double y) { return x / y; }
};
public abstract double apply(double x, double y);
}
void main() {
double x = 10;
double y = 5;
for (Operation op : Operation.values()) {
System.out.printf("%s %s %s = %s%n",
x, op, y, op.apply(x, y));
}
}
This example demonstrates an enum with an abstract method. The Operation
enum defines four basic arithmetic operations. Each constant implements the
apply method with its specific behavior. The example shows how to
iterate through all operations and apply them to sample values.
Enum Implementing Interfaces
Enums can implement interfaces just like regular classes. This allows enums to provide polymorphic behavior while maintaining their type safety and fixed set of instances. Each enum constant can implement interface methods differently.
interface Command {
void execute();
}
enum FileOperation implements Command {
OPEN {
public void execute() {
System.out.println("Opening file...");
}
},
SAVE {
public void execute() {
System.out.println("Saving file...");
}
},
CLOSE {
public void execute() {
System.out.println("Closing file...");
}
};
}
void main() {
Command[] operations = FileOperation.values();
for (Command cmd : operations) {
cmd.execute();
}
}
This example shows an enum implementing an interface. The FileOperation
enum implements the Command interface, with each constant providing
its own implementation of the execute method. The example
demonstrates how to treat enum constants polymorphically through the interface.
Enum with Static Factory Method
Enums can have static factory methods that return enum constants based on
specific criteria. This is useful when you need to look up enum constants by
properties other than their name. The valueOf method provided by
default only looks up by name.
enum HttpStatus {
OK(200, "OK"),
NOT_FOUND(404, "Not Found"),
SERVER_ERROR(500, "Internal Server Error");
private final int code;
private final String description;
HttpStatus(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() { return code; }
public String getDescription() { return description; }
public static HttpStatus fromCode(int code) {
for (HttpStatus status : values()) {
if (status.code == code) {
return status;
}
}
throw new IllegalArgumentException("No status for code: " + code);
}
}
void main() {
HttpStatus status = HttpStatus.fromCode(404);
System.out.println(status + ": " + status.getDescription());
try {
HttpStatus.fromCode(999);
} catch (IllegalArgumentException e) {
System.out.println("Error: " + e.getMessage());
}
}
This example demonstrates an enum with a static factory method. The
HttpStatus enum represents HTTP status codes with their
descriptions. The fromCode method looks up statuses by their
numeric code. The example shows both successful lookup and error handling.
Enum with State and Behavior
Enums can maintain state and implement complex behavior. They can be used to implement state machines or other patterns where a fixed set of instances with specific behavior is needed. This example shows a simple vending machine state.
enum VendingMachineState {
IDLE {
public VendingMachineState nextState() {
return WAITING_FOR_MONEY;
}
},
WAITING_FOR_MONEY {
public VendingMachineState nextState() {
return DISPENSING;
}
},
DISPENSING {
public VendingMachineState nextState() {
return IDLE;
}
},
OUT_OF_STOCK {
public VendingMachineState nextState() {
return this;
}
};
public abstract VendingMachineState nextState();
}
void main() {
VendingMachineState state = VendingMachineState.IDLE;
System.out.println("Initial state: " + state);
state = state.nextState();
System.out.println("After first transition: " + state);
state = state.nextState();
System.out.println("After second transition: " + state);
state = state.nextState();
System.out.println("After third transition: " + state);
state = VendingMachineState.OUT_OF_STOCK;
System.out.println("Out of stock state remains: " +
state.nextState());
}
This example shows an enum implementing a simple state machine. The
VendingMachineState enum represents different states of a vending
machine. Each state knows its next state through the nextState
method. The example demonstrates state transitions and the special case of
OUT_OF_STOCK which doesn't transition.
Source
In this article, we've covered all major aspects of the Java Enum
class with practical examples. Enums are powerful constructs that go beyond
simple constants, offering type safety, encapsulation, and polymorphic behavior.
Author
List all Java tutorials.