doubt about loading classes

[Nitin Bhardwaj]

class X{
                Y y=new Y();
	X()
	{
		System.out.print("X");
	}
}

class Y
{
               Y()
               {
	                System.out.print("Y");
                }
}

class Z extends X
{
	Y y=new Y();
	Z()
	{
		System.out.print("Z");
	}
}

public class nitIon2
{

	public static void main(String args[])
	{
		//new Z();   [color=red]// Mark 1[/color]	}
		
}

/*
Output:

When Mark 1(new Z()) is not commented output: YXYZ
When Mark 1 is commented output: (program runs without printing anything on screen)

My Understanding(I am not confident about this):

(1) When new Z() is commented: When we compile the code and run the code no class is loaded and hence no constructor or class code runs.
(2) When new Z() is not commented: When we compile the code: syntax is ok so it compiles successfully. When we invoke java then the main () method is run and constructor is called on Z which loads the class associated with it and hence the output.
*/
I thought that output would be YYXZ when new Z() is not commented. I was of the notion that when I invoke java nitIon2 then class X, Y and Z would be loaded automatically and then the statement new Z() would be executed and hence the output would be YYXZ.
However, it is not so.
Request you to please clarify my doubts regarding the compiling, executing, and loading etc(or whatever it is which I don't know right now) by throwing some information in a step by step manner right from beginning with the compilation of a .java file.
It would be really helpful of you.

Best Regards,
Nitin

[Steve Luke]

You should read this: Class Initialization (JLS) and Class Instantiation (JLS)

A class is loaded basically the first time the class is referenced. Loading a class consists of creating the static context of the parent class, then building the static content of the class in question.
1) Lock the class
2) load the parent class - recursively run these steps on the parent class
3) assign static members and run static initializers

When the class is instantiated, and instance of the class is created, then:
1) The parameters to the constructor are processed
2) The parent constructor is called -> recursively applies these steps to the parent class
3) Instance members are created and initializers are run
4) The body of the constructor runs.

So when you run Class Z here is what happens:

Class Z
    Z is accessed to get to the main() method
    1) Z is Marked as being loaded
      - Z is a subclass of X, so X must be loaded
    Class X
        1) X is marked as being loaded
         - X is a subclass of Object, so Object must be loaded (if not done already)
        Class Object
            1) Object is marked as being loaded
            2) Object static members are initialized
            3) Object is marked as done being loaded
        2) X static members are initialized
        3) X is marked as done being loaded
    2) Z static members are initialized
    3) Z is marked as done being loaded

Now Z is properly loaded, so main() can execute. When Z.main() is executed, you call new Z() so you go through the process of making a new instance of Z:

Class Z
    1) The Z() ctor is entered (parameters are processed)
     - No call to other Z ctor or explicit X ctor, so implicit call to X() is called
    2) Class X
        1) The X() ctor is entered (parameters processed)
         - No call to other X ctor or explicit Object ctor, so implicit call to Object() is called
        2) Class Object
            1) The Object() ctor is entered (parameters processed)
            3) Any Object instance members are created and initialized
            4) Object() constructor code runs
        3) The Y y instance variable in X is created
        Class Y
            1) The Y() ctor is entered (parameters processed)
             - No call to other Y ctor or explicit Object ctor, so implicit call to Object() is called
            2) Class Object
                1) The Object() ctor is entered (parameters processed)
                3) Any Object instance members are created and initialized
                4) Object is constructor code runs
            3) Instance members of Y created and initialized
            4) Body of Y() ctor code runs and 'Y' is displayed to output
        4) X() ctor code runs and 'X' is displayed to output
    3) The Y y instance in Z is created
    Class Y
        1) The Y() ctor is entered (parameters processed)
         - No call to other Y ctor or explicit Object ctor, so implicit call to Object() is called
        2) Class Object
            1) The Object() ctor is entered (parameters processed)
            3) Any Object instance members are created and initialized
            4) Object is constructor code runs
        3) Instance members of Y created and initialized
        4) Body of Y() ctor code runs and 'Y' is displayed to output
    4) Body of Z() ctor code runs and 'Z' is displayed to output