CODEWITHSUNDEEP
javastaticcompilationfinal
Without Me It Just Aweso
Without Me It Just Aweso

Reputation: 4873

Java static final values replaced in code when compiling?

In java, say I have the following

==fileA.java==
class A
{  
    public static final int SIZE = 100;
}

Then in another file I use this value

==fileB.java==  
import A;
class b
{
      Object[] temp = new Object[A.SIZE];
}

When this gets compiled does SIZE get replaced with the value 100, so that if I were to replace the FileA.jar but not FileB.jar, would the object array get the new value or would it have been hardcoded to 100 because that's the value when it was originally built?

Upvotes: 19

Views: 14258

Answers (10)

amandeep1991
amandeep1991

Reputation: 1394

There is an exception to this:-

If static final field is null at the time of compiling then it doesn't get replaced with null (which is actually its value)

A.java

class A{
     public static final String constantString = null;
}

B.java

class B{
     public static void main(String... aa){
         System.out.println(A.constantString);
     }
}

Compile both A.java and B.java and run java B

Output will be null

Now Update A.java with following code and compile only this class.

class A{
     public static final String constantString = "Omg! picking updated value without re-compilation";
}

Now run java B

Output will be Omg! picking updated value without re-compilation

Upvotes: 0

Jay Zhou
Jay Zhou

Reputation: 1

One thing should note is: static final value is known at compile time if the value is not known at compile time, compiler won't replaces the constant name everywhere in the code with its value.

  public class TestA {
      // public static final int value = 200;
      public static final int value = getValue();
      public static int getValue() {
        return 100;
      }
  }

public class TestB {
    public static void main(String[] args) {
        System.out.println(TestA.value);
    }
}

first compile TestA and TestB, run TestB

then change TestA.getValue() to return 200, compile TestA, run TestB, TestB will get the new value enter image description here

Upvotes: 0

MeBigFatGuy
MeBigFatGuy

Reputation: 28568

You can keep the constant from being compiled into B, by doing

class A
{  
    public static final int SIZE;

    static 
    {
        SIZE = 100;
    }
}

Upvotes: 8

Tom Hawtin - tackline
Tom Hawtin - tackline

Reputation: 147164

The important concept here is that the static final field is initialised with a compile-time constant, as defined in the JLS. Use a non-constant initialiser (or non-static or non-final) and it wont be copied:

public static final int SIZE = null!=null?0: 100;

(null is not a *compile-time constant`.)

Upvotes: 3

James Kingsbery
James Kingsbery

Reputation: 7486

Another route to proving that the behavior is to looking at the generated bytecode. When the constant is "small" (presumably < 128):

public B();
  Code:
   0:   aload_0
   1:   invokespecial   #10; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   bipush  42
   7:   anewarray       #3; //class java/lang/Object
   10:  putfield        #12; //Field temp:[Ljava/lang/Object;
   13:  return

}

(I used 42 instead of 100 so it stands out more). In this case, it is clearly substituted in the byte code. But, say the constant is "bigger." Then you get byte code that looks like this:

public B();
  Code:
   0:   aload_0
   1:   invokespecial   #10; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   ldc     #12; //int 86753098
   7:   anewarray       #3; //class java/lang/Object
   10:  putfield        #13; //Field temp:[Ljava/lang/Object;
   13:  return

When it is bigger, the opcode "ldc" is used, which according to the JVM documentation "an unsigned byte that must be a valid index into the runtime constant pool of the current class".

In either case, the constant is embedded into B. I imagine, since that in opcodes you can only access the current classes runtime constant pool, that this the decision to write the constant into the class file is independent of implementation (but I don't know that for a fact).

Upvotes: 5

mmccomb
mmccomb

Reputation: 13807

Woo - you learn something new everyday!

Taken from the Java spec...

Note: If a primitive type or a string is defined as a constant and the value is known at compile time, the compiler replaces the constant name everywhere in the code with its value. This is called a compile-time constant. If the value of the constant in the outside world changes (for example, if it is legislated that pi actually should be 3.975), you will need to recompile any classes that use this constant to get the current value.

Upvotes: 4

Robby Pond
Robby Pond

Reputation: 73484

As an optimization the compiler will inline that final variable.

So at compile time it will look like.

class b
{
      Object[] temp = new Object[100];
}

Upvotes: 1

Bill K
Bill K

Reputation: 62769

Actually I ran into this bizarreness a while ago.

This will compile "100" into class b directly. If you just recompile class A, this will not update the value in class B.

On top of that, the compiler may not notice to recompile class b (at the time I was compiling single directories and class B was in a separate directory and compiling a's directory did not trigger a compile of B)

Upvotes: 2

satinyou
satinyou

Reputation: 11

Java does optimise these sorts of values but only if they are in the same class. In this case the JVM looks in A.SIZE rather than optimizing it because of the usage case you are considering.

Upvotes: -2

Jesper
Jesper

Reputation: 206836

Yes, the Java compiler does replace static constant values like SIZE in your example with their literal values.

So, if you would later change SIZE in class A but you don't recompile class b, you will still see the old value in class b. You can easily test this out:

file A.java

public class A {
    public static final int VALUE = 200;
}

file B.java

public class B {
    public static void main(String[] args) {
        System.out.println(A.VALUE);
    }
}

Compile A.java and B.java. Now run: java B

Change the value in A.java. Recompile A.java, but not B.java. Run again, and you'll see the old value being printed.

Upvotes: 32

Related Questions