Enumerations
An enumeration is a list of named constants that define a new data type. It allows you to create type-safe collections of related values. An object of an enumeration type can hold only the values that are defined by the list.
enum Month {
JANUARY, FEBRUARY, MARCH, ..., DECEMBER
}
You can use enums to define:
Days of the week
Months of the year
Status codes like
SUCCESS
,FAILED
,WAITING
Enums replace the older approach of using final
variables for constants with a more structured and powerful alternative.
Enumeration Fundamentals
Defining an Enum
Use the enum
keyword to create an enumeration:
enum Transport {
CAR, TRUCK, AIRPLANE, TRAIN, BOAT
}
These constants (
CAR
,TRUCK
, etc.) are implicitly:public
static
final
They are also self-typed:
Transport.CAR
is of typeTransport
.
Naming Convention: Enum constants are typically written in uppercase, just like
final
constants.
Declaring Enum Variables
Transport tp;
tp = Transport.AIRPLANE;
You don’t use new
to instantiate enum values. You assign them directly using the enum constants.
This assigns tp
the value AIRPLANE
. Because tp
is of type Transport, the only values that it can be assigned are those defined by the enumeration.
Comparing Enum Values
Enums can be compared using ==
or in a switch
statement:
if (tp == Transport.TRAIN) {
// Do something
}
Using Enum in a switch
:
switch (tp) {
case CAR:
System.out.println("A car carries people.");
break;
case TRUCK:
System.out.println("A truck carries freight.");
break;
}
In case statements, enum constants are used without the enum name, e.g.,
CAR
, notTransport.CAR
.
This is because the type of the enumeration in the switch expression has already implicitly specified the enum type of the case constants. There is no need to qualify the constants in the case statements with their enum type name.
Printing Enum Constants
System.out.println(Transport.BOAT);
// Output: BOAT
The enum constant name is printed by default.
Basic Enum Usage
enum Transport {
CAR, TRUCK, AIRPLANE, TRAIN, BOAT
}
class EnumDemo {
public static void main(String[] args) {
Transport tp = Transport.AIRPLANE;
System.out.println("Value of tp: " + tp);
if (tp == Transport.TRAIN)
System.out.println("tp contains TRAIN.\n");
switch (tp) {
case CAR:
System.out.println("A car carries people.");
break;
case AIRPLANE:
System.out.println("An airplane flies.");
break;
}
}
}
Enums Are Class Types
In Java, even though not instantiated, enums are classes. This means enums can have:
Constructors
Methods
Fields (instance variables)
Can implement interfaces
But enums:
Cannot extend other classes
Cannot be extended (because they're
final
)
Built-in Enum Methods
Every enum extends the abstract class java.lang.Enum
, which gives:
Method | Description |
---|---|
values() | Returns an array of all enum constants |
valueOf() | Returns the constant with the specified name |
ordinal() | Returns the constant's position (0-based) |
compareTo() | Compares the ordinal values |
values()
and valueOf()
enum Transport {
CAR, TRUCK, AIRPLANE, TRAIN, BOAT
}
class EnumDemo2 {
public static void main(String[] args) {
Transport tp = Transport.valueOf("AIRPLANE");
// Transport[] allTransports = Transport.values();
System.out.println("All transport constants:");
for (Transport t : Transport.values())
System.out.println(t);
System.out.println("\ntp contains " + tp);
}
}
Here are all Transport constants
CAR
TRUCK
AIRPLANE
TRAIN
BOAT
tp contains AIRPLANE
Enums with Constructors and Methods
When an enumeration contains other members, the enumeration list must end in a semicolon. The last constant, BOAT, is followed by a semicolon.
enum Transport {
CAR(65), TRUCK(55), AIRPLANE(600), TRAIN(70), BOAT(22);
private int speed; // instance variable
Transport(int s) {
speed = s; // constructor
}
int getSpeed() {
return speed; // method
}
}
Each enum constant is an object of enumeration type. You can attach data and behavior. When constructor is defined for an enum, the constructor is called when each enumeration constant is created.
Using the Enum:
public class EnumDemo {
public static void main(String[] args) {
System.out.println("Airplane speed: "
+ Transport.AIRPLANE.getSpeed()
+ " mph");
System.out.println("All transport speeds:");
for (Transport t : Transport.values())
System.out.println(t + ": " + t.getSpeed()
+ " mph");
}
}
Typical speed for an airplane is 600 miles per hour.
All Transport speeds:
CAR typical speed is 65 miles per hour.
TRUCK typical speed is 55 miles per hour.
AIRPLANE typical speed is 600 miles per hour.
TRAIN typical speed is 70 miles per hour.
BOAT typical speed is 22 miles per hour.
ordinal()
and compareTo()
enum Days { MONDAY, TUESDAY, WEDNESDAY }
Days d1 = Days.MONDAY;
Days d2 = Days.WEDNESDAY;
System.out.println(d1.ordinal());
// Output: 0
System.out.println(d1.compareTo(d2));
// Output: -2
ordinal()
gives position (starting from 0)compareTo()
compares positions
Traffic Light Simulation
enum TrafficLightColor { RED, GREEN, YELLOW }
class TrafficLightSimulator implements Runnable {
private TrafficLightColor tlc = TrafficLightColor.RED;
private boolean stop = false;
private boolean changed = false;
public void run() {
while (!stop) {
try {
switch (tlc) {
case GREEN -> Thread.sleep(10000);
case YELLOW -> Thread.sleep(2000);
case RED -> Thread.sleep(12000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
changeColor();
}
}
synchronized void changeColor() {
switch (tlc) {
case RED -> tlc = TrafficLightColor.GREEN;
case GREEN -> tlc = TrafficLightColor.YELLOW;
case YELLOW -> tlc = TrafficLightColor.RED;
}
changed = true;
notify();
}
synchronized void waitForChange() {
try {
while (!changed)
wait();
changed = false;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized TrafficLightColor getColor() {
return tlc;
}
synchronized void cancel() {
stop = true;
}
}
public class TrafficLightDemo {
public static void main(String[] args) {
TrafficLightSimulator tl = new TrafficLightSimulator();
Thread thrd = new Thread(tl);
thrd.start();
for (int i = 0; i < 9; i++) {
System.out.println(tl.getColor());
tl.waitForChange();
}
tl.cancel();
}
}
Enums restrict the light color to only three valid values:
RED
,GREEN
,YELLOW
.Enums make code cleaner, type-safe, and more readable.
Summary
Feature | Explanation |
---|---|
enum keyword | Defines a list of named constants |
values() | Returns array of all constants |
valueOf("NAME") | Returns the constant matching the string |
Custom fields and methods | You can attach data and logic to each constant |
ordinal() | Returns the position of a constant in its declaration |
compareTo() | Compares constants by their position |
Switch compatibility | Can use enums in switch without qualification |
Can't extend or be extended | Enums are implicitly final and can't extend other classes |
Inherits from Enum | All enums extend java.lang.Enum class |