Static variables

[Sunil Kumar Jakkaraju]

Please look at following code

   
 
 
public class SizeClass {
    public static final SizeClass INSTANCE = new SizeClass(10);
    private final int size;
    //private static final int MAX_SIZE = 1000;
    private static final int MAX_SIZE = getMaxSize();
 
    private static int getMaxSize()
    {
      return 1000;
    }
 
    private SizeClass(int size) {
        this.size = MAX_SIZE - 10;
    }
 
    public int getSize() {
        return size;
    }
 
    public static void main(String[] args) {
        System.out.println("Size is " + INSTANCE.getSize());
    } 
}
 
 

I expected output to be .

Size is 990

But the output is .

Size is -10

If you uncomment

private static final int MAX_SIZE = 1000;

and comment

private static final int MAX_SIZE = getMaxSize();

I get the output as

Size is 990

One more observation, If

private static final int MAX_SIZE = getMaxSize(); 

statement is the first statement then also the output is

Size is 990

What is the reason for this behavior?
[ November 09, 2006: Message edited by: Sunil Kumar Jakkaraju ]

[Henry Wong]

There are actually a couple things going on. First, the easy one...

Static variables are initialized from top to bottom (the order they are defined in the class) when the class is loaded. As you have figured out, order matters.

Second, there are also some obscure optimizations going on. If the compiler can determine the variable to be a compile time constant, I am actually not sure what happens, but they seem to be initialized immediately -- probably because they are optimized out.

The reason the MAX_SIZE = 1000 works as you expected, even though it is after the object init, is because of this optimization. If you remove the "final" modifier, or make the expression more complex, it will not work as you expected.

If someone knows the part of the specification that states this, I would appreciate it, as this has always been fuzzy for me.


[EDIT: Thanks for the brainteaser ref. It contained the ref to the specification.]

Henry
[ November 09, 2006: Message edited by: Henry Wong ]

[Saurabh Vyas]

Hi Sunil,

This is the case of forward referencing of variable.

This can be better understood if we understand the flow of initialization in a class.
For a class first final static variables are initialized, than static variable, than static methods, and so on....

Now here in your case both INSTANCE and MAX_SIZE are final static variables, so they will be initialized in the order of top to bottom. Thus INSTANCE will be initialized before MAX_SIZE. ( since both are initialized by some method call and not directly by some finite value )

public static final SizeClass INSTANCE = new SizeClass(10);
private static final int MAX_SIZE = getMaxSize();

Now INSTANCE is initialized by a constructor call and in that constructor there is a forward reference for MAX_SIZE, which is not yet initialized. Thus value of MAX_SIZE will be taken as 0. Thus INSTANCE will be initialized with -10. Thus obvious o/p is "Size is -10".

Thus same logic applies when you shift the intialization of MAX_SIZE before INSTANCE ie as follows :

private static final int MAX_SIZE = getMaxSize();
public static final SizeClass INSTANCE = new SizeClass(10);

Because here MAX_SIZE will be initialized before INSTANCE so now the o/p will be "Size is 990".

Coming to the third case ie

public static final SizeClass INSTANCE = new SizeClass(10);
private static final int MAX_SIZE = 1000;

Here again the initialization from top to bottom rule applies but with a small change. Since MAX_SIZE is assigned with a finite value rather than some method call initialization, so it will be initialized before INSTANCE. Thus again the o/p will be "Size is 990".


See one earlier discussion also for further reference

SCJP Brainteaser (6)


Ranchers correct me if I am wrong anywhere.

Regards
Saurabh

[Sunil Kumar Jakkaraju]

Thanks for your answers.

[Rohit Dhodapkar]

Hi Saurabh,

Coming to the third case ie
quote:
public static final SizeClass INSTANCE = new SizeClass(10);
private static final int MAX_SIZE = 1000;
Here again the initialization from top to bottom rule applies but with a small change. Since MAX_SIZE is assigned with a finite value rather than some method call initialization, so it will be initialized before INSTANCE. Thus again the o/p will be "Size is 990".

By the above statement do you mean in case when a finite value is assigned to a static final vaiable then the top to bottom rule of initialization is not applicable. Because if it is applicable there would be still forward referencing in the constructor.. Please explain

[Henry Wong]

Originally posted by Rohit Dhodapkar:
Hi Saurabh,
By the above statement do you mean in case when a finite value is assigned to a static final vaiable then the top to bottom rule of initialization is not applicable. Because if it is applicable there would be still forward referencing in the constructor.. Please explain

Here is the exact quote from the specification...

8. Next, execute either the class variable initializers and static initializers of the class, or the field initializers of the interface, in textual order, as though they were a single block, except that final class variables and fields of interfaces whose values are compile-time constants are initialized first (�8.3.2.1, �9.3.1, �13.4.8).

The top to bottom rules still applies -- it is just that compile time constants are done first. There is still a forward referencing static initialization, but it is forward referencing something that will be done first.

Henry

[Rohit Dhodapkar]

Hi Henery,

That clarifies my doubt . final variable are compile time constants.
I noted if we remove the final from
private final int size;

The result is - 10 .

Thanks for that.

[Henry Wong]

Originally posted by Rohit Dhodapkar:
Hi Henery,

That clarifies my doubt . final variable are compile time constants.
I noted if we remove the final from
private final int size;

The result is - 10 .

Thanks for that.

Be careful with this. There are other issues. To be a compile time constant, you need all of the following.

1. The variable must be declared as final
2. The expression assigned to the variable can't call methods, instantiate objects, or anything that must be done at runtime.
3. The expression can't use any other variable that is not a compile time constant. (Don't you love those recursive definitions?)

Henry
[ November 09, 2006: Message edited by: Henry Wong ]

[Sunil Kumar Jakkaraju]

Henry

The expression can't use any other variable that is not a compile time constant.

Emphasizing your point

If I initialize MAX_SIZE with a static variable like this

    static int i = 1000;
    private static final int MAX_SIZE = i;

The output is

Size is -10

But if variable "i" is final,

    final static int i = 1000;
    private static final int MAX_SIZE = i;

The output is

Size is 990