28.2.2. Loading Process

• Loading: Reads .class files into memory.

The first step in the loading process is simply to load the class files. When you compile a Java program, it generates bytecode in the form of .class files. The Class Loader is responsible for finding these files on the disk and reading them into the memory of the Java Virtual Machine (JVM). This is crucial because the JVM needs access to the bytecode to execute the program.

Think of loading as opening a book before you start reading. Just like a book needs to be opened and its pages brought into view for reading, the .class files must be loaded into memory before the JVM can run the program.

• Linking: o Verification o Preparation o Resolution

Linking is the next stage after loading. It has three sub-steps:

1. Verification: At this stage, the JVM checks the validity of the bytecode to ensure it adheres to Java's safety and security rules. This helps prevent issues like loading corrupt or harmful classes.
2. Preparation: Here, the JVM allocates memory for static fields and initializes them to their default values (like 0, null, etc.). This step prepares the class for use in terms of memory allocation.
3. Resolution: In this final step of linking, the JVM resolves symbolic references (like method calls or field accesses) into direct references. This ensures that when the program runs, it knows where to find these elements in memory.

Consider linking as organizing a file cabinet. Verification is like checking if the files are correctly labeled and in good condition. Preparation is like setting aside space for new documents (static fields). Resolution is like filing documents in their proper places, ensuring you know where to find them later.

• Initialization: Execution of static blocks.

Initialization is the last phase of the loading process. In this phase, the JVM executes any static blocks and initializes static variables for the class. Static blocks are code blocks that run only once when the class is loaded and can be useful for complex initialization tasks that cannot be accomplished with simple assignments. After this step, the class is fully ready to be used in the program.

Imagine initializing as the final checklist before a flight. Just as pilots perform a series of checks and procedures to ensure everything is ready before takeoff, the JVM runs static blocks and sets up static variables to ensure that the class is fully prepared for use during runtime.

--