https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

Return to Effective Java, Java Best Practices, Java Style Guides, Java

In Java, enums are a powerful feature that allows you to define a fixed set of constants. Each enum constant has an associated ordinal, which is its position in the enum declaration. While ordinals can be useful in certain cases, it's generally a best practice to avoid relying on ordinals for logic or data storage. Instead, use instance fields in your enums to represent additional data or behavior. This approach leads to more readable, maintainable, and flexible code.

Each enum constant has an associated ordinal value, which is the position of the constant in the enum declaration, starting from zero. While ordinals can be useful for simple comparisons or iteration, relying on them for business logic, data storage, or communication between systems can lead to brittle code. The primary issue is that ordinals are inherently tied to the order of constants in the enum declaration, meaning that any changes to the order can break the code.

Using ordinals can introduce several risks: 1. **Fragility**: The code becomes fragile because changing the order of enum constants can cause unexpected behavior or break existing functionality. 2. **Lack of Expressiveness**: Ordinals do not convey any meaningful information about the constants, making the code harder to read and understand. 3. **Incompatibility with Persistence**: Storing ordinals in databases or using them in serialized objects can lead to compatibility issues if the enum is modified in the future.

Consider an example where ordinals are used to represent a priority level:

```java public enum Priority {

   LOW,
   MEDIUM,
   HIGH

public class Task {

   private Priority priority;

   public Task(Priority priority) {
       this.priority = priority;
   }

   public int getPriorityValue() {
       return priority.ordinal(); // Using ordinals (not recommended)
   }

In this example, the `getPriorityValue` method returns the ordinal of the priority enum. If the order of the constants in the `Priority` enum is changed (e.g., `HIGH` is moved before `MEDIUM`), the ordinal values will change, potentially breaking the logic that relies on these values.

A better approach is to use instance fields in the enum to represent additional data or behavior. This approach makes the code more robust and expressive and avoids the pitfalls associated with ordinals. By using instance fields, you can associate meaningful data with each enum constant, making the code easier to understand and maintain.

Here’s how the previous example can be refactored to use instance fields instead of ordinals:

```java public enum Priority {

   LOW(1),
   MEDIUM(2),
   HIGH(3);

   private final int priorityValue;

   Priority(int priorityValue) {
       this.priorityValue = priorityValue;
   }

   public int getPriorityValue() {
       return priorityValue; // Using instance fields (recommended)
   }

public class Task {

   private Priority priority;

   public Task(Priority priority) {
       this.priority = priority;
   }

   public int getPriorityValue() {
       return priority.getPriorityValue();
   }

In this refactored example, each `Priority` enum constant has an associated `priorityValue` field that is explicitly defined in the constructor. This approach is more robust because the priority values are independent of the order of the enum constants, making the code more maintainable.

Using instance fields instead of ordinals offers several benefits: 1. **Expressiveness**: Instance fields allow you to assign meaningful values or data to enum constants, making the code more readable and understandable. 2. **Immutability**: Instance fields in enums are typically `final`, meaning they cannot be changed once assigned. This immutability leads to safer and more predictable code. 3. **Flexibility**: Instance fields provide the flexibility to associate additional behavior or data with each enum constant, such as methods for processing the data.

Here’s an example of an enum that uses instance fields to add behavior:

```java public enum Operation {

   ADDITION("+") {
       public double apply(double x, double y) {
           return x + y;
       }
   },
   SUBTRACTION("-") {
       public double apply(double x, double y) {
           return x - y;
       }
   },
   MULTIPLICATION("*") {
       public double apply(double x, double y) {
           return x * y;
       }
   },
   DIVISION("/") {
       public double apply(double x, double y) {
           return x / y;
       }
   };

   private final String symbol;

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

   public String getSymbol() {
       return symbol;
   }

   public abstract double apply(double x, double y);

In this example, the `Operation` enum represents arithmetic operations. Each constant has an associated symbol and a method that implements the operation. The instance fields and methods make the enum both expressive and flexible, allowing it to encapsulate both data and behavior.

When storing enum values in a database or using them in serialized objects, always store the name or a specific field (such as an ID) rather than the ordinal. This approach ensures that the data remains consistent and compatible even if the enum is modified in the future.

Here’s an example of how to safely store an enum in a database:

```java public enum Status {

   ACTIVE("A"),
   INACTIVE("I"),
   DELETED("D");

   private final String code;

   Status(String code) {
       this.code = code;
   }

   public String getCode() {
       return code;
   }

In this example, the `Status` enum uses a `code` field to represent the status in the database. Instead of storing the ordinal, the `code` value is stored, ensuring that the data remains consistent even if the order of the enum constants changes.

In conclusion, using instance fields instead of ordinals in Java is a best practice that leads to more expressive, flexible, and maintainable code. Ordinals are tied to the order of enum constants and can introduce fragility into your code, especially when used in persistence or business logic. By using instance fields, you can associate meaningful data and behavior with each enum constant, resulting in more robust and reliable software.

For more information on using enums and avoiding ordinals in Java, consider exploring the following resources:

• https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
• https://en.wikipedia.org/wiki/Enumerated_type
• https://github.com/iluwatar/java-design-patterns/tree/master/enum

These resources provide additional insights and best practices for using enums effectively in Java.

Fair Use Sources:

• Use instance fields instead of ordinals
• Java Best Practices and Core Guidelines
• Effective Java on DuckDuckGo - B078H61SCH (EffJav 2017)
• The Borg

• Effective Java for Archive Access for Fair Use Preservation, quoting, paraphrasing, excerpting and/or commenting upon