Initialization Process

Hi,

studying for the SCJP, I had some problems in understanding the rules of the class loading and object creation process. To entirely understand it, I wrote a little test programm, which imho answers all open questions.
I'd like to share it with you, in the hopes that it will also help you.
(Please let me know what you think...)

public class SCJPTest {
public static void main(String[] args) {

System.out.println("begin");
B b1 = null;
A a1 = null;
 
System.out.println("End variable declaration");
System.out.println("------------------------------");

b1 = B.myStaticB;
System.out.println("------------------------------");
System.out.println("End static initialization of B");
System.out.println("------------------------------");

a1 = A.myStaticA;
System.out.println("------------------------------");
System.out.println("End static initialization of A");
System.out.println("------------------------------");
 
new B("b");
System.out.println("------------------------------");
System.out.println("End instance creation of B");
System.out.println("------------------------------");

new A();
System.out.println("------------------------------");
System.out.println("End instance creation of A ");
System.out.println("------------------------------");
}
}
 
class A {
public static A myStaticA;
public static String aString = myFunction("static variable A1");
String a = myFunction("instance member A1");
static {
System.out.println("static initializer A2");
}
{
System.out.println("instance initializer A2");
}
 
private static String myFunction(String s) {
System.out.println(s);
return s;
}
 
static {
System.out.println("static initializer A3");
}
{
System.out.println("instance initializer A3");
}
 
public A() {
this("s");
System.out.println("instance constructor A4");
}

public A(String s) {
System.out.println("instance constructor A5");
}
 
static {
System.out.println("static initializer A4");
}
{
System.out.println("instance initializer A6");
}
 
static {
System.out.println("static initializer A5");
}
{
System.out.println("instance initializer A7");
}
public String a2 = myFunction("instance member A8");
public static String aString2 = myFunction("static variable A6");
}
 
class B extends A {
public static B myStaticB;
static {
System.out.println("static initializer B1");
}
public static String bString = myFunction("static variable B2");
String b = myFunction("instance member B1");
{
System.out.println("instance initializer B2");
}
 
private static String myFunction(String s) {
System.out.println(s);
return s;
}
 
static {
System.out.println("static initializer B3");
}
{
System.out.println("instance initializer B3");
}
 
public B(String s) {
this();
System.out.println("instance constructor B4");
}

public B() {
System.out.println("instance constructor B5");
}

static {
System.out.println("static initializer B4");
}
{
System.out.println("instance initializer B6");
}
 
static {
System.out.println("static initializer B5");
}
{
System.out.println("instance initializer B7");
}
public String b2 = myFunction("instance member B8");
public static String bString2 = myFunction("static variable B6");
}

The output is:

begin
End variable declaration
------------------------------
static variable A1
static initializer A2
static initializer A3
static initializer A4
static initializer A5
static variable A6
static initializer B1
static variable B2
static initializer B3
static initializer B4
static initializer B5
static variable B6
------------------------------
End static initialization of B
------------------------------
------------------------------
End static initialization of A
------------------------------
instance member A1
instance initializer A2
instance initializer A3
instance initializer A6
instance initializer A7
instance member A8
instance constructor A5
instance constructor A4
instance member B1
instance initializer B2
instance initializer B3
instance initializer B6
instance initializer B7
instance member B8
instance constructor B5
instance constructor B4
------------------------------
End instance creation of B
------------------------------
instance member A1
instance initializer A2
instance initializer A3
instance initializer A6
instance initializer A7
instance member A8
instance constructor A5
instance constructor A4
------------------------------
End instance creation of A
------------------------------

From the output I come to the following conclusions:

1. A class is loaded only when it's used, not just because it's part of the file where the main method is executed.
2. A class is loaded, as soon as an instance is is created, or if you access a static member of the class.
3. You have to look at the process in different levels of abstraction.
First level: The classes - Parent class is loaded before child class
Second level: The variables and initializers - static before instance, each "group" from top to bottom, first in class is loaded first
Third level: The constructors - The last thing beeing called are the constructors. The order in which they are called depends on how they are chained.
4. static variables / initializers are loaded only once, instances variables / initializers are loaded once for each instance created.

It's as easy as this. That's imho all you got to know!
Reading the SCJP book of Kathy and Bert, so far I never understood it in this detail, and failed in all mock test on the subject.

Now with some coding, I think I finally understood.

Did I get it right???

Marcus
[ October 18, 2008: Message edited by: Marcus Moreno ]

Thanks Marcus for sharing your knowledge...

Hey Marcus,
The code of yours sure did show some nuances in the initializing process.Thanks for sharing with us.Now we know why you take >15 months to
take a shot at scjp.Wish you all the best!