Initialization blocks...

[Dan Silva]

I'm having trouble understanding what initialization blocks are. I feel pretty dumb, but if somebody could give me a brief rundown, it would be much appreciated.

[Vishwanath Krishnamurthi]

Hi Dan,

Consider this:
For a static init block..

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

O/P==> one [printed when class is loaded]


Now two instantiations:

 class A
  {
     static { System.out.println("One");}
     public static void main(String[] args)
       {
         new A(); new A();
       }
 }   

O/P==>one [means its executed only once]

=====================
For a init block:

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

O/P==> nothing.... [No instantiations... so no o/p]

 class A
  {
     { System.out.println("One");}
     public static void main(String[] args)
       {
           new A(); new A();
       }
 }   

O/P==> One One [Two instantiations, so its run twice... meaning its run every time an instantiation takes place]
[ January 14, 2008: Message edited by: Vishwanath Murthi ]

[Vishwanath Krishnamurthi]

and to keep building on that...

The order is as follows..

1)static init blocks of the superclass are run first, then the subclass's....
2)In a class a static init block can appear at the top/bottom/anywhere
3)They are run in top-down order...
=====

Then if you have done any instantiations for each instantiation

1)the initializations
as in
class A{ private int aa=10;}

2)init blocks(I mean non static init blocks) of the superclass, then the subclass....
3)init blocks too in the same top-down order....
=====
then constructors...
[ January 14, 2008: Message edited by: Vishwanath Murthi ]

[Dean Jones]

The following link might help.

[Sunny Jain]

Let me try to add something :

consider a Superclass, with one static block, one init block , one instance variable
conisder one subclass with same

when you create an instance of Subclass, Following hirerachy is followed :

SubClass subClass = new SubClass();

0) Static block of super class executes

1) Static block of Subclass executes

2) Inside constructor of subclass

3) call to super constructor

5) call of Object Class constructor

6) init blocks of super class executes,in the order in which they appear

7) Instance Variable of super class executes

8)Super class constructor executes

9) Init blocks of subclass executes, in the order in which they appear

10) Instance Variable of Subclass are initialized

11) Subclass constructor executes

[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