What’s in My Stack?

item-34-use-enums-instead-of-int-constants

5 min read

Enums in Java – Why We Needed Them

1. Introduction

Enums in Java are a special data type that lets you define a fixed set of named constants.
A constant is a variable whose value cannot be changed after it’s defined.

Common real-world examples that fit naturally as enums:

  • Seasons of the year: SPRING, SUMMER, AUTUMN, WINTER
  • The planets in the solar system
  • The suits in a deck of playing cards
  • The days of the week: MONDAY … SUNDAY

Enums make code type-safe, self-documenting, and easier to maintain.

2. Before Enums: The int Constant Pattern

Before Java 5 introduced the enum keyword, developers simulated enums with public static final int constants grouped in a class.

Example: fruits represented as integers

// Example: Types of Fruits (Old int-enum pattern)
public class Fruit {
    public static final int APPLE_FUJI         = 0;
    public static final int APPLE_PIPPIN       = 1;
    public static final int APPLE_GRANNY_SMITH = 2;
 
    public static final int ORANGE_NAVEL       = 0;
    public static final int ORANGE_TEMPLE      = 1;
    public static final int ORANGE_BLOOD       = 2;
}

These constants are just numbers; the compiler sees no difference between apples and oranges.

3. A Method Using the Old Pattern

Consider a method that works with oranges:

public static String getOrangeName(int orange) {
    switch (orange) {
        case ORANGE_NAVEL:  return "Navel Orange";
        case ORANGE_TEMPLE: return "Temple Orange";
        case ORANGE_BLOOD:  return "Blood Orange";
        default:            return "Unknown Orange";
    }
}

The parameter is simply an int.
The compiler cannot tell if the value passed really comes from the orange constants.

4. The Problem: No Type Safety

For example:

String result = getOrangeName(Fruit.APPLE_FUJI);
System.out.println(result);   // Prints "Navel Orange" 😱

Here’s why:

  • APPLE_FUJI has value 0

  • ORANGE_NAVEL also has value 0

  • The compiler only sees an integer, so it accepts it

⚠️ The compiler allows you to pass APPLE_FUJI where an orange is expected.
There is no type safety.

5. Other Problems with the int-enum Pattern

❌ 5.1 No Namespace Separation

All constants share the same integer space.
To avoid clashes, developers add prefixes:

APPLE_FUJI
ORANGE_FUJI

Example:

Fruit.APPLE_FUJI     // 0
Fruit.ORANGE_NAVEL   // also 0

Prefixes prevent clashes but make code long and error-prone.

❌ 5.2 Poor Debuggability

Printing such constants shows only numbers:

System.out.println(Fruit.APPLE_FUJI);  // Prints 0

You must consult the source code or documentation to know what each number means.

❌ 5.3 Fragile and Error-Prone

If the library author changes the order or value of the constants later,
old client code may silently break.

Example:

// v1 of library
public static final int APPLE_FUJI         = 0;
public static final int APPLE_GRANNY_SMITH = 1;

Client code:

int fav = Fruit.APPLE_FUJI;  // compiler substitutes value 0

Later the library is changed:

// v2 of library
public static final int APPLE_GRANNY_SMITH = 0;  // reordered
public static final int APPLE_FUJI         = 1;  // value changed

If the client app is not recompiled, the bytecode still contains the value 0,
but in v2 0 now refers to APPLE_GRANNY_SMITH.

👉 Result: the client’s program changes behaviour silently at runtime.

❌ 5.4 Hard to Evolve

Sometimes the constants don’t follow a simple sequence, e.g.:

SOLO(1), DUET(2), TRIPLE_QUARTET(12)

There’s no natural ordinal formula, so developers end up using fragile expressions like ordinal + 1.

❌ 5.5 No Easy Iteration

If you want to loop over all constants (like all oranges), you must create and maintain your own arrays or lists.
There is no built-in way to iterate through the constant set.

6. Recap of Problems with int-enum Pattern

  • 🚫 No type safety – compiler can’t prevent mixing unrelated groups

  • 🚫 No namespace separation – requires ugly prefixes

  • 🚫 Poor debugging – printing just shows numbers

  • 🚫 Fragile – reordering or renumbering silently breaks old code

  • 🚫 Hard to evolve – can’t easily assign non-sequential values

  • 🚫 No easy way to iterate over all constants

7. Enter Java Enums

Java 5 introduced the enum type to solve all these issues:

  • Each enum is its own type → type-safe

  • Each enum has its own namespace

  • Printing an enum constant shows its name (e.g., FUJI) not a number

  • You can add fields, constructors, and methods to store extra data

  • The set of constants is fixed and known at compile-time

  • You can iterate over them easily with the built-in values() method

  • Reordering enum constants doesn’t break existing client code

Example:

public enum Apple  { FUJI, PIPPIN, GRANNY_SMITH }
public enum Orange { NAVEL, TEMPLE, BLOOD }

Now this is type-safe:

public static String getOrangeName(Orange orange) {
    switch (orange) {
        case NAVEL:  return "Navel Orange";
        case TEMPLE: return "Temple Orange";
        case BLOOD:  return "Blood Orange";
    }
    return "Unknown Orange";
}

Trying to pass an apple:

getOrangeName(Apple.FUJI); // ❌ Compile-time error

The compiler stops us — type safety restored.

there are the various ways of using the enmus such as the

  • Enum Abstract
  • Enum Interfaces
  • Enum overload and the normal Enum

Enum

The syntax of the normal enum is simple it contain the type (public ,default) note enums can’t be private and enum which is identifier and class name

public enum EnumSample {
MONDAY,
TUESDAY,
WEDNESDAY,
THRUSDAY,
FRIDAY,
SATURDAY,
SUNDAY;

}

here the each feild’s are constants and final and static by default and for the each feilds it generate the instance when you call the EnumSample

— Note you can’t initialize the new instace of the enum outside the enum class

by default the enum class generates the ‘Ordinal’ or you can give the ordinal and the method’s in the EnumSample its self

it is immposible to give or instantiate the method out side the EnumSample

Backlinks