Discussion :

[sir_gcc]

Bonjour,

j'ai une petite question sur cette structure

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public MyAppSqlConfig {
private static final SqlMapClient sqlMap;
static {
try {
String resource = “com/ibatis/example/sqlMap-config.xml”;
Reader reader = Resources.getResourceAsReader (resource);
sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
} catch (Exception e) {
// If you get an error at this point, it doesn’t matter what it was. It is going to be
// unrecoverable and we will want the app to blow up hard so we are aware of the
// problem. You should always log such errors and re-throw them in such a way that
// you can be made immediately aware of the problem.
e.printStackTrace();
throw new RuntimeException (“Error initializing MyAppSqlConfig class. Cause: ” + e);
}
}
public static SqlMapClient getSqlMapInstance () {
return sqlMap;
}
}

C'est un exemple de classe utilitaire pour utiliser iBatis. Mais ma question porte sur la syntaxe, et pas sur iBatis.

On voit à la troisième ligne un bloc de code précédé du mot-clef static. Or j'ai appris dans mes cours il y a quelque temps que dans une classe on mettait des attributs et des méthodes. Or ce n'est ni l'un ni l'autre.

Donc qu'est-ce que c'est ? Un bloc qui est éxécuté au chargement de la classe par la JVM ? Si oui à quel moment ? Avant ou après l'appel au constructeur ? Durée de vie des objets créés à l'intérieur ?

Merci pour vos réponses, même partielles.

[guis14]

Lors d'une instanciation de classe, les initialisateurs statiques sont exécutés après que les données statiques soient allouées et avant le constructeur.

Les intialisateurs statiques permettent de lancer des traitements uniquement pour la première instance d'une classe, car ils ne sont exécutés qu'une seule fois.

Les initialisateurs statiques se révélent également utiles pour l'initialisation complexes de variables statiques.

[adiGuba]

Salut,

Un bloc qui est éxécuté au chargement de la classe par la JVM ? Si oui à quel moment ?

Tu te répond toi-même : ce code est exécuté au chargement de la classe par la JVM.

Avant ou après l'appel au constructeur ?

Ce code est exécuté une seule fois au chargement de la classe.

Il n'a rien à voir avec les constructeurs...
Par contre il existe des blocs d'initialisations qui sont exécuté avant chaque appel de constructeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class Classe {
 
	{
		// Bloc d'initialisation
	}
 
}

Durée de vie des objets créés à l'intérieur ?

Ils obéissent aux mêmes règles que tous les autres objets : tant qu'une référence est accessible ils sont conservé en mémoire


Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Parent {
 
	static {
		System.out.println("Parent : bloc static{}");
	}
 
	{
		System.out.println("Parent : bloc d'initialisation {}");
	}
 
	public Parent() {
		System.out.println("Parent : constructeur");
	}
 
}
 
class Fille extends Parent {
 
	static {
		System.out.println("Fille : bloc static{}");
	}
 
	{
		System.out.println("Fille : bloc d'initialisation {}");
	}
 
	public Fille() {
		super(); // implicite si absent
		System.out.println("Fille : constructeur");
	}
 
}
 
public class Main {
 
	public static void main(String[] args) throws Exception {
		System.out.println("main()");
		System.out.println("-------------------------------------");
		new Fille();
		System.out.println("-------------------------------------");
		new Fille();
	}
}

Ce qui donnera :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
main()
---------------------------------
Parent : bloc static{}
Fille : bloc static{}
Parent : bloc d'initialisation {}
Parent : constructeur
Fille : bloc d'initialisation {}
Fille : constructeur
---------------------------------
Parent : bloc d'initialisation {}
Parent : constructeur
Fille : bloc d'initialisation {}
Fille : constructeur

a++

[sir_gcc]

Merci,

j'avais déjà ma petite idée, mais une confirmation ne fait jamais de mal

A+