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.