XQA
Back to Java
2026-01-317 min read

Java Enum

Learn Java Enum step by step with clear examples and exercises.

Why This Matters

Java Enums are a powerful feature that offers several advantages in Java programming:

  1. Type Safety: Enums ensure that only valid values can be assigned to an enum variable, preventing runtime errors caused by incorrect data types.
  2. Immutability: Enum constants are implicitly final and cannot be reassigned, ensuring the integrity of your data.
  3. Readability: By organizing related constants into a single class, enums make your code more readable and easier to maintain.
  4. Interview Ready: Understanding enums is essential for Java interviews as they are frequently used in real-world applications.
  5. Named Constants: Enums provide a way to create named constants that can be easily referenced throughout your code, improving its readability and maintainability.
  6. Implicit Interface Implementation: Every enum implicitly implements the java.lang.Enum interface, which provides several useful methods such as values(), valueOf(), and ordinal().
  7. Enum Sets: Enums can be used to create thread-safe, ordered collections of unique elements with constant time performance for basic operations like add, remove, and contains.

Prerequisites

To fully grasp the concept of Java Enums, you should have a good understanding of:

  1. Basic Java syntax (variables, methods, classes)
  2. Object-Oriented Programming concepts (inheritance, polymorphism)
  3. Interfaces in Java
  4. Exception handling in Java
  5. Understanding of the java.lang.Enum interface and its methods

Core Concept

An Enum in Java is essentially a special type of class that represents a set of named constants. To create an enum, you define a class and use the enum keyword instead of class. Here's an example:

public enum Days {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

In the above example, we have created an enum called Days, which contains seven constant values representing the days of the week. Each constant is a unique instance of the Days enum class and has an implicitly private access modifier, final keyword, and static modifier.

Enums can also have methods and constructors, just like regular classes:

public enum Operation {
ADD("+"), SUB("-"), MUL("*"), DIV("/");

private String symbol;

Operation(String symbol) {
this.symbol = symbol;
}

public String getSymbol() {
return symbol;
}
}

In the above example, we have created an enum called Operation, which contains four constant values representing arithmetic operations. Each constant has a constructor that takes a string parameter and initializes it with a specific symbol. We also added a method called getSymbol() to retrieve the operation's symbol.

Worked Example

Let's create a simple program using enums to represent different shapes, calculate their areas, and print them:

public enum Shape {
CIRCLE("Circle", 2), RECTANGLE("Rectangle", 4);

private final String name;
private final int dimensions;

Shape(String name, int dimensions) {
this.name = name;
this.dimensions = dimensions;
}

public double calculateArea(double radius, double length, double width) {
if (this == CIRCLE) {
return Math.PI * Math.pow(radius, 2);
} else if (this == RECTANGLE) {
return length * width;
}
throw new IllegalArgumentException("Invalid shape");
}

@Override
public String toString() {
return name;
}

// Add a method to get the number of dimensions for each shape
public int getDimensions() {
return dimensions;
}
}

In the above example, we have added a getDimensions() method to our enum Shape, which returns the number of dimensions required for each shape. This allows us to create more complex shapes with different numbers of dimensions in the future.

Now let's modify the Main class to use this improved Shape enum:

public class Main {
public static void main(String[] args) {
double circleArea = Shape.CIRCLE.calculateArea(5);
double rectangleArea = Shape.RECTANGLE.calculateArea(4, 6);

System.out.println("Circle area: " + circleArea);
System.out.println("Rectangle area: " + rectangleArea);

// Print the number of dimensions for each shape
System.out.println("Number of dimensions for Circle: " + Shape.CIRCLE.getDimensions());
System.out.println("Number of dimensions for Rectangle: " + Shape.RECTANGLE.getDimensions());
}
}

In the Main class, we have added code to print the number of dimensions for each shape using the new getDimensions() method in our Shape enum. This demonstrates how enums can be extended and modified to better suit your needs.

Common Mistakes

