Core Java · Chapter 09

Enums

Type-safe constants with fields, constructors and behaviour, plus EnumSet, EnumMap and JPA persistence.

◷ 6 min read§ 24 sections? 10 interview questions{ } 30 code examples

#Introduction

An Enum (Enumeration) is a special Java type used to represent a fixed set of constants.

Instead of using hardcoded values like:

Java

String status = "ACTIVE";

we use:

Java

Status status = Status.ACTIVE;

Enums improve:

Type Safety
Readability
Maintainability
Compile-time checking

Enums were introduced in Java 5 and are heavily used in enterprise applications.

#What is an Enum?

An Enum defines a predefined list of constants.

Java

enum Day {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Usage:

Java

Day today = Day.MONDAY;
System.out.println(today);

Output

MONDAY

#Why Enums?

Instead of:

Java

String paymentType = "CARD";

someone may accidentally write:

Java

paymentType = "CRAD";

The compiler won't detect the mistake. Using an Enum:

Java

PaymentType type = PaymentType.CARD;

Invalid values are rejected during compilation.

#Internal Working

Every Enum automatically extends java.lang.Enum. Internally,

Java

enum Status {
    ACTIVE,
    INACTIVE
}

behaves roughly like:

Java

final class Status extends Enum<Status> {
    public static final Status ACTIVE;
    public static final Status INACTIVE;
}

#Creating an Enum

Java

public enum Status {
    ACTIVE,
    INACTIVE,
    BLOCKED
}

Usage:

Java

Status status = Status.ACTIVE;

#Enum Constants are Singleton Objects

Each enum constant exists only once.

Status
- ACTIVE
- INACTIVE
- BLOCKED

Therefore, Status.ACTIVE == Status.ACTIVE always returns true.

#Enum Methods

Every Enum provides useful methods.

values()

Returns all constants.

Java

for (Status s : Status.values()) {
    System.out.println(s);
}

Output

ACTIVE
INACTIVE
BLOCKED

valueOf()

Converts a String to an Enum.

Java

Status status = Status.valueOf("ACTIVE");

Output

ACTIVE

Invalid value:

Java

Status.valueOf("TEST");

Output

IllegalArgumentException

ordinal()

Returns the position.

Java

System.out.println(Status.ACTIVE.ordinal());
System.out.println(Status.BLOCKED.ordinal());

Output

0
2

name()

Returns the constant name.

Java

Status.ACTIVE.name();

Output

ACTIVE

toString()

Default implementation:

Java

System.out.println(Status.ACTIVE);

Output

ACTIVE

Can be overridden.

#Enum with Fields

Enums can contain instance variables.

Java

public enum PaymentStatus {
    SUCCESS(200),
    FAILED(500),
    PENDING(100);

    private final int code;

    PaymentStatus(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

Usage:

Java

System.out.println(PaymentStatus.SUCCESS.getCode());

Output

#Enum with Methods

Java

public enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST;

    public boolean isNorth() {
        return this == NORTH;
    }
}

Usage:

Java

Direction.NORTH.isNorth();

Output

true

#Enum with Constructors

Enums can have constructors.

Java

enum Size {
    SMALL(30),
    MEDIUM(40),
    LARGE(50);

    private final int value;

    Size(int value) {
        this.value = value;
    }
}

Rules:

The constructor is always private.
You cannot create enum objects using new.

Wrong:

Java

new Size();   // Compilation Error

#Enum with Abstract Methods

Each constant can have different behaviour.

Java

public enum Operation {
    ADD {
        @Override
        public int apply(int a, int b) {
            return a + b;
        }
    },
    SUBTRACT {
        @Override
        public int apply(int a, int b) {
            return a - b;
        }
    };

