Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to understand the Java class loading mechanism". In the daily operation, I believe many people have doubts about how to understand the Java class loading mechanism. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "how to understand the Java class loading mechanism". Next, please follow the editor to study!

In many Java interviews, we often see an examination of the Java class loading mechanism, such as the following question:

Class Grandpa {static {System.out.println ("Grandpa in the static code block");}} class Father extends Grandpa {static {System.out.println ("Dad in the static code block");} public static int factor = 2510 public Father () {System.out.println ("I am the father ~");}} class Son extends Father {static {System.out.println ("son in the static code block");} public Son () {System.out.println ("I am the son ~") }} public class InitializationDemo {public static void main (String [] args) {System.out.println ("Dad's age:" + Son.factor); / / entry}}

Please write the final output string.

The correct answer is:

Grandpa in the static code block Dad's age in the static code block: 25

I believe that after seeing this topic, many students' expressions are broken and they have no idea where to start. Some even met several times, still can not find the right way of thinking.

In fact, this kind of interview question is to examine your understanding of the Java class loading mechanism.

If you don't understand the Java loading mechanism, you won't be able to solve this problem.

So in this article, I will first take you to learn the basic knowledge of Java class loading, and then analyze several topics to let you master your ideas.

Let's first learn the seven stages of the Java class loading mechanism.

Seven stages of the Java class loading mechanism

When our Java code is compiled, the corresponding class file is generated. Then when we run the java Demo command, we actually start the JVM virtual machine to execute the contents of the class bytecode file. The process of JVM virtual machine executing class bytecode can be divided into seven stages: loading, verification, preparation, parsing, initialization, use and unloading.

Load

The following is the most official description of the loading process.

The loading phase is the first stage of the class loading process. At this stage, the main purpose of JVM is to convert the bytecode from various locations (network, disk, etc.) into a binary byte stream and load it into memory, and then create a corresponding Class object for this class in the method area of JVM, which is the access entry for all kinds of data of this class.

In fact, the loading phase is in one sentence: load the code data into memory. This process is not directly related to our answer to this question, but it is a process of class loading mechanism, so it must be mentioned.

Verification

When JVM loads the Class bytecode file and creates the corresponding Class object in the method area, JVM starts the verification of the bytecode stream, and only files that conform to the JVM bytecode specification can be executed correctly by JVM. This verification process can be roughly divided into the following types:

JVM specification check. JVM checks the file format of the byte stream to determine whether it conforms to the JVM specification and can be processed by the current version of the virtual machine. For example: whether the file starts with 0x cafe bene, whether the major and minor version numbers are within the scope of the current virtual machine processing, and so on. Code logic check. JVM validates the data flow and control flow of the code to ensure that there are no fatal errors after JVM runs the bytecode file. For example, a method requires a parameter of type int, but when it is used, it passes in a parameter of type String. A method requires a result of type String to be returned, but no result is returned in the end. A class named Apple is referenced in the code, but you don't actually define an Apple class.

When the code data is loaded into memory, the virtual machine validates the code data to see if the code is actually written according to the JVM specification. This process is not directly related to answering questions, but it is necessary to understand the class loading mechanism.

Prepare (key points)

When the bytecode file is verified, JVM starts allocating memory for the class variables and initializing them. There are two key points to pay attention to here, namely, the object of memory allocation and the type of initialization.

The object of memory allocation. There are two types of variables in Java: "class variable" and "class member variable". "class variable" refers to the variable modified by static, while all other types of variables belong to "class member variable". In the preparation phase, JVM allocates memory only for class variables, not for class member variables. Memory allocation for Class member variables does not begin until the initialization phase.

For example, in the preparation phase, the following code allocates memory only for the factor property, not for the website property.

Public static int factor = 3th public String website = www.cnblogs.com/chanshuyi

The type of initialization. In the preparation phase, JVM allocates memory to the class variable and initializes it. But initialization here refers to assigning a variable the zero value of the data type in the Java language, not the initialized value in the user code.