  1. Forgetting to make an enum final: Since enums are implicitly final, you should not explicitly declare them as such.
  2. Trying to instantiate an enum using the new keyword: Enums cannot be instantiated using the new keyword because each constant is a unique instance of the enum class.
  3. Not defining constants for all enum values: If you define an enum without providing values for all its constants, you will get a compile-time error.
  4. Forgetting to provide a constructor for enums with more than one constant: When you have multiple constants in your enum and do not provide a constructor, Java automatically generates a no-argument constructor for each constant. However, if you want to initialize the constants with specific values, you should provide a constructor explicitly.
  5. Forgetting to implement Enum's methods: Enums implicitly implement the java.lang.Enum interface, which provides several useful methods such as values(), valueOf(), and ordinal(). It is essential to understand these methods and how they can be used in your code.
  6. Using enums as method arguments: While it's possible to use enums as method arguments, it's generally better to use primitive data types or interfaces when defining method parameters for improved performance and type safety.
  7. Not considering EnumSet: When working with collections of enum constants, consider using EnumSet for thread-safe, ordered collections with constant time performance for basic operations like add, remove, and contains.
  8. Ignoring the benefits of named constants: Enums provide a way to create named constants that can be easily referenced throughout your code, improving its readability and maintainability. Don't overlook this advantage when designing your classes and methods.

Practice Questions

  1. Create an enum called Color with constants representing primary colors (RED, BLUE, YELLOW) and a method that returns the complementary color for each primary color.
public enum Color {
RED("Complementary color: Cyan"),
BLUE("Complementary color: Orange"),
YELLOW("Complementary color: Purple");

private String complementaryColor;

Color(String complementaryColor) {
this.complementaryColor = complementaryColor;
}

public String getComplementaryColor() {
return complementaryColor;
}
}
  1. Write a program that uses enums to represent different coin denominations (PENNY, NICKEL, DIME, QUARTER) and calculates the total value of a given collection of coins.
public enum Coin {
PENNY(0.01), NICKEL(0.05), DIME(0.10), QUARTER(0.25);

private final double value;

Coin(double value) {
this.value = value;
}

public double getValue() {
return value;
}
}

public class Main {
public static void main(String[] args) {
Coin[] coins = {Coin.PENNY, Coin.NICKEL, Coin.DIME, Coin.QUARTER};
double totalValue = 0;

for (Coin coin : coins) {
totalValue += coin.getValue();
}

System.out.println("Total value: " + totalValue);
}
}
  1. Create an enum called Fruit with constants representing common fruits (APPLE, BANANA, ORANGE) and a method that determines whether a fruit is citrus or not based on its name.
public enum Fruit {
APPLE("Not Citrus"), BANANA("Not Citrus"), ORANGE("Citrus");

private final String isCitrus;

Fruit(String isCitrus) {
this.isCitrus = isCitrus;
}

public boolean isCitrus() {
return "Citrus".equals(isCitrus);
}
}

FAQ

  1. Can I extend one enum from another enum? No, enums cannot be extended like regular classes in Java. However, you can achieve similar functionality using interfaces or composition.
  2. How do I create an enum with a custom method that takes arguments? You can define a constructor for your enum constants and pass the required arguments to it. Then, you can call the constructor from within the custom method.
  3. Can I use enums as keys in a HashMap? Yes, enums are implicitly final and can be used as keys in a HashMap. However, it's essential to ensure that the hashCode() and equals() methods for your enum class are properly implemented for correct behavior.
  4. What happens if I try to add a new constant to an existing enum? If you attempt to add a new constant to an existing enum without modifying the source code, you will get a compile-time error because the enum constants are implicitly final and cannot be reassigned.
  5. How can I iterate through all enum constants at runtime? You can use the values() method provided by the java.lang.Enum interface to get an array of all enum constants for a given enum class, then iterate through that array.
  6. What is the purpose of the ordinal() method in enums? The ordinal() method returns the index of the current enum constant within its enum declaration order. This can be useful when working with enums that need to maintain a specific order or when using switch statements with enum constants.
  7. How do I create an enum with private constructors? To create an enum with private constructors, make the constructor(s) private and provide a public factory method (or static factory methods) to create instances of the enum class. This ensures that only authorized code can create new enum instances while still allowing for flexible construction.
  8. How do I ensure my enum constants are thread-safe when using them in concurrent environments? To make your enum constants thread-safe, consider using EnumSet or implementing the java.util.concurrent.Serializable interface if your enum needs to be shared between threads or serialized. Additionally, ensure that any methods that modify the state of an enum instance are synchronized to prevent race conditions.
Java Enum | Java | XQA Learn