How to Use a Constant in Java

A constant is a variable whose value cannot change once it has been assigned. Java doesn't have built-in support for constants, but the variable modifiers static and final can be used to effectively create one.

Constants can make your program more easily read and understood by others. In addition, a constant is cached by the JVM as well as your application, so using a constant can improve performance. 

Static Modifier

This allows a variable to be used without first creating an instance of the class; a static class member is associated with the class itself, rather than an object. All class instances share the same copy of the variable.

This means that another application or main() can easily use it.

For example, class myClass contains a static variable days_in_week:

public class myClass {
   static int days_in_week = 7;
}

Because this variable is static, it can be used elsewhere without explicitly creating a myClass object:

public class myOtherClass {  
   static void main(String[] args) {
       System.out.println(myClass.days_in_week);
   }
 }

Final Modifier

The final modifier means that the variable's value cannot change. Once the value is assigned, it cannot be reassigned. 

Primitive data types (i.e., int, short, long, byte, char, float, double, boolean) can be made immutable/unchangeable using the final modifier.

Together, these modifiers create a constant variable.

static final int DAYS_IN_WEEK = 7;

Note that we declared DAYS_IN_WEEK in all caps once we added the final modifier. It's a long-standing practice among Java programmers to define constant variables in all caps, as well as to separate words with underscores.

Java doesn't require this formatting but it makes it easier for anyone reading the code to immediately identify a constant. 

Potential Problems With Constant Variables

The way the final keyword works in Java is that the variable's pointer to the value cannot change. Let's repeat that: it's the pointer that cannot change the location to which it's pointing.

There's no guarantee that the object being referenced will stay the same, only that the variable will always hold a reference to the same object. If the referenced object is mutable (i.e. has fields that can be changed), then the constant variable may contain a value other than what was originally assigned.