Enums in Java are more powerful than in many other languages. They can have constructors, methods, fields, and even implement interfaces.

Basic Enum Syntax

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

Enum with Constructor, Fields and Methods

Simple Example

public enum Planet {
// Enum constants with constructor arguments
MERCURY(3.303e+23, 2.4397e6),
VENUS(4.869e+24, 6.0518e6),
EARTH(5.976e+24, 6.37814e6),
MARS(6.421e+23, 3.3972e6),
JUPITER(1.9e+27, 7.1492e7),
SATURN(5.688e+26, 6.0268e7),
URANUS(8.686e+25, 2.5559e7),
NEPTUNE(1.024e+26, 2.4746e7);
// Fields
private final double mass;   // in kilograms
private final double radius; // in meters
// Constructor (always private by default)
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
// Methods
public double getMass() {
return mass;
}
public double getRadius() {
return radius;
}
public double getSurfaceGravity() {
final double G = 6.67300E-11; // gravitational constant
return G * mass / (radius * radius);
}
public double getSurfaceWeight(double otherMass) {
return otherMass * getSurfaceGravity();
}
}

Usage Example

public class PlanetTest {
public static void main(String[] args) {
double earthWeight = 175; // in pounds
double mass = earthWeight / Planet.EARTH.getSurfaceGravity();
for (Planet p : Planet.values()) {
System.out.printf("Your weight on %s is %f%n",
p, p.getSurfaceWeight(mass));
}
}
}

Advanced Enum Features

Enum with Multiple Fields and Custom Methods

public enum Operation {
PLUS("+") {
public double apply(double x, double y) { return x + y; }
},
MINUS("-") {
public double apply(double x, double y) { return x - y; }
},
TIMES("*") {
public double apply(double x, double y) { return x * y; }
},
DIVIDE("/") {
public double apply(double x, double y) { return x / y; }
};
private final String symbol;
// Constructor
Operation(String symbol) {
this.symbol = symbol;
}
// Abstract method - each constant must implement
public abstract double apply(double x, double y);
// Regular method
public String getSymbol() {
return symbol;
}
// Static utility method
public static Operation fromSymbol(String symbol) {
for (Operation op : values()) {
if (op.symbol.equals(symbol)) {
return op;
}
}
throw new IllegalArgumentException("Unknown operator: " + symbol);
}
}

Usage

public class Calculator {
public static void main(String[] args) {
double x = 10, y = 5;
for (Operation op : Operation.values()) {
System.out.printf("%f %s %f = %f%n", 
x, op.getSymbol(), y, op.apply(x, y));
}
// Using the static method
Operation plus = Operation.fromSymbol("+");
System.out.println("5 + 3 = " + plus.apply(5, 3));
}
}

Enum with State and Behavior

Complex Example with Multiple Constructors

public enum HttpStatus {
// Success responses
OK(200, "OK"),
CREATED(201, "Created"),
ACCEPTED(202, "Accepted"),
// Client error responses
BAD_REQUEST(400, "Bad Request"),
UNAUTHORIZED(401, "Unauthorized"),
FORBIDDEN(403, "Forbidden"),
NOT_FOUND(404, "Not Found"),
// Server error responses  
INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
NOT_IMPLEMENTED(501, "Not Implemented"),
BAD_GATEWAY(502, "Bad Gateway");
private final int code;
private final String description;
private final Category category;
// Regular constructor
HttpStatus(int code, String description) {
this.code = code;
this.description = description;
this.category = determineCategory(code);
}
// Private helper method
private Category determineCategory(int code) {
if (code >= 200 && code < 300) return Category.SUCCESS;
if (code >= 400 && code < 500) return Category.CLIENT_ERROR;
if (code >= 500 && code < 600) return Category.SERVER_ERROR;
return Category.UNKNOWN;
}
// Methods
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
public Category getCategory() {
return category;
}
public boolean isSuccess() {
return category == Category.SUCCESS;
}
public boolean isError() {
return category == Category.CLIENT_ERROR || category == Category.SERVER_ERROR;
}
// Static lookup method
public static HttpStatus fromCode(int code) {
for (HttpStatus status : values()) {
if (status.code == code) {
return status;
}
}
throw new IllegalArgumentException("Unknown HTTP status code: " + code);
}
// Nested enum
public enum Category {
SUCCESS, CLIENT_ERROR, SERVER_ERROR, UNKNOWN
}
@Override
public String toString() {
return code + " " + description;
}
}

