How public static final variable works in Java?

How do public static final variable works in Java? what is the difference between a public static final variable and a public final (non-static) variable in Java? Does both are same? It is one of the simple, yet tricky questions which may Interviewers like to ask candidates, and would you believe that almost 50% Java developers miss the key point to mention here, which we'll see in this article. In short, No, they are not same. Even though both are final variables and you cannot change their value once assigned there is a very subtle difference between them. A public static final variable is a compile time constant, but a public final is just a final variable, i.e. you cannot reassign value to it but it's not a compile-time constant.

This may look puzzling, but actual difference allows how compiler treat those two variables. For public static final variables, values are copied at client end at compile time, which means if the value is coming from a third party JAR and is changed in the subsequent release but the client has not compiled again, maybe because they are in different JAR file then the client will continue be using the old value. This is actually one of the mysterious gotchas of Java programming language and creates really hard to find bugs.

Let's say you have a public static final variable to validate the length of username in your application. The variable username is a compile time constant in the AppUtils class, as shown below:

public class AppUtils {

  public static AppUtils _INSTANCE = new AppUtils();
  public static final int USERNAME_LENGTH = 8;
  private AppUtils(){
    // no instance allowed outside this class
  public static AppUtils getInstance(){
    return _INSTANCE;

The AppUtils class is in a separate JAR file, the utils.jar and you created a client which depends upon this value to validate username and password, but the client and this constant are in different JAR files i.e. app.jar and utils.jar

import java.util.Scanner;

public class App {

  public static void main(String args[]) {

    // read username and password and validate length
    // using AppUtil constants
    Scanner cmdReader = new Scanner(;

    System.out.println("Please enter username");
    String username = cmdReader.nextLine();

    if (username.length() > AppUtils.USERNAME_LENGTH) {
      System.out.println("Please enter a shorter username, max characters :"
          + AppUtils.USERNAME_LENGTH);

Now, let's run our program from the command line by including the dependent JAR file into classpath as shown here:

How public static final variable works in Java?

You can see that program is behaving as expected. Later we change the value of the final variable to 20 and replace the library JAR, the utils.jar in our case, with a new version, but we forgot to compile our client application i.e. the App class, which validates the length of username and password. Now, let's see what happens:

public static final variable example in Java

Oops, it's still using the same old value and complaining about username is greater than the length of 8, even though we have increased the length to 20 and put a new JAR file. Since value is inlined even after updating the dependent JAR file it's not reflected in your program because we have not compiled the class again.

In order to solve this problem, I compiled the App.jar again against the new version of utils.jar and then ran the program again, you can see in the last line that it didn't complain now because it's using updated value, which allows username up to 20 characters. This issue can be really tricky to find out sometime. The Java Puzzlers from Joshua Bloch also has some puzzles to educate Java developers about this point. You may want to check that as well.

public static final variable works in Java

Important points

In short, here are some key differences between a public static final variable and normal final variables in Java:

1) The public static final variable is usually a compile time constant if value is known to compiler at compile time e.g.
public static final int USERNAME_LENGTH = 8;
but it may not be a compile time constant if you use expressions as shown below:
public static final int USERNAME_LENGTH = getConstant();
in this case, USERNAME_LENGTH is not a compile time constant.

2) If a public static final variable is a compile time constant then it's value is also inlined at the client end, hence it can remove runtime dependency on a third party library at the bytecode level.

3) Because of above reason, it's also advised to compile your project every time you update the third party libraries in your project. If the value of a compile time constant is updated in third party JAR it won't be reflected in your project until you compile it again because values are copied at compile time. You can read Java Puzzlers to learn more about that.

4) When you create JAR file from Eclipse, make sure you include the name of the main class for creating executable JAR files, otherwise, you won't be able to run them from the command prompt. In our example, the utils.jar was a library without any main class but app.jar was an executable JAR file, contains Main-Class attribute in the manifest file, that's why we could run it using java -jar option. See here to learn more about how to create an executable JAR file using Eclipse.

That's all about the difference between public static final and public final variable in Java. Remember, former is a compile time constant and their value is inlined at compile time at the client end, which means, if the value is changed you need to compile all clients explicitly to pick the new value, otherwise they will keep using old value. This is one reason, Why you should compile your whole project when you upgrade to newer version of a library. Contrary to that, public final variables are not inlined.

No comments :

Post a Comment