Java: using switch statement with enum under subclass

java

switch-expressions

enum-visibility

best-practices

byAnton Shumikhin·Jan 24, 2025

To utilize an enum within a switch case inside a subclass, reference it directly from the superclass:

public class Subclass extends Superclass {
    public void useEnum(MyEnum value) {
        switch (value) {
            case VALUE1: /* Logic here is as straightforward as a buttered slide */ break;
            case VALUE2: /* Logic here is deeper than a philosopher's thoughts */ break;
        }
    }
}

Ensure the enum is visible in the subclass context - either through import or qualifying with the superclass name.

Ensuring enum visibility

When dealing with enums in the context of subclasses, ensuring that your enum is accessible is half the battle. Here's what you need to do:

Safeguard your enum is public for access in different packages.
To make your code reek of clean structure, declare enums outside methods. If your enum is the town bicycle (used everywhere), perhaps consider a single separate .java file.

Nailing the syntax for switch

When dealing with switch statements and enums, Java has a very non-negotiable syntax. Always take a resort in unqualified constants. For example:

switch (myEnumValue) {
    case FIRST_OPTION: 
        // Stubborn as a mule? Handle it here.
        break;
    case SECOND_OPTION: 
        // More like a fleeting rabbit? Manage that too.
        break;
    // More? Bring it on.
}

Dealing with imports and nested enums

If your enum is nestled snug or in a different package, ensure you import it correct:

import mypackage.MyLovableEnum;

For nested enums accessed in a subclass, use them direct:

public void useNestedEnum() {
    OuterClass.InnerClass.MyNestedEnum value = /* ... */;
    switch (value) {
        case NESTED_VALUE1: /* Just like your favorite nested dolls */ break;
        case NESTED_VALUE2: /* One inside other, and so forth */ break;
    }
}

Work smarter with switch expressions

Switch expressions introduced in Java 14, aid in simplifying how you handle enum:

String result = switch (myEnumValue) {
    case FIRST_OPTION -> "First"; // Silver medallist.
    case SECOND_OPTION -> "Second"; // Sorry, you're not first.
    default -> "Unknown"; // Shrugs. Who are you?
};

Use yield to return a calculated value from a block of code in a switch expression.

int numericValue = switch (myEnum) {
    case FIRST_OPTION -> 1; // Solo.
    case SECOND_OPTION -> {
        int complexCalculation = /* ... */;
        yield complexCalculation; // You're not alone.
    }
    default -> 0; // Nothingness.
};

Troubleshooting with error messages

Error messages are the breadcrumb trail to rectification. Here are some common errors and their corrections:

On receiving case expressions must be constant expressions, check if you've used qualified enum constants and switch to unqualified names.
If your enum is within scope and still receive cannot find symbol, verify if you forgot to statically import that enum.

Leveraging enums in subclass

Opt for these subclass-specific remedies:

Inner class enums: Reference directly in the switch, no need for prefixing the enclosing class.
Inherited enums: If the subclass is inside the same package, no need of additional import.
Enums in interfaces: Enum defined within interfaces are implicitly public and static, just implement the interface and use the enum directly.