Initializing Sequence

[Hasnain Khan]

Hello All,
I have some confusion about class loading and initialization sequence.Here is what I understood.

1 ) Static statements/static blocks are executed.
2) Instance variables are assigned default values
3) Instance variables are initialized
4) constructor runs
5) Instance initialization block(s) run after all the call(s) to super has(have) been completed but before the rest of the constructor is executed.
6) Rest of the constructor is executed.

This is my sample program.

 public class MyInitTest
{
   public MyInitTest()
   {
   System.out.println("After Instance Initialization Block");
   System.out.println("constructor called");
   
      s1 = sM1("1");
   }
   static String s1 = sM1("a");
   String s3 = sM1("2");
   {
   System.out.println("Initialization Block running");
      s1 = sM1("3");
   }
   static
   {
   System.out.println("Static Initialization Block");
      s1 = sM1("b");
   }
   static String s2 = sM1("c");
   String s4 = sM1("4");
    public static void main(String args[])
    {
    MyInitTest it = new MyInitTest();
    }
    private static String sM1(String s)
    {
    System.out.println("sM1 called with Parameter " + s);
       System.out.println(s);  return s;
    }    
}
 

and this is the output

sM1 called with Parameter a
a
Static Initialization Block
sM1 called with Parameter b
b
sM1 called with Parameter c
c
sM1 called with Parameter 2
2
Initialization Block running
sM1 called with Parameter 3
3
sM1 called with Parameter 4
4
After Instance Initialization Block
constructor called
sM1 called with Parameter 1
1

I was hoping to see 4 printed after 2 but its printing 3 ???

Could anyone kindly explain why .

Waiting for a favorable reply. Thanks in advance.
Kind Regards.
Hasnain Javed Khan

[Henry Wong]

1) Static statements/static blocks are executed.
2) Instance variables are assigned default values
3) Instance variables are initialized
4) constructor runs
5) Instance initialization block(s) run after all the call(s) to super has(have) been completed but before the rest of the constructor is executed.
6) Rest of the constructor is executed.

This list is *almost* correct. Item 3 is only true, if the instance variable is assigned a compile time constant. Otherwise, it will be done with Item 5 (instance variables *and* instance initializers will be done together from the top to the bottom, in the order they are defined).

Henry

[Deepak Chopra]

Hi,

Tho' you have already got solution for your doubt, but following code will clear your doubt :

class  JavaRanch
{
int x = getX();
int y = 10;
 
public int getX()
{
System.out.println("Break point 1");
return y;
}
 
{
System.out.println("Break point 2..");
}
 
static
{
System.out.println("Break point 0");
}
 

public JavaRanch()
{
System.out.println(x + " " + y);
}
public static void main(String[] args) 
{
JavaRanch j = new JavaRanch();
System.out.println(j.x);
System.out.println(j.y);

}
}

Output is :

---------- Java ----------
Break point 0
Break point 1
Break point 2..
0 10
0
10
Normal Termination

Thanks,
sunny

[Gitesh Ramchandani]

Just to add to the above, what I found is that:

1. static instances & init blocks run (from top to bottom order)
2. instance & init blocks runs (from top to bottom order)
3. constructor runs

The above I have tried on a single class. (having no super/sub class)

code example:

 public class tt
{
   public tt()
           {
   System.out.println("After Instance Initialization Block");
   System.out.println("constructor called");
   s1 = sM1("1");
           }
   
  static String s1 = sM1("static instance 1");
  
 String s3 = sM1("Instance 1");
   

   
static
   {
   System.out.println("Static Initialization Block");
      s1 = sM1("Inside static initialization block");
   }
   
static String s2 = sM1("static instance 2");
 
   String s4 = sM1("Instance 2");
 
{
                System.out.println("Instance Initialization Block running");
      s1 = sM1("Inside instance initialization block");
    }
 
    public static void main(String args[])
    {
    tt it = new tt();
    }
    
private static String sM1(String s)
        {
    System.out.println("static method called from " + s);
                System.out.println(s);  
                return s;
       }    
}
 

output:

static method called from static instance 1
static instance 1
Static Initialization Block
static method called from Inside static initialization block
Inside static initialization block
static method called from static instance 2
static instance 2
static method called from Instance 1
Instance 1
static method called from Instance 2
Instance 2
Instance Initialization Block running
static method called from Inside instance initialization block
Inside instance initialization block
After Instance Initialization Block
constructor called
static method called from 1
1

Regards,
Gitesh

[Gitesh Ramchandani]

Can some Bartender please reply to my above post to clarify what i think, as depicted from the sample code?

Thanks,
Gitesh

[Jart Bo]

This list is *almost* correct. Item 3 is only true, if the instance variable is assigned a compile time constant. Otherwise, it will be done with Item 5 (instance variables *and* instance initializers will be done together from the top to the bottom, in the order they are defined).

Hi Henry,

Could I ask you what you mean by compile time constant here? Thanks!

[Raghavan Muthu]

Originally posted by Jart Bo:


Hi Henry,

Could I ask you what you mean by compile time constant here? Thanks!

A compile time constant is a value which can be very well identified (determined) during the compilation time itself. It does NOT need to wait till runtime.

Some examples are: string literals whatever you type within double quotes (eg. "Sample String"), all constant values like INTEGER.MAX_VALUE etc.,

[Henry Wong]

Just to add to the above, what I found is that:

1. static instances & init blocks run (from top to bottom order)
2. instance & init blocks runs (from top to bottom order)
3. constructor runs

The above I have tried on a single class. (having no super/sub class)

This list is correct. However, with no super class, you won't be able to tell that the constructor actually starts to run before step 2. Basically, the constructor runs to find and execute the correct super constructor, then step 2 happens. After step 2, the rest of the constructor runs.

Henry