For example, in the following code, after the preparation phase, the value of sector will be 0 instead of 3.

Public static int sector = 3

But if a variable is constant (modified by static final), the property is given the value the user wants during the preparation phase. For example, in the following code, after the preparation phase, the value of number will be 3 instead of 0.

Public static final int number = 3

The reason why the static final is copied directly and the static variable is assigned a zero value. In fact, we can figure it out after a little thinking.

The difference between the two statements is that one is modified by the final keyword and the other is not. The final keyword means immutable in Java, meaning that once the value of number is assigned, it will not change. Since once the assignment is no longer changed, it must be given the user's desired value in the first place, so the class variable modified by final is given the desired value in the preparation phase. Class variables that are not modified by final may change during initialization or run-time, so there is no need to give users the desired value during the preparation phase.

Analysis

After the preparation phase, JVM parses seven types of references to classes or interfaces, fields, class methods, interface methods, method types, method handles, and call point qualifiers. The main task of this phase is to replace its symbolic reference in the constant pool with its direct reference in memory.

In fact, this stage is almost transparent to us, just learn about it.

Initialization (focus)

It is not until the initialization phase that the user-defined Java program code really begins to execute. At this stage, JVM initializes the class object according to the order in which the statement is executed. Generally speaking, initialization is triggered when JVM encounters the following five situations:

When you encounter four bytecode instructions new, getstatic, putstatic, and invokestatic, if the class has not been initialized, you need to trigger its initialization first. The most common Java code scenarios that generate these four instructions are when an object is instantiated with the new keyword, when a static field of a class is read or set (except for a static field that has been decorated by final, when the compiler has put the result into the constant pool), and when the static method of a class is called. When you make a reflection call to a class using the method of the java.lang.reflect package, if the class has not been initialized, you need to trigger its initialization first. When initializing a class, if you find that its parent class has not been initialized, you need to trigger the initialization of its parent class first. When the virtual machine starts, the user needs to specify a main class to execute (the class that contains the main () method), and the virtual machine initializes the main class first. When using JDK1.7 dynamic language support, if the last parsing result of a java.lang.invoke.MethodHandle instance is the method handle of REF_getstatic,REF_putstatic,REF_invokeStatic, and the corresponding class of the method handle is not initialized, its initialization needs to be triggered by first-out.

You may get dizzy when you see the above conditions, but it doesn't matter, you don't need to memorize it, just know it, and just go back and look for it when you use it later.

Use

When the JVM completes the initialization phase, the JVM starts executing the user's program code from the entry method. At this stage, you just need to get to know it.

Unloading

When the user program code is finished, JVM begins to destroy the created Class object, and finally the JVM responsible for running it exits memory. At this stage, you just need to get to know it.

After watching Java's class load wit, I feel a little confused. No, let's wake up with a small example.

Public class Book {public static void main (String [] args) {System.out.println ("Hello ShuYi.");} Book () {System.out.println ("Construction method of the Book"); System.out.println ("price=" + price + ", amount=" + amount);} {System.out.println ("ordinary Code Block of the Book");} int price= 110 static {System.out.println ("static Code Block of the Book");} static int amount= 112;}

Think about what the above code outputs?

I'll give you five minutes to think and hand in your paper in five minutes. Haha.

So, have you made up your mind? the answer has been announced.

The static code block of the book Hello ShuYi.

So, did you get the right answer? Is it a little different from what you think?

Let's briefly analyze it. First, we initialize the class according to the fourth of the five situations mentioned above (when the virtual machine starts, the user needs to specify a main class to execute (the class that contains the main () method), and the virtual machine initializes this main class first.

So what is the order in which classes are initialized?

Here comes the point!

Here comes the point!

Here comes the point!

In our code, we only know that there is one constructor, but in fact, after Java code is compiled into bytecode, there is no concept of constructor, only class initialization method and object initialization method.

