Dealing with Unexpected Enum Values in JDK 12 Switch Expressions

In this post, we'll discuss how to handle unexpected enum values in JDK 12 Switch Expressions in Java. Switch expressions have been enhanced in JDK 12 to support the use of enums, making them more powerful and concise. However, one challenge that may arise when using switch expressions with enums is how to handle unexpected enum values.

Understanding Switch Expressions in JDK 12

With the introduction of JDK 12, switch expressions were enhanced to provide a more concise syntax and improved functionality. The traditional switch statement, which only supported primitive types and strings, was extended to include support for enums, making code more readable and maintainable.

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

// A switch expression handling the Day enum
String getDayType(Day day) {
    return switch (day) {
        case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
        case SATURDAY, SUNDAY -> "Weekend";
    };
}

In the above example, the switch expression handles the Day enum and returns the type of day (weekday or weekend) based on the input enum value.

Handling Unexpected Enum Values

While switch expressions provide a cleaner and more readable way to handle enum values, one potential issue is how to handle unexpected enum values that are not explicitly handled in the switch cases. In traditional switch statements, a default case can be used to handle such unexpected values. However, in switch expressions, the use of default is not allowed.

To address this challenge, the introduction of "sealed" and "non-sealed" classes in JDK 15 provides a way to restrict the subclasses of an enum, enabling exhaustive checks in switch expressions. By using sealed classes, we can ensure that all possible enum values are explicitly handled in the switch cases, leaving no room for unexpected enum values.

Sealed Classes in JDK 15

Sealed classes and interfaces were introduced as a preview feature in JDK 15, and they provide a way to restrict the subclasses of a class or interface. A sealed class or interface can specify which classes are permitted to extend or implement it, allowing for a more controlled and predictable class hierarchy.

To use sealed classes with enums, we can create a sealed interface and make the enum implement this interface. By specifying the permitted subclasses in the sealed interface, we ensure that all possible enum values are explicitly handled, making switch expressions more robust and reliable.

public sealed interface Day permits Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday { }

public non-sealed enum Monday implements Day { /*...*/ }
public non-sealed enum Tuesday implements Day { /*...*/ }
//... other enum values

// A switch expression handling the sealed Day interface
String getDayType(Day day) {
    return switch (day) {
        case Monday, Tuesday, Wednesday, Thursday, Friday -> "Weekday";
        case Saturday, Sunday -> "Weekend";
    };
}

In the above example, the Day interface is declared as sealed, specifying the permitted enum values. This ensures that all enum values must explicitly handle switch cases, providing a more comprehensive handling of enum values.

Exhaustive Checks with Sealed Classes

By using sealed classes in combination with switch expressions, we can achieve exhaustive checks, meaning that all possible enum values are explicitly handled in the switch cases. This eliminates the need for a default case to handle unexpected enum values, as the compiler can enforce that all possible enum values are handled.

String getDayType(Day day) {
    return switch (day) {
        case Monday, Tuesday, Wednesday, Thursday, Friday -> "Weekday";
        case Saturday, Sunday -> "Weekend";
    };
    // Error: 'switch' expression does not cover all possible enum values
}

In the above example, if all possible enum values are not explicitly handled, the compiler will produce an error, ensuring that no enum value is left unhandled.

The Closing Argument

In this post, we've explored how to handle unexpected enum values in JDK 12 switch expressions by leveraging sealed classes introduced in JDK 15. By using sealed classes, we can ensure exhaustive checks in switch expressions, making our code more robust and predictable.

Switch expressions with sealed classes provide a more reliable way to handle enum values, eliminating the need for default cases and reducing the risk of unexpected behavior. This approach enhances the readability and maintainability of our code, making it a valuable feature for handling enum values in Java.

To learn more about sealed classes and their usage with enums, refer to the Java Language Specification.

In conclusion, by embracing sealed classes and switch expressions, Java developers can handle unexpected enum values more effectively, leading to more robust and maintainable code.

Now it's your turn to try out sealed classes and switch expressions to handle enum values in your Java projects. Happy coding!