About static blocks and instance blocks in Java.

When a class is used for the first time, it needs to be loaded by the class loader, and the loading process involves the following two points:

(1) When loading a class, if its parent class is still If it is not loaded, then its parent class must be loaded first;

(2) After the class is loaded into memory, its static data fields and static blocks are executed in the order of appearance in the code.

2. When calling the constructor of a class, the calling process involves the following three points:

(1) Calling the constructor of the parent class;

(2) Initialize instance data fields and execute instance blocks in the order they appear in the code;

(3) Execute its constructor body.

The theory still has to be proven through practice. Here is a simple example to prove it.

/**
 * 
 * @author Sel
 * 
 * 2014.3.29
 */public class InitializationDemo {	public static void main(String[] args) {		
		new InitializationDemo();
	}	
	public InitializationDemo() {		
		new B();
	}
	
	{
		System.out.println("2. Initialization 的实例块。");
	}	
	static {
		System.out.println("1. Initialization 的静态块。");
	}

}class A {
	
	A() {
		System.out.println("6. A 的构造函数体。");
	}
	
	{
		System.out.println("5. A 的实例块。");
	}	
	static {
		System.out.println("3. A 的静态块。");
	}
}class B extends A {
	
	B() {
		System.out.println("8. B 的构造函数体。");
	}
	
	{
		System.out.println("7. B 的实例块。");
	}	
	static {
		System.out.println("4. B 的静态块。");
	}
}

The above example outputs corresponding text in each part of the class, so that the execution order can be seen from the output.

The corresponding output is as follows:

1. Initialization 的静态块。
2. Initialization 的实例块。
3. A 的静态块。
4. B 的静态块。
5. A 的实例块。
6. A 的构造函数体。
7. B 的实例块。
8. B 的构造函数体。

It can be seen from the output that the sequence of program execution is as follows:

1. First, use Initialization class, then the Initialization class is loaded, so its static block is executed, so 1 is output;

2. The program calls the constructor of Initialization, so the instance block of the Initialization class is executed, so 2 is output;

3. Then, execute the constructor body of Initialization, that is, new B(). At this time, because class B is to be used, it is loaded;

4. Because the parent class of class B is A , then before loading B, A must be loaded first, so the loading process of A is executed at this time, that is, the static block of A is executed, so 3 is output;

5. After A is loaded, it is time to go to B is loaded. At this time, the loading process of B is executed, that is, the static block of B is executed, so 4 is output;

6. After the loading is completed, according to the code, new B(), which is the constructor of B, is executed. , so at this time, the constructor of the parent class A must be called first, so the instance block and constructor body of A are executed in sequence, and 5 and 6 are output;

7. Finally, the "real" execution is B's constructor (because it has been said to execute new B() before, but it has been calling others), so the instance block and constructor body of B are executed in sequence, and 7 and 8 are output.

The above is about static blocks and instance blocks in Java. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!