How to use enum in Java switch statement

Introduction

This tutorial explores the powerful combination of enums and switch statements in Java, providing developers with practical techniques to enhance code structure and maintainability. By understanding how to leverage enums within switch cases, programmers can create more robust and type-safe code that improves overall software design and readability.

Skills Graph

Enum Basics in Java

What is an Enum?

In Java, an enum (enumeration) is a special type of class used to define a collection of constants. Enums provide a way to create a group of related constants with more functionality than traditional static final variables.

Defining an Enum

Here's a basic example of an enum in Java:

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

Enum Characteristics

Enums in Java have several important characteristics:

Creating Enums with Additional Properties

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters

    // Constructor
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    // Method to calculate surface gravity
    public double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }
}

Enum Methods and Behaviors

Enums come with built-in methods:

DaysOfWeek day = DaysOfWeek.MONDAY;
System.out.println(day.name());           // Prints "MONDAY"
System.out.println(day.ordinal());         // Prints 0 (index in enum)
System.out.println(day.toString());        // Prints "MONDAY"

Enum in Switch Statements

Enums work perfectly with switch statements:

DaysOfWeek day = DaysOfWeek.WEDNESDAY;
switch (day) {
    case MONDAY:
        System.out.println("Start of the work week");
        break;
    case WEDNESDAY:
        System.out.println("Middle of the work week");
        break;
    case FRIDAY:
        System.out.println("End of the work week");
        break;
    default:
        System.out.println("Weekend");
}

Enum Iteration

You can easily iterate through enum constants:

for (DaysOfWeek day : DaysOfWeek.values()) {
    System.out.println(day);
}

Why Use Enums?

• Provide type safety
• Improve code readability
• Represent a fixed set of constants
• Allow for more complex constant definitions

At LabEx, we recommend using enums to create more robust and meaningful code structures in Java applications.

Enum with Switch Cases

Introduction to Enum Switch Statements

Switch statements with enums provide a clean and type-safe way to handle different enum constants. They offer more readable and concise code compared to traditional if-else structures.

Basic Enum Switch Example

public enum TrafficLight {
    RED, YELLOW, GREEN
}

public class TrafficController {
    public static void handleTrafficLight(TrafficLight light) {
        switch (light) {
            case RED:
                System.out.println("Stop");
                break;
            case YELLOW:
                System.out.println("Prepare to stop");
                break;
            case GREEN:
                System.out.println("Go");
                break;
        }
    }
}

Switch Expression (Java 12+)

public static String getTrafficInstruction(TrafficLight light) {
    return switch (light) {
        case RED -> "Absolutely stop";
        case YELLOW -> "Slow down";
        case GREEN -> "Proceed safely";
    };
}

Enum Switch Flow Visualization

Handling Multiple Cases

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

public static void printDayType(Day day) {
    switch (day) {
        case SATURDAY:
        case SUNDAY:
            System.out.println("Weekend");
            break;
        default:
            System.out.println("Weekday");
    }
}

Enum Switch Patterns

Advanced Enum Switch Techniques

enum PaymentMethod {
    CREDIT_CARD, DEBIT_CARD, PAYPAL, CASH
}

public static double applyDiscount(PaymentMethod method, double amount) {
    return switch (method) {
        case CREDIT_CARD, DEBIT_CARD -> amount * 0.95;
        case PAYPAL -> amount * 0.97;
        case CASH -> amount;
    };
}

Common Pitfalls to Avoid

• Always include a default case or handle all enum constants
• Be aware of exhaustive checking in switch expressions
• Use break statements in traditional switch statements

Best Practices

• Use enums with switch for finite, known set of constants
• Prefer switch expressions in Java 12+ for more concise code
• Ensure type safety and readability

At LabEx, we recommend mastering enum switch patterns to write more elegant and maintainable Java code.

Practical Enum Patterns

Enum State Machine Pattern

public enum OrderStatus {
    PENDING {
        @Override
        public void nextStatus(Order order) {
            order.setStatus(PROCESSING);
        }
    },
    PROCESSING {
        @Override
        public void nextStatus(Order order) {
            order.setStatus(SHIPPED);
        }
    },
    SHIPPED {
        @Override
        public void nextStatus(Order order) {
            order.setStatus(DELIVERED);
        }
    },
    DELIVERED {
        @Override
        public void nextStatus(Order order) {
            // Final state
        }
    };

    public abstract void nextStatus(Order order);
}

Enum Singleton Pattern

public enum DatabaseConnection {
    INSTANCE;
    
    private Connection connection;
    
    private DatabaseConnection() {
        // Initialize database connection
        connection = createConnection();
    }
    
    public Connection getConnection() {
        return connection;
    }
    
    private Connection createConnection() {
        // Actual connection logic
        return null;
    }
}

Enum Strategy Pattern

public enum PaymentStrategy {
    CREDIT_CARD {
        @Override
        public void pay(double amount) {
            System.out.println("Paying " + amount + " with Credit Card");
        }
    },
    PAYPAL {
        @Override
        public void pay(double amount) {
            System.out.println("Paying " + amount + " with PayPal");
        }
    },
    BANK_TRANSFER {
        @Override
        public void pay(double amount) {
            System.out.println("Paying " + amount + " via Bank Transfer");
        }
    };

    public abstract void pay(double amount);
}

Enum Validation Pattern

public enum ValidationRule {
    EMAIL {
        @Override
        public boolean validate(String input) {
            return input.matches("^[A-Za-z0-9+_.-]+@(.+)$");
        }
    },
    PHONE_NUMBER {
        @Override
        public boolean validate(String input) {
            return input.matches("^\\d{10}$");
        }
    },
    PASSWORD {
        @Override
        public boolean validate(String input) {
            return input.length() >= 8;
        }
    };

    public abstract boolean validate(String input);
}

Enum Configuration Pattern

public enum AppConfiguration {
    INSTANCE;
    
    private Map<String, String> configMap = new HashMap<>();
    
    public void setConfig(String key, String value) {
        configMap.put(key, value);
    }
    
    public String getConfig(String key) {
        return configMap.get(key);
    }
    
    public String getConfig(String key, String defaultValue) {
        return configMap.getOrDefault(key, defaultValue);
    }
}

Enum Patterns Comparison

Enum Flow Visualization

Best Practices

• Use enums for a fixed set of related constants
• Leverage enum methods for complex behaviors
• Prefer enum patterns over traditional implementation
• Keep enum implementations focused and simple

At LabEx, we recommend exploring these practical enum patterns to write more robust and maintainable Java code.

Summary

Java's enum and switch statement integration offers developers a sophisticated approach to handling multiple states and conditions with improved type safety and code clarity. By mastering these techniques, programmers can write more expressive, maintainable, and efficient code that leverages Java's strong type system and provides cleaner alternatives to traditional conditional logic.