    public abstract int apply(int a, int b);
}

Usage:

Java

Operation.ADD.apply(10, 20);

Output

#Enum in Switch

Enums work naturally with switch.

Java

switch (status) {
    case ACTIVE:
        System.out.println("User Active");
        break;
    case BLOCKED:
        System.out.println("User Blocked");
        break;
    default:
        System.out.println("Unknown");
}

#EnumSet

A special high-performance Set for enums.

Java

EnumSet<Day> weekends = EnumSet.of(
        Day.SATURDAY,
        Day.SUNDAY
);

Faster than HashSet for enum types.

#EnumMap

A special Map optimized for enum keys.

Java

EnumMap<Status, String> map =
        new EnumMap<>(Status.class);

Advantages:

Faster than HashMap
Less memory
Type-safe

#Enums in Spring Boot

Common examples: OrderStatus, PaymentStatus, UserRole, Gender, TicketStatus, NotificationType.

Entity:

Java

@Enumerated(EnumType.STRING)
private Status status;

#Why Use EnumType.STRING?

Suppose the enum is ACTIVE, INACTIVE, BLOCKED, stored in the database as ordinals 0, 1, 2. Later a new constant is inserted:

Constant	Old ordinal	New ordinal
`ACTIVE`	0	0
`SUSPENDED`	—	1
`INACTIVE`	1	2
`BLOCKED`	2	3

Ordinals change, so old data becomes incorrect. With STRING, values like ACTIVE and BLOCKED remain stable.

#Comparing Enums

Recommended:

Java

if (status == Status.ACTIVE) {
}

Why? Each enum constant is a singleton. Using == is safe and slightly faster than equals().

#Real Project Examples

Enum	Constants
User Role	`ADMIN`, `CUSTOMER`, `MANAGER`, `SUPER_ADMIN`
Order Status	`PLACED`, `CONFIRMED`, `SHIPPED`, `DELIVERED`, `CANCELLED`
Payment	`SUCCESS`, `FAILED`, `PENDING`
Notification Type	`EMAIL`, `SMS`, `PUSH`, `WHATSAPP`

#Interview Questions

Q1What is an Enum?

A special Java type representing a fixed set of constants.

Q2Can an Enum extend another class?

No. It already extends java.lang.Enum.

Q3Can an Enum implement interfaces?

Yes. Enums can implement one or more interfaces.

Q4Can an Enum have constructors?

Yes. Constructors are implicitly private.

Q5Can we create an Enum object using new?

No. Enum instances are created only by the JVM.

Q6Why use == for Enum comparison?

Each enum constant is a singleton, so reference comparison is safe.

Q7Should we store ordinal() values in the database?

No. Use EnumType.STRING.

Q8Can Enums contain methods?

Yes. They can contain fields, methods, constructors, and abstract methods.

Q9What are EnumSet and EnumMap?

Specialized, high-performance collections designed specifically for enum types.

Q10Why are Enums better than String constants?

Compile-time safety
No spelling mistakes
Better readability
Better switch support
Easier maintenance

#Common Mistakes

Comparing enum names using Strings.
Persisting ordinal() values.
Creating constants using integer values instead of enums.
Using equals() when == is sufficient.

#Best Practices

Use enums whenever values are fixed.
Use == for enum comparisons.
Store enums as strings in databases.
Keep business logic inside enums when appropriate.
Use EnumSet and EnumMap for better performance.

#Quick Revision

Enum

Fixed Constants

Singleton Objects

Fields

Methods

Constructors

Switch

EnumSet

EnumMap

#Interview Cheat Sheet

Requirement	Recommendation
Fixed values	Enum
Database storage	`EnumType.STRING`
Comparison	`==`
Collection	`EnumSet`
Map key	`EnumMap`
Convert String	`valueOf()`

#Chapter Summary

After completing this chapter, you should be able to:

Explain what an Enum is and why it is used.
Understand the internal working of enums.
Use enum fields, constructors, and methods.
Work with EnumSet and EnumMap.
Persist enums correctly using EnumType.STRING.
Confidently answer advanced enum interview questions commonly asked in Java and Spring Boot interviews.