So how did these two methods come from?

Class initialization method. According to the order of its occurrence, the compiler collects the assignment statements and static code blocks of class variables, and finally forms the class initialization method. Class initialization methods are generally executed when the class is initialized.

In the above example, the class initialization method is the following code:

Static {System.out.println ("static code block of a book");} static int amount = 112

Object initialization method. According to the order of its occurrence, the compiler will collect the assignment statements of member variables, ordinary code blocks, and finally collect the code of the constructor, and finally form the object initialization method. Object initialization methods are typically performed when class objects are instantiated. In the above example, the object initialization method is the following code:

{System.out.println ("ordinary code block of a book");} int price= 110 system. Out.println ("Construction method of a book"); System.out.println ("price=" + price + ", amount=" + amount)

After the class initialization method and the object initialization method, let's look at this example again, it is not difficult for us to get the above answer.

But careful friends will find that the above example does not actually execute the object initialization method.

Because we really didn't instantiate the Book class object. If you add a new Book () statement to the main method, you will find that the initialization method of the object is executed!

Interested friends can try it by themselves, but I won't do it here.

Through the above theory and simple examples, let's move on to a more complex actual combat analysis.

Actual combat analysis

Class Grandpa {static {System.out.println ("Grandpa in the static code block");}} class Father extends Grandpa {static {System.out.println ("Dad in the static code block");} public static int factor = 2510 public Father () {System.out.println ("I am the father ~");}} class Son extends Father {static {System.out.println ("son in the static code block");} public Son () {System.out.println ("I am the son ~") }} public class InitializationDemo {public static void main (String [] args) {System.out.println ("Dad's age:" + Son.factor); / / entry}}

Think about it, what is the final output of the above code?

The final output is:

Grandpa in the static code block Dad's age in the static code block: 25

Some people may ask why the string "son in the static code block" is not output.

This is because for static fields, only the class that defines the field directly will be initialized (execute the static block of code). Therefore, referencing static fields defined in the parent class through its subclass will only trigger the initialization of the parent class, not the initialization of the subclass.

For the example above, we can start from the entrance and go on with the analysis:

