À propos des blocs statiques et des blocs d'instance en Java.

Lorsqu'une classe est utilisée pour la première fois, elle doit être chargée par le chargeur de classe, et le processus de chargement implique les deux points suivants :

(1) Lors du chargement d'une classe, si son parent la classe n'est pas Si elle n'est pas chargée, alors sa classe parent doit être chargée en premier

(2) Une fois la classe chargée en mémoire, ses champs de données statiques et ses blocs statiques sont exécutés dans l'ordre d'apparition dans le code.

2. Lors de l'appel du constructeur d'une classe, le processus d'appel implique les trois points suivants :

(1) Appel du constructeur de la classe parent ; >

(2) Initialisez les champs de données d'instance et exécutez les blocs d'instance dans l'ordre dans lequel ils apparaissent dans le code

(3) Exécutez son corps de constructeur.

La théorie doit encore être prouvée par la pratique. Voici un exemple simple pour le prouver.

/**
 * 
 * @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 的静态块。");
	}
}

L'exemple ci-dessus génère le texte correspondant dans chaque partie de la classe, de sorte que l'ordre d'exécution puisse être vu à partir de la sortie. La sortie correspondante de

est la suivante :

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

On peut voir à partir de la sortie que l'ordre d'exécution du programme est le suivant :

1. Tout d'abord, pour utiliser la classe Initialization, chargez la classe Initialization, donc son bloc statique est exécuté, donc 1 est sorti

2. Le bloc d'instance de la classe Initialization est exécuté, donc 2 est affiché

3 Ensuite, exécutez le corps du constructeur d'Initialization, c'est-à-dire new B() À ce moment-là, car la classe B doit être utilisée. , il est chargé ;

4. Parce que la classe B est la classe parent A, alors avant de charger B, A doit être chargé en premier, donc le processus de chargement de A est exécuté à ce moment-là, c'est-à-dire le Le bloc statique de A est exécuté, donc 3 est sorti

5. Après le chargement de A, à ce moment-là, lorsque B est chargé, le processus de chargement de B est exécuté, c'est-à-dire que le bloc statique de B est exécuté. exécuté, donc 4 est généré

6. Une fois le chargement terminé, exécutez new B() selon le code, c'est-à-dire le constructeur B, donc à ce moment, le constructeur de la classe parent A doit être appelé en premier, donc le bloc d'instance et le corps du constructeur de A sont exécutés en séquence, produisant 5 et 6 ; Enfin, il atteint finalement le « réel » Le constructeur de B est exécuté (car il l'a été. dit d'exécuter new B() auparavant, mais il en a appelé d'autres), donc le bloc d'instance et le corps du constructeur de B sont exécutés en séquence, et 7 et 8 sont sortis.

Ce qui précède concerne les blocs statiques et les blocs d'instance en Java. Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn) !