Enums

Enums (enumerations) are a way to define a set of named constants. They provide type safety and make code more readable by using meaningful names instead of magic numbers or strings.

What are Enums?

An enum is a special type that represents a fixed set of constants. Instead of using arbitrary numbers or strings, enums allow you to use meaningful names.

Why Use Enums?

• Type Safety - Prevents invalid values
• Readability - Code is self-documenting
• Maintainability - Easy to update values in one place
• IDE Support - Better autocomplete and refactoring

Python Enums

Python provides the Enum class from the enum module:

Python

basic_enum.py

from enum import Enum

class Status(Enum):
    """Simple enum for status values"""
    PENDING = "pending"
    ACTIVE = "active"
    INACTIVE = "inactive"
    DELETED = "deleted"

# Usage
user_status = Status.ACTIVE
print(user_status)           # Status.ACTIVE
print(user_status.value)     # "active"
print(user_status.name)      # "ACTIVE"

# Compare enum values
if user_status == Status.ACTIVE:
    print("User is active")

Output

Status.ACTIVE
active
ACTIVE
User is active

Java

BasicEnum.java

public enum Status {
    PENDING("pending"),
    ACTIVE("active"),
    INACTIVE("inactive"),
    DELETED("deleted");

    private final String value;

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

    public String getValue() {
        return value;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Status userStatus = Status.ACTIVE;
        System.out.println(userStatus);              // ACTIVE
        System.out.println(userStatus.getValue());   // "active"
        System.out.println(userStatus.name());       // "ACTIVE"

        // Compare enum values
        if (userStatus == Status.ACTIVE) {
            System.out.println("User is active");
        }
    }
}

Output

ACTIVE
active
ACTIVE
User is active

Enum with Integer Values

Enums can use integer values:

Python

int_enum.py

from enum import IntEnum

class Priority(IntEnum):
    """Enum with integer values"""
    LOW = 1
    MEDIUM = 2
    HIGH = 3
    CRITICAL = 4

# Can compare with integers
priority = Priority.HIGH
print(priority)           # Priority.HIGH
print(priority.value)     # 3
print(priority < Priority.CRITICAL)  # True
print(priority == 3)      # True (IntEnum allows this)

Output

Priority.HIGH
3
True
True

Java

IntEnum.java

public enum Priority {
    LOW(1),
    MEDIUM(2),
    HIGH(3),
    CRITICAL(4);

    private final int value;

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

    public int getValue() {
        return value;
    }

    // Compare with integers
    public boolean isHigherThan(Priority other) {
        return this.value > other.value;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Priority priority = Priority.HIGH;
        System.out.println(priority);                    // HIGH
        System.out.println(priority.getValue());        // 3
        System.out.println(priority.isHigherThan(Priority.MEDIUM));  // True
    }
}

Output

HIGH
3
True

Enum with Methods

Enums can have methods and properties:

Python

enum_with_methods.py

from enum import Enum

class Color(Enum):
    """Enum with methods"""
    RED = (255, 0, 0)
    GREEN = (0, 255, 0)
    BLUE = (0, 0, 255)
    YELLOW = (255, 255, 0)

    def __init__(self, r, g, b):
        self.r = r
        self.g = g
        self.b = b

    def rgb(self):
        """Return RGB tuple"""
        return (self.r, self.g, self.b)

    def hex(self):
        """Return hex color code"""
        return f"#{self.r:02x}{self.g:02x}{self.b:02x}"

    def is_dark(self):
        """Check if color is dark"""
        return (self.r + self.g + self.b) < 400

# Usage
color = Color.RED
print(color.rgb())      # (255, 0, 0)
print(color.hex())      # #ff0000
print(color.is_dark())  # False

Output

(255, 0, 0)
#ff0000
False

Java

EnumWithMethods.java

public enum Color {
    RED(255, 0, 0),
    GREEN(0, 255, 0),
    BLUE(0, 0, 255),
    YELLOW(255, 255, 0);

    private final int r;
    private final int g;
    private final int b;

    Color(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    // Return RGB array
    public int[] rgb() {
        return new int[]{r, g, b};
    }

    // Return hex color code
    public String hex() {
        return String.format("#%02x%02x%02x", r, g, b);
    }

    // Check if color is dark
    public boolean isDark() {
        return (r + g + b) < 400;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Color color = Color.RED;
        System.out.println(java.util.Arrays.toString(color.rgb()));  // [255, 0, 0]
        System.out.println(color.hex());      // #ff0000
        System.out.println(color.isDark());   // false
    }
}

Output

[255, 0, 0]
#ff0000
false

Real-World Example: Order Status

Python

order_status_enum.py

from enum import Enum, auto

class OrderStatus(Enum):
    """Order status enum"""
    PENDING = auto()
    CONFIRMED = auto()
    PROCESSING = auto()
    SHIPPED = auto()
    DELIVERED = auto()
    CANCELLED = auto()

    def can_cancel(self):
        """Check if order can be cancelled"""
        return self in [OrderStatus.PENDING, OrderStatus.CONFIRMED]

    def is_completed(self):
        """Check if order is completed"""
        return self == OrderStatus.DELIVERED