First, the program goes to the main method and uses standardization to output the factor class member variable in the Son class, but this class member variable is not defined in the Son class. So we look for the parent class, and we find the corresponding class member variable in the Father class, which triggers the initialization of Father. However, according to the third of the five initialization cases mentioned above (when initializing a class, if you find that its parent class has not been initialized, you need to trigger the initialization of its parent class first. We need to initialize the parent class of the Father class first, that is, initialize the Grandpa class before initializing the Father class. So we first initialize the Grandpa class output: "Grandpa in the static code block", and then initialize the Father class output: "Dad is in the static code block". Finally, after all the parent classes have been initialized, the Son class can call the parent's static variable to output: "Dad's age: 25."

What do you think? do you feel suddenly enlightened?

Let's take a look at a more complicated example and see what the output is.

Class Grandpa {static {System.out.println ("Grandpa in the static code block");} public Grandpa () {System.out.println ("I'm Grandpa ~");}} class Father extends Grandpa {static {System.out.println ("Dad in the static code block");} public Father () {System.out.println ("I'm the father ~");}} class Son extends Father {static {System.out.println ("son in the static code block") } public Son () {System.out.println ("I am a son ~");}} public class InitializationDemo {public static void main (String [] args) {new Son (); / / entry}}

The output is as follows:

Grandpa in the static code block, father in the static code block, son in the static code block, I am the grandfather ~ I am the father ~ I am the son ~

So, do you think this problem is different from the one above?

Let's take a closer look at the execution flow of the above code:

First of all, at the entrance, we instantiate a Son object, so it will trigger the initialization of the Son class, and the initialization of the Son class will drive the initialization of the Father and Grandpa classes, thus executing the static code block in the corresponding class. So output: "Grandpa in the static code block", "father in the static code block", "son in the static code block". When the Son class is initialized, the constructor of the Son class is called, and the call to the constructor of the Son class also drives the call of the constructor of the Father and Grandpa classes, and finally outputs: "I am grandpa ~", "I am the father ~", "I am the son ~".

After reading two examples, I believe everyone is confident.

Let's show you an example of a special point, which is a little difficult.

Public class Book {public static void main (String [] args) {staticFunction ();} static Book book = new Book (); static {System.out.println ("static code block of a book");} {System.out.println ("common code block of a book");} Book () {System.out.println ("construction method of a book"); System.out.println ("price=" + price + ", amount=" + amount);} public static void staticFunction () {System.out.println ("static method of a book") } int price = 110 position static int amount = 112;}

The output of the above example is:

The construction method of the general code block book of the book static method of the static code block book of price=110,amount=0 book

Let's analyze the entire execution process of the code step by step.

In the above two examples, because there is no extra code in the class where the main method is located, we directly ignore the initialization of the class in which the main method is located.

But in this example, there is a lot of code in the class where the main method belongs, and we can't just ignore it.

When JVM is in the preparation phase, the class variables are allocated memory and initialized. At this point, our book instance variable is initialized to null,amount variable and initialized to 0. When entering the initialization phase, because the Book method is the entrance to the program, according to the fourth of the five cases of class initialization we mentioned above (when the virtual machine starts, the user needs to specify a main class to execute (the class that contains the main () method), and the virtual machine initializes this main class first. So JVM initializes the Book class, which executes the class constructor. JVM initializes the Book class first by executing the class constructor (the class constructor is formed by collecting all static code blocks and class variable assignment statements in the class sequentially), then executes the object constructor (sequentially collects member variable assignments and ordinary code blocks, and finally collects the object constructor, and finally forms the object constructor).

For the Book class, the class constructor () can be simply expressed as follows:

Static Book book = new Book (); static {System.out.println ("static code block of the book");} static int amount = 112

So first execute the statement static Book book = new Book (); which in turn triggers the class instantiation. So JVM executes the object constructor and collects the object constructor code:

{System.out.println ("ordinary code block of a book");} int price= 110: book () {System.out.println ("Construction method of a book"); System.out.println ("price=" + price + ", amount=" + amount);}

So at this time price gives the value of 110, the output: "the ordinary code block of the book", "the construction method of the book". At this point, price is 110, and the assignment statement for amount is not executed, so only the zero value is assigned during the preparation phase, so "price=110,amount=0" is output later.

When the class instantiation is complete, JVM continues to initialize the class constructor:

Static Book book = new Book (); / / complete class instantiation static {System.out.println ("static code block of the book");} static int amount = 112

That is, the output: "static code block of the book", followed by a value of 112 assigned to amount.

At this point, the class has been initialized, and JVM executes the contents of the main method.

Public static void main (String [] args) {staticFunction ();}

That is, output: "the static method of the book".

Methodology

As you can see from the above examples, the execution order of a class can be analyzed by following the following steps:

Determine the initial value of the class variable. In the preparation phase of class loading, JVM initializes a zero value for the class variable, which then has an initial zero value. If it is a class variable modified by final, it will be initialized to the value that the user wants. Initialize the entry method. When you enter the initialization phase of class loading, JVM looks for the entire main method entry, initializing the entire class in which the main method resides. When a class needs to be initialized, the class constructor () is initialized first, followed by the object constructor (). Initialize the class constructor. JVM collects the assignment statements and static code blocks of class variables in order, and finally forms the class constructor, which is executed by JVM. Initialize the object constructor. JVM will follow the assignment statements of collecting member variables, normal code blocks, and finally collect constructors, form them into object constructors, and finally be executed by JVM.

If you encounter initialization of another class while initializing the class where the main method is located, load the corresponding class first and return after loading. This loop is repeated, and finally the class where the main method is located is returned.

At this point, the study on "how to understand the Java class loading mechanism" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.