when is static variable loaded in java, runtime or compile time?

Question

When is static variable loaded, runtime or compile time? Can someone please explain it.

I would really appreciate the help.

Thank you.

Answer 1

The compiler optimizes inlineable static final fields by embedding the value in the bytecode instead of computing the value at runtime.

When you fire up a JVM and load a class for the first time (this is done by the classloader when the class is first referenced in any way) any static blocks or fields are 'loaded' into the JVM and become accessible.

A demonstration:

public class StaticDemo {

 // a static initialization block, executed once when the class is loaded
 static {
  System.out.println("Class StaticDemo loading...");
 }

 // a constant
 static final long ONE_DAY_IN_MILLIS = 24 * 60 * 60 * 1000;

 // a static field
 static int instanceCounter;

 // a second static initialization block
 // static members are processed in the order they appear in the class
 static {
  // we can now acces the static fields initialized above
  System.out.println("ONE_DAY_IN_MILLIS=" + ONE_DAY_IN_MILLIS
    + " instanceCounter=" + instanceCounter);
 }

 // an instance initialization block
 // instance blocks are executed each time a class instance is created,
 // after the parent constructor, but before any own constructors (as remarked by Ahmed Hegazy)
 {
  StaticDemo.instanceCounter++;
  System.out.println("instanceCounter=" + instanceCounter);
 }

 public static void main(String[] args) {
  System.out.println("Starting StaticDemo");
  new StaticDemo();
  new StaticDemo();
  new StaticDemo();
 }

 static {
  System.out.println("Class StaticDemo loaded");
 }

}

Output:

Class StaticDemo loading...
ONE_DAY_IN_MILLIS=86400000 instanceCounter=0
Class StaticDemo loaded
Starting StaticDemo
instanceCounter=1
instanceCounter=2
instanceCounter=3

Notice how 'Starting StaticDemo' does not appear as the first line of output. This is because the class must be loaded before the main method can be executed, which means all static fields and blocks are processed in order.

Answer 2

They are loaded at runtime.

Static means: that the variable belong to the class, and not to instances of the class. So there is only one value of each static variable, and not n values if you have n instances of the class.

Answer 3

run time when class is loaded. - Have a look at initialization

Answer 4

The static fields are loaded when the class is loaded. This usually happens which the file object of a class is created, but it can be earlier if the class is used another way.

The static initialiser is thread safe and you can access the class in multiple threads safely. This is useful as a way to create a thread safe singleton without having to use a lock.

Note: the class can be loaded (and its static intialisation block run) more than once if multiple class loaders are used. Generally, loading the same class in multiple class loaders can be confusing and is avoided, but it is supported and does work.

Answer 5

How would you load a variable at compile time? The variable is initialized when the corresponding class is loaded. See the JVMS.

Answer 6

Loading is a runtime operation. Everything is loaded at runtime.

Answer 7

When you type java ClassName then class loads into JVM with static variables, so you don't need an object for it.

Where as instance variable loaded by JVM when the object is created.

Answer 8

Static fields gets loaded at the time of class loading in JVM.