What are Compile-time Constants in Java?

1. Overview

The Java language specification does not define or even use the term compile-time constants. However, developers often use this term for describing a value that is not changed after compilation.

In this tutorial, we'll explore the differences between a class constant and a compile-time constant. We'll look at constant expressions and see which data types and operators may be used for defining compile-time constants. Finally, we'll look at a few examples where compile-time constants are commonly used.

2. Class Constants

When we use the term constant in Java, most of we the time, we are referring to static and final class variables. We cannot change the value of a class constant after compilation. Thus, all class constants of a primitive type or String are also compile-time constants:

public static final int MAXIMUM_NUMBER_OF_USERS = 10;
public static final String DEFAULT_USERNAME = "unknown";

It's possible to create constants that are not static. However, Java will allocate memory for that constant in every object of the class. Therefore, if the constant really has only one value, it should be declared static.

Oracle has defined a naming convention for class constants. We name them uppercase with words separated by underscores. However, not all static and final variables are constants. If a state of an object can change, it is not a constant:

public static final Logger log = LoggerFactory.getLogger(ClassConstants.class);
public static final List<String> contributorGroups = Arrays.asList("contributor", "author");

Though these are constant references, they refer to mutable objects.

3. Constant Expressions

The Java compiler is able to calculate expressions that contain constant variables and certain operators during code compilation:

public static final int MAXIMUM_NUMBER_OF_GUESTS = MAXIMUM_NUMBER_OF_USERS * 10;
public String errorMessage = ClassConstants.DEFAULT_USERNAME + " not allowed here.";

Expressions like these are called constant expressions, as the compiler will calculate them and produce a single compile-time constant. As defined in the Java language specification, the following operators and expressions may be used for constant expressions:

• Unary operators: +, -, ~, !
• Multiplicative operators: *, /, %
• Additive operators: +, –
• Shift operators: <<, >>,  >>>
• Relational operators: <, <=, >, >=
• Equality operators: ==, !=
• Bitwise and logical operators: &, ^, |
• Conditional-and and the conditional-or operator: &&, ||
• Ternary conditional operator: ?:
• Parenthesized expressions whose contained expression is a constant expression
• Simple names that refer to constant variables

4. Compile vs. Runtime Constants

A variable is a compile-time constant if its value is computed at compile-time. On the other hand, a runtime constant value will be computed during execution.

4.1. Compile-Time Constants

A Java variable is a compile-time constant if it's of a primitive type or String, declared final, initialized within its declaration, and with a constant expression.

Strings are a special case on top of the primitive types because they are immutable and live in a String pool. Therefore, all classes running in an application can share String values.

The term compile-time constants include class constants, but also instance and local variables defined using constant expressions:

public final int maximumLoginAttempts = 5;
public static void main(String[] args) {
    PrintWriter printWriter = System.console().writer();
    printWriter.println(ClassConstants.DEFAULT_USERNAME);
    CompileTimeVariables instance = new CompileTimeVariables();
    printWriter.println(instance.maximumLoginAttempts);
    final String username = "baeldung" + "-" + "user";
    printWriter.println(username);
}

Only the first printed variable is a class constant. However, all three printed variables are compile-time constants.

4.2. Run-Time Constants

A runtime constant value cannot change while the program is running. However, each time when we run the application, it can have a different value:

public static void main(String[] args) {
    Console console = System.console();
    final String input = console.readLine();
    console.writer().println(input);
    final double random = Math.random();
    console.writer().println("Number: " + random);
}

Two run-time constants are printed in our example, a user-defined value and a randomly generated value.

5. Static Code Optimization

The Java compiler statically optimizes all compile-time constants during the compilation process. Therefore, the compiler replaces all compile-time constant references with their actual values. The compiler performs this optimization for any classes where compile-time constants are used.

Let's take a look at an example where a constant from another class is referenced:

PrintWriter printWriter = System.console().writer();
printWriter.write(ClassConstants.DEFAULT_USERNAME);

Next, we'll compile the class and observe the generated bytecode for the above two lines for code:

LINENUMBER 11 L1
ALOAD 1
LDC "unknown"
INVOKEVIRTUAL java/io/PrintWriter.write (Ljava/lang/String;)V

Note that the compiler replaced the variable reference with its actual value. Consequently, in order to change a compile-time constant, we need to recompile all classes which are using it. Otherwise, the old value would continue to be used.

6. Use Cases

Let's take a look at two common use cases for compile-time constants in Java.

6.1. Switch Statement

When defining the cases for a switch statement, we need to adhere to the rules defined in the Java language specification:

• The case labels of the switch statement require values that are either constant expressions or enum constants
• No two of the case constant expressions associated with a switch statement may have the same value

The reason behind this is that the compiler compiles switch statements into bytecode tableswitch or lookupswitch. They require the values used in the case statement to be both compile-time constants and unique:

private static final String VALUE_ONE = "value-one"
public static void main(String[] args) {
    final String valueTwo = "value" + "-" + "two";
    switch (args[0]) {
        case VALUE_ONE:
            break;
        case valueTwo:
            break;
        }
}

The compiler will throw an error if we do not use constant values in our switch statement. However, it will accept a final String or any other compile-time constant.

6.2. Annotations

Annotation processing in Java takes place at compile time. In effect, that means that annotation parameters can only be defined using compile-time constants:

private final String deprecatedDate = "20-02-14";
private final String deprecatedTime = "22:00";
@Deprecated(since = deprecatedDate + " " + deprecatedTime)
public void deprecatedMethod() {}

Though it's more common to use class constants in this situation, the compiler allows this implements, as it recognizes the values as immutable constants.

7. Conclusion

In this article, we explored the term compile-time constants in Java. We saw that the term includes class, instance, and local variables of a primitive type or String, declared final, initialized within its declaration, and defined with a constant expression.

In the examples, we saw the difference between compile-time and run-time constants. We also saw that the compiler uses compile-time constants to perform static code optimization.

Finally, we looked at the usage of compile-time constants in switch statements and Java annotations.

As always, the source code is available over on GitHub.