    def next_status(self):
        """Get next status in workflow"""
        status_flow = {
            OrderStatus.PENDING: OrderStatus.CONFIRMED,
            OrderStatus.CONFIRMED: OrderStatus.PROCESSING,
            OrderStatus.PROCESSING: OrderStatus.SHIPPED,
            OrderStatus.SHIPPED: OrderStatus.DELIVERED,
        }
        return status_flow.get(self)

class Order:
    def __init__(self, order_id: str):
        self.order_id = order_id
        self.status = OrderStatus.PENDING

    def advance_status(self):
        """Move to next status"""
        next_status = self.status.next_status()
        if next_status:
            self.status = next_status
            return f"Order {self.order_id} moved to {self.status.name}"
        return f"Order {self.order_id} cannot advance from {self.status.name}"

    def cancel(self):
        """Cancel order if possible"""
        if self.status.can_cancel():
            self.status = OrderStatus.CANCELLED
            return f"Order {self.order_id} cancelled"
        return f"Order {self.order_id} cannot be cancelled from {self.status.name}"

# Usage
order = Order("ORD-001")
print(order.status)              # OrderStatus.PENDING
print(order.advance_status())     # Order ORD-001 moved to CONFIRMED
print(order.status)               # OrderStatus.CONFIRMED
print(order.cancel())             # Order ORD-001 cancelled

Output

OrderStatus.PENDING
Order ORD-001 moved to CONFIRMED
OrderStatus.CONFIRMED
Order ORD-001 cancelled

Java

OrderStatusEnum.java

public enum OrderStatus {
    PENDING,
    CONFIRMED,
    PROCESSING,
    SHIPPED,
    DELIVERED,
    CANCELLED;

    public boolean canCancel() {
        return this == PENDING || this == CONFIRMED;
    }

    public boolean isCompleted() {
        return this == DELIVERED;
    }

    public OrderStatus nextStatus() {
        switch (this) {
            case PENDING: return CONFIRMED;
            case CONFIRMED: return PROCESSING;
            case PROCESSING: return SHIPPED;
            case SHIPPED: return DELIVERED;
            default: return null;
        }
    }
}

public class Order {
    private String orderId;
    private OrderStatus status;

    public Order(String orderId) {
        this.orderId = orderId;
        this.status = OrderStatus.PENDING;
    }

    public OrderStatus getStatus() {
        return status;
    }

    public String advanceStatus() {
        OrderStatus nextStatus = this.status.nextStatus();
        if (nextStatus != null) {
            this.status = nextStatus;
            return String.format("Order %s moved to %s", orderId, status.name());
        }
        return String.format("Order %s cannot advance from %s", orderId, status.name());
    }

    public String cancel() {
        if (this.status.canCancel()) {
            this.status = OrderStatus.CANCELLED;
            return String.format("Order %s cancelled", orderId);
        }
        return String.format("Order %s cannot be cancelled from %s", orderId, status.name());
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Order order = new Order("ORD-001");
        System.out.println(order.getStatus());        // PENDING
        System.out.println(order.advanceStatus());    // Order ORD-001 moved to CONFIRMED
        System.out.println(order.getStatus());        // CONFIRMED
        System.out.println(order.cancel());           // Order ORD-001 cancelled
    }
}

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

Enum Iteration

You can iterate over all enum values:

Python

enum_iteration.py

from enum import Enum

class Day(Enum):
    MONDAY = 1
    TUESDAY = 2
    WEDNESDAY = 3
    THURSDAY = 4
    FRIDAY = 5
    SATURDAY = 6
    SUNDAY = 7

# Iterate over all enum values
for day in Day:
    print(f"{day.name}: {day.value}")

# Check if value exists
print(Day.MONDAY in Day)  # True
print(Day(1) == Day.MONDAY)  # True

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
True
True

Java

EnumIteration.java

public enum Day {
    MONDAY(1),
    TUESDAY(2),
    WEDNESDAY(3),
    THURSDAY(4),
    FRIDAY(5),
    SATURDAY(6),
    SUNDAY(7);

    private final int value;

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

    public int getValue() {
        return value;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        // Iterate over all enum values
        for (Day day : Day.values()) {
            System.out.println(day.name() + ": " + day.getValue());
        }

        // Check if value exists
        System.out.println(Day.MONDAY == Day.valueOf("MONDAY"));  // true
    }
}

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
true

Visual Representation

Key Takeaways

Remember

• Enums provide type-safe named constants
• Python: Use Enum or IntEnum from the enum module
• Java: Use enum keyword (special class type)
• Enums can have methods and properties
• Enums improve readability and maintainability
• Use enums instead of magic numbers or strings
• Enums can be iterated over all values
• Enums provide type safety - prevents invalid values

When to Use Enums

Use enums when:

• You have a fixed set of related constants
• You want type safety (prevent invalid values)
• You need self-documenting code
• Values won’t change frequently
• You want better IDE support

Examples:

• Status values (PENDING, ACTIVE, INACTIVE)
• Days of the week
• Colors
• Priority levels
• Error codes
• Configuration options