Basic Enum Switch Syntax

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } public class EnumSwitchExample { public static void main(String[] args) { Day today = Day.WEDNESDAY; switch(today) { case MONDAY: System.out.println("Start of work week"); break; case TUESDAY: case WEDNESDAY: case THURSDAY: System.out.println("Mid week days"); break; case FRIDAY: System.out.println("Almost weekend!"); break; case SATURDAY: case SUNDAY: System.out.println("Weekend!"); break; } } }

Enhanced Enum with Methods and Fields

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; Operation(String symbol) { this.symbol = symbol; } public String getSymbol() { return symbol; } public abstract double apply(double x, double y); } public class Calculator { public static double calculate(Operation op, double x, double y) { switch(op) { case PLUS: return x + y; case MINUS: return x - y; case TIMES: return x * y; case DIVIDE: if (y == 0) throw new ArithmeticException("Division by zero"); return x / y; default: throw new IllegalArgumentException("Unknown operation: " + op); } } }

Switch Expressions with Enums (Java 14+)

enum Status { PENDING, PROCESSING, COMPLETED, FAILED } public class StatusHandler { public static String getStatusMessage(Status status) { return switch(status) { case PENDING -> "Please wait..."; case PROCESSING -> "Working on your request"; case COMPLETED -> "Operation successful!"; case FAILED -> "Something went wrong"; // No default needed when all cases are covered }; } public static void handleStatus(Status status) { switch(status) { case PENDING -> System.out.println("Sending notification"); case PROCESSING -> { System.out.println("Starting processing"); System.out.println("Monitoring progress"); } case COMPLETED -> System.out.println("Cleaning up resources"); case FAILED -> System.out.println("Initiating retry mechanism"); } } }

Best Practices and Important Notes

1. Always Include Default Case (When Appropriate)

public static void processPriority(Priority priority) { switch(priority) { case LOW: // handle low priority break; case MEDIUM: // handle medium priority break; case HIGH: // handle high priority break; default: throw new IllegalArgumentException("Unexpected priority: " + priority); } }

2. Using Enum Methods Instead of Switch

Sometimes, using polymorphism is better than switch statements:

enum NotificationType { EMAIL { @Override public void send(String message) { System.out.println("Sending email: " + message); } }, SMS { @Override public void send(String message) { System.out.println("Sending SMS: " + message); } }, PUSH { @Override public void send(String message) { System.out.println("Sending push notification: " + message); } }; public abstract void send(String message); } // No switch needed! NotificationType.EMAIL.send("Hello World");

3. Complete Example with Error Handling

enum FileType { TEXT, PDF, IMAGE, AUDIO, VIDEO, UNKNOWN } public class FileProcessor { public static void processFile(FileType fileType, String fileName) { String result = switch(fileType) { case TEXT -> processTextFile(fileName); case PDF -> processPdfFile(fileName); case IMAGE -> processImageFile(fileName); case AUDIO -> processAudioFile(fileName); case VIDEO -> processVideoFile(fileName); case UNKNOWN -> { System.out.println("Unknown file type, attempting generic processing"); yield processGenericFile(fileName); } }; System.out.println("Processing result: " + result); } private static String processTextFile(String fileName) { return "Text file processed: " + fileName; } private static String processPdfFile(String fileName) { return "PDF file processed: " + fileName; } // ... other processing methods }

Key Advantages of Using Enums in Switch

1. Type Safety - Compiler ensures you only use valid enum values
2. Compile-time Checking - Missing cases can be caught at compile time
3. Better Readability - Enum names are self-documenting
4. Refactoring Friendly - Easy to add new enum values

Common Pitfalls to Avoid

// ❌ Wrong - don't use enum name as string switch(day) { case "MONDAY": // Compilation error break; } // ✅ Correct - use enum constants directly switch(day) { case MONDAY: break; } // ❌ Don't forget break statements (in traditional switch) switch(day) { case MONDAY: System.out.println("Monday"); // missing break - falls through to Tuesday! case TUESDAY: System.out.println("Tuesday"); break; } // ✅ Use switch expressions to avoid fall-through String message = switch(day) { case MONDAY -> "Monday"; case TUESDAY -> "Tuesday"; // no fall-through possible };

Enums in switch statements provide a clean, type-safe way to handle multiple cases and make your code more maintainable and readable.