Usage

public class HttpStatusTest {
public static void main(String[] args) {
HttpStatus status = HttpStatus.NOT_FOUND;
System.out.println("Code: " + status.getCode());
System.out.println("Description: " + status.getDescription());
System.out.println("Category: " + status.getCategory());
System.out.println("Is error: " + status.isError());
System.out.println("Is success: " + status.isSuccess());
System.out.println("ToString: " + status);
// Lookup by code
HttpStatus found = HttpStatus.fromCode(200);
System.out.println("Found: " + found);
}
}

Enum Implementing Interface

// Interface
public interface Cacheable {
String getCacheKey();
boolean isCacheable();
}
// Enum implementing interface
public enum UserRole implements Cacheable {
ADMIN("admin", 1, true),
MODERATOR("moderator", 2, true),
USER("user", 3, true),
GUEST("guest", 4, false);
private final String roleName;
private final int level;
private final boolean cacheable;
UserRole(String roleName, int level, boolean cacheable) {
this.roleName = roleName;
this.level = level;
this.cacheable = cacheable;
}
// Interface method implementations
@Override
public String getCacheKey() {
return "ROLE_" + name();
}
@Override
public boolean isCacheable() {
return cacheable;
}
// Additional methods
public String getRoleName() {
return roleName;
}
public int getLevel() {
return level;
}
public boolean hasPermission(String permission) {
// Logic to check permissions based on role level
return this.level <= getRequiredLevel(permission);
}
private int getRequiredLevel(String permission) {
// Permission level mapping logic
return switch (permission) {
case "DELETE" -> 1;
case "EDIT" -> 2;
case "VIEW" -> 3;
default -> 4;
};
}
}

Enum with Singleton Pattern

public enum DatabaseConnection {
INSTANCE;
private Connection connection;
DatabaseConnection() {
// Initialize connection
initializeConnection();
}
private void initializeConnection() {
try {
// Simulate connection creation
System.out.println("Creating database connection...");
// this.connection = DriverManager.getConnection(url);
} catch (Exception e) {
throw new RuntimeException("Failed to create database connection", e);
}
}
public Connection getConnection() {
return connection;
}
public void executeQuery(String query) {
System.out.println("Executing: " + query);
// Actual query execution logic
}
public void close() {
try {
if (connection != null && !connection.isClosed()) {
connection.close();
}
} catch (SQLException e) {
System.err.println("Error closing connection: " + e.getMessage());
}
}
}

Singleton Usage

public class SingletonDemo {
public static void main(String[] args) {
// Get the singleton instance
DatabaseConnection db = DatabaseConnection.INSTANCE;
db.executeQuery("SELECT * FROM users");
// All calls to INSTANCE return the same instance
DatabaseConnection sameInstance = DatabaseConnection.INSTANCE;
System.out.println("Same instance? " + (db == sameInstance)); // true
}
}

Best Practices

1. Use descriptive names for enum constants
2. Keep enum constructors private (they already are by default)
3. Make enum fields final when possible for immutability
4. Override toString() for better readability
5. Use enum for fixed set of constants that won't change frequently
6. Consider using enums instead of boolean parameters for better readability

// BAD - boolean parameters are confusing
public void setVisible(boolean visible, boolean modal)
// GOOD - enum parameters are clear
public void setVisible(Visibility visible, Modality modal)
public enum Visibility { VISIBLE, HIDDEN }
public enum Modality { MODAL, MODELESS }

Key Benefits

• Type safety - Compiler prevents invalid values
• Rich functionality - Can have methods, fields, and implement interfaces
• Singleton support - Natural implementation of singleton pattern
• Serialization safety - Built-in serialization support
• Switch statement compatibility - Can be used in switch statements

Enums with constructors and methods provide a powerful way to represent fixed sets of related constants with associated behavior and data.