Custom Enum

About

A Custom Enum is an enum that we define yourself in a project to fit our own specific needs. We can add fields, methods, and constructors to an enum to expand its capabilities, making it powerful and functional beyond just a list of constants.

Adding Fields and Methods to a Custom Enum

Custom enums can contain instance variables, constructors, and methods, enabling them to store and manipulate additional data.

Example of a Custom Enum with Fields and Methods

public enum ProductType {
    PREPAID_CARD("prepaid-card", "A prepaid card"),
    CREDIT_CARD("credit-card", "A credit card"),
    DEBIT_CARD("debit-card", "A debit card");

    private String code;
    private String description;

    ProductType(String code, String description) {
        this.code = code;
        this.description = description;
    }

    public String getCode() {
        return code;
    }

    public String getDescription() {
        return description;
    }

    public static ProductType fromCode(String code) {
        for (ProductType type : ProductType.values()) {
            if (type.code.equals(code)) {
                return type;
            }
        }
        throw new IllegalArgumentException("Unknown code: " + code);
    }
}

Usage of Custom Enum

In this example, ProductType stores a code and description for each constant

ProductType type = ProductType.fromCode("prepaid-card");
System.out.println(type.getDescription()); // Output: A prepaid card

Examples

Payment Confirmation Status

PaymentConfirmationStatus.java

package sample.enums;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

/**
 * The status of the confirmation.
 */
public enum PaymentConfirmationStatus {

    CONFIRMED("CONFIRMED"),

    PENDING("PENDING"),

    USER_DECLINED("USER DECLINED"),

    SYSTEM_DECLINED("SYSTEM DECLINED"),

    ERROR("ERROR");

    private String value;

    PaymentConfirmationStatus(String value) {
        this.value = value;
    }

    @JsonValue
    public String getValue() {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }

    @JsonCreator
    public static PaymentConfirmationStatus fromValue(String value) {
        for (PaymentConfirmationStatus b : PaymentConfirmationStatus.values()) {
            if (b.value.equals(value)) {
                return b;
            }
        }
        throw new IllegalArgumentException("Unexpected value '" + value + "'");
    }
}

Add below dependency for jackson annotation
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.16.1</version>
</dependency>

Validation Enum

ValidationResult.java

package sample.enums;

import lombok.Getter;
import lombok.RequiredArgsConstructor;
import sample.model.ValidationResponse;

@Getter
@RequiredArgsConstructor
public enum ValidationResult {


    PASSED(Result.PASSED, "Provided value(s) are unique", "000"),
    REJECTED_NAME(Result.REJECTED, "The name is already used. Please use another", "001"),
    REJECTED_ID(Result.REJECTED, "Enter a valid ID number", "002");

    private final Result result;
    private final String message;
    private final String key;

    public ValidationResponse toHttpResponse() {
        return new ValidationResponse().result(result.name()).message(message).key(key);
    }

    public enum Result {
        PASSED, REJECTED
    }
}

Version Type

VersionType.java

package sample.enums;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

public enum VersionType {
  
    _1_0_0("1.0.0"),
    _2_0_0("2.0.0");

    private String value;

    VersionType(String value) {
        this.value = value;
    }

    @JsonValue
    public String getValue() {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }

    @JsonCreator
    public static VersionType fromValue(String value) {
        for (VersionType b : VersionType.values()) {
            if (b.value.equals(value)) {
                return b;
            }
        }
        throw new IllegalArgumentException("Unexpected value '" + value + "'");
    }
}

Yes or No Flag

YesNoFlagType.java

package sample.enums;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

/**
 * Flag indicating if a specific option is enabled or disabled with possible supported values. 
 */
public enum YesNoFlagType {
  
    Y("Y"),
    
    N("N");
  
    private String value;
  
    YesNoFlagType(String value) {
        this.value = value;
    }
  
    @JsonValue
    public String getValue() {
        return value;
    }
  
    @Override
    public String toString() {
        return String.valueOf(value);
    }
  
    @JsonCreator
    public static YesNoFlagType fromValue(String value) {
        for (YesNoFlagType b : YesNoFlagType.values()) {
            if (b.value.equals(value)) {
                return b;
            }
        }
        throw new IllegalArgumentException("Unexpected value '" + value + "'");
    }
}

Multi-stage order processing system

OrderState Enum: The OrderState enum defines multiple states for an order, such as RECEIVED, PROCESSING, SHIPPED, DELIVERED, and COMPLETED. Each enum constant has a stage number (int stage), which allows us to track the order's progress. Every state has a behavior defined in the handleOrder method. This method is abstract in the enum and is overridden in each state to handle the order’s transition logic. OrderState is a polymorphic enum. The method handleOrder is defined for each state, allowing us to change the order's state and behavior dynamically. The enum constants (RECEIVED, PROCESSING, etc.) override the abstract method to define their specific behavior. validTransitions is an EnumMap used to store valid transitions between states. For instance, an order can only go from RECEIVED to PROCESSING, from PROCESSING to SHIPPED, etc. The isTransitionValid static method checks if a state transition is allowed based on the current and next states.

OrderState.java

package sample;

import java.util.EnumMap;
import java.util.EnumSet;

public enum OrderState {
    RECEIVED(1) {
        @Override
        public void handleOrder(Order order) {
            System.out.println("Order " + order.getId() + " received.");
            order.setState(PROCESSING);
        }
    },
    PROCESSING(2) {
        @Override
        public void handleOrder(Order order) {
            System.out.println("Processing order " + order.getId() + "...");
            // Simulate some process time
            order.setState(SHIPPED);
        }
    },
    SHIPPED(3) {
        @Override
        public void handleOrder(Order order) {
            System.out.println("Order " + order.getId() + " shipped.");
            order.setState(DELIVERED);
        }
    },
    DELIVERED(4) {
        @Override
        public void handleOrder(Order order) {
            System.out.println("Order " + order.getId() + " delivered.");
            order.setState(COMPLETED);
        }
    },
    COMPLETED(5) {
        @Override
        public void handleOrder(Order order) {
            System.out.println("Order " + order.getId() + " completed.");
        }
    };

    private final int stage;

    // Constructor to initialize the enum with an additional field
    OrderState(int stage) {
        this.stage = stage;
    }

    public int getStage() {
        return stage;
    }

    // Abstract method that each state must implement
    public abstract void handleOrder(Order order);

    // Transition map to allow direct state transitions (for advanced use cases)
    private static final EnumMap<OrderState, EnumSet<OrderState>> validTransitions = new EnumMap<>(
        OrderState.class);

    static {
        validTransitions.put(RECEIVED, EnumSet.of(PROCESSING));
        validTransitions.put(PROCESSING, EnumSet.of(SHIPPED));
        validTransitions.put(SHIPPED, EnumSet.of(DELIVERED));
        validTransitions.put(DELIVERED, EnumSet.of(COMPLETED));
        validTransitions.put(COMPLETED, EnumSet.noneOf(OrderState.class));
    }

    public static boolean isTransitionValid(OrderState fromState, OrderState toState) {
        return validTransitions.get(fromState).contains(toState);
    }
}

Order Class: The Order class holds an OrderState and provides a method (setState) to change the state. The setState method ensures that only valid state transitions are allowed using isTransitionValid. If a transition is invalid (e.g., trying to go backward in the state machine), it prints a message and does not update the state.

Order.java

package sample;

import lombok.Getter;

@Getter
public class Order {
    private final String id;
    private OrderState state;

    public Order(String id) {
        this.id = id;
        this.state = OrderState.RECEIVED; // Initially in 'RECEIVED' state
    }

    public void setState(OrderState state) {
        if (OrderState.isTransitionValid(this.state, state)) {
            this.state = state;
            this.state.handleOrder(this);
        } else {
            System.out.println("Invalid state transition: " + this.state + " -> " + state);
        }
    }
}

OrderProcessingSystem.java

package sample;

public class OrderProcessingSystem {

    public static void main(String[] args) {
        // Create an order with ID 12345
        Order order = new Order("12345");

        // Print the current state of the order
        System.out.println("Initial Order State: " + order.getState());

        // Simulate state transitions using the handleOrder logic
        order.setState(OrderState.PROCESSING);  // Should transition to PROCESSING
        order.setState(OrderState.SHIPPED);     // Should transition to SHIPPED
        order.setState(OrderState.DELIVERED);   // Should transition to DELIVERED
        order.setState(OrderState.COMPLETED);   // Should transition to COMPLETED

        // Try invalid transition (e.g., from DELIVERED to PROCESSING)
        order.setState(OrderState.PROCESSING);  // Invalid transition from DELIVERED to PROCESSING
    }
}