The "constant expression required" compiler error in a Java switch statement means the value in your case label is not a compile-time constant, even if it looks constant to you. The fix is to declare the variable as final with a literal initializer, use an enum, or use a literal value directly.

Why Java Requires Compile-Time Constants in Switch Cases

The Java Language Specification requires every case label in a switch statement to be a constant expression. A constant expression is a value the compiler can fully evaluate during compilation, not at runtime. This constraint exists because the compiler builds a jump table or lookup table from the case values, and it can only do that when every value is known before the program runs.

This is the root of the confusion. A variable can appear "constant" to a developer because it never changes at runtime, but the compiler does not perform that kind of analysis. It only recognizes specific syntactic patterns as compile-time constants.

What Qualifies as a Compile-Time Constant

The compiler treats these as constant expressions:

• Literal values: 42, 'A', "hello"
• final local variables initialized with a literal or another constant expression
• static final fields initialized with a literal or constant expression
• Enum constants
• Constant expressions built from other constants using operators (e.g., 1 + 2)

These do NOT qualify:

• Non-final variables, even if never reassigned
• final variables initialized from a method call (e.g., final int x = getValue())
• static fields without final
• Values read from configuration, user input, or any runtime source

The Error in Action

Here is the pattern that triggers the error:

1public class StatusCodes {
2    static int OK = 200;          // not final
3    static int NOT_FOUND = 404;   // not final
4
5    public String describe(int code) {
6        switch (code) {
7            case OK:        // Compilation error: constant expression required
8                return "Success";
9            case NOT_FOUND: // Compilation error: constant expression required
10                return "Not found";
11            default:
12                return "Unknown";
13        }
14    }
15}

The variables OK and NOT_FOUND are static but not final. The compiler cannot guarantee their values will not change before the switch executes, so it rejects them.

Fix 1: Add the final Keyword

The simplest fix is to declare the variables as static final:

1public class StatusCodes {
2    static final int OK = 200;
3    static final int NOT_FOUND = 404;
4
5    public String describe(int code) {
6        switch (code) {
7            case OK:
8                return "Success";
9            case NOT_FOUND:
10                return "Not found";
11            default:
12                return "Unknown";
13        }
14    }
15}

The same rule applies to local variables. A final local variable initialized with a literal is a compile-time constant:

1public void process(int status) {
2    final int TIMEOUT = 408;
3
4    switch (status) {
5        case TIMEOUT:
6            System.out.println("Request timed out");
7            break;
8    }
9}

But a final local variable initialized from a method call is NOT a compile-time constant:

1public void process(int status) {
2    final int timeout = getTimeoutCode(); // runtime value
3
4    switch (status) {
5        case timeout: // Compilation error: constant expression required
6            break;
7    }
8}

Fix 2: Use an Enum

Enums are inherently compile-time constants and are the idiomatic Java solution when you have a fixed set of related values:

1public enum HttpStatus {
2    OK(200),
3    NOT_FOUND(404),
4    INTERNAL_ERROR(500);
5
6    private final int code;
7
8    HttpStatus(int code) {
9        this.code = code;
10    }
11
12    public int getCode() {
13        return code;
14    }
15}
16
17// Usage in a switch
18public String describe(HttpStatus status) {
19    switch (status) {
20        case OK:
21            return "Success";
22        case NOT_FOUND:
23            return "Not found";
24        case INTERNAL_ERROR:
25            return "Server error";
26        default:
27            return "Unknown";
28    }
29}

Note that when switching on an enum, the case labels use the unqualified constant name (OK, not HttpStatus.OK).

Fix 3: Use Literal Values Directly

When you do not want to extract constants, literal values always work:

1switch (code) {
2    case 200:
3        return "Success";
4    case 404:
5        return "Not found";
6    default:
7        return "Unknown";
8}

This sacrifices readability for simplicity. Named constants are almost always preferable.

Comparison of Valid vs. Invalid Case Label Declarations

Switch Expressions in Modern Java (14+)

Java 14 introduced switch expressions with arrow syntax. The same constant expression rules apply to case labels, but the syntax is cleaner:

1static final int OK = 200;
2static final int NOT_FOUND = 404;
3
4String result = switch (code) {
5    case OK -> "Success";
6    case NOT_FOUND -> "Not found";
7    default -> "Unknown";
8};

Switch expressions also support pattern matching (Java 21+), which opens up new possibilities but does not change the constant expression requirement for traditional value-based cases.

Supported Switch Expression Types

Not every type can be used as a switch expression. Here is what Java supports:

Common Pitfalls

Constants from another class without final. Importing a static field from a utility class does not make it a constant. The field must be static final with a constant initializer in the source class.

Interface fields look constant but might not be. Interface fields are implicitly public static final, so they do work as case labels, but only if initialized with a constant expression. If the initializer calls a method, it still fails.

Wrapper types cause confusion. You cannot switch on Integer, Long, or other wrapper types directly (they get unboxed), but the case labels must still be primitive constants. Mixing Integer objects and int cases can introduce subtle NullPointerException risks if the switch expression is null.

Fall-through after a fix. After resolving the constant expression error, do not forget that Java switch statements fall through without break. Missing a break in one case silently executes subsequent cases.

Summary

The "constant expression required" error means the compiler cannot evaluate your case label at compile time. The value must be a literal, a final variable initialized with a literal, or an enum constant. Adding final to the declaration is the most common fix. For type-safe sets of values, prefer enums. In modern Java, switch expressions provide cleaner syntax but follow the same constant rules. Always verify that the initializer itself is a constant expression, because final int x = someMethod() does not qualify.