1. Ordre d’initialisation d’un objet en Java : qui en premier, qui en dernier ?
Créer un objet en Java — ce n’est pas simplement « allouer de la mémoire et y écrire des valeurs ». C’est tout un rituel avec un ordre d’actions strict. Si l’on compare le processus d’initialisation au lancement d’une fusée, chaque étage a sa place précise.
Quand vous écrivez :
Person person = new Person("John", 30);Java exécute les étapes suivantes :
- Alloue de la mémoire pour l’objet et assigne des valeurs par défaut à tous les champs.
- Exécute les initialisations explicites des champs (si vous avez fourni des valeurs directement à la déclaration).
- Exécute tous les blocs d’initialisation d’instance (non statiques) — dans l’ordre où ils apparaissent dans la classe.
- Exécute le corps du constructeur que vous avez appelé via new.
Voyons chaque étape en détail.
2. Initialisation des champs
Valeurs par défaut
Quand l’objet vient tout juste d’être créé (avant tout affectation explicite), tous ses champs reçoivent des valeurs par défaut :
| Type de champ | Valeur par défaut |
|---|---|
|
|
|
|
|
|
|
'\u0000' (caractère nul) |
| Types de référence (String, autres objets) | |
Initialisation explicite
Si, lors de la déclaration d’un champ, vous lui assignez immédiatement une valeur, celle-ci sera établie après les valeurs par défaut, mais avant l’exécution du constructeur.
public class Person {
private String name = "Sans nom";
private int age = 18;
}
Si vous créez un objet via un constructeur vide, ces valeurs resteront. Si vous utilisez un constructeur avec paramètres, elles seront très probablement remplacées.
3. Blocs d’initialisation : à quoi servent-ils et comment fonctionnent-ils
En Java, on peut déclarer des blocs d’initialisation d’instance (non statiques). Ils s’exécutent à chaque fois qu’un objet est créé, juste après l’initialisation des champs, mais avant le constructeur.
Syntaxe :
public class Person {
{
System.out.println("Exécution du bloc d'initialisation d'instance !");
}
}
Si la classe contient plusieurs blocs de ce type, ils s’exécutent dans l’ordre où ils sont écrits.
Exemple avec plusieurs blocs
public class Person {
private String name = "Sans nom";
{
System.out.println("Bloc 1: name = " + name);
name = "Énigme";
}
{
System.out.println("Bloc 2: name = " + name);
}
public Person() {
System.out.println("Constructeur: name = " + name);
}
}
Si on crée un objet :
Person p = new Person();
La sortie sera :
Bloc 1: name = Sans nom
Bloc 2: name = Énigme
Constructeur: name = Énigme
À quoi servent les blocs d’initialisation ?
Dans la pratique, les blocs d’initialisation sont utilisés rarement. En général, tout ce que l’on peut faire dans un bloc peut aussi se faire à la déclaration du champ ou dans le constructeur. Mais parfois (par exemple, si vous avez plusieurs constructeurs et qu’une partie de la logique d’initialisation doit être commune à tous), les blocs d’initialisation peuvent être pratiques.
4. Constructeur : le point final de l’initialisation
Après que tous les champs ont reçu leurs valeurs (par défaut ou explicites) et que tous les blocs d’initialisation ont été exécutés, le constructeur est appelé — celui que vous avez indiqué après new.
Dans le constructeur, vous définissez généralement les valeurs finales des champs, recevez des paramètres et effectuez d’autres initialisations dépendantes des données d’entrée.
public class Person {
private String name;
private int age;
public Person(String name, int age) {
System.out.println("Constructeur: name = " + name + ", age = " + age);
this.name = name;
this.age = age;
}
}
5. Démonstration de l’ordre complet d’initialisation
Écrivons une classe qui montre explicitement dans quel ordre l’initialisation se produit.
public class Person {
private String name = "Sans nom";
private int age = 18;
{
System.out.println("Bloc d'initialisation: name = " + name + ", age = " + age);
age = 21;
}
public Person() {
System.out.println("Constructeur sans paramètres: name = " + name + ", age = " + age);
}
public Person(String name, int age) {
System.out.println("Constructeur avec paramètres: name = " + name + ", age = " + age);
this.name = name;
this.age = age;
}
public void printInfo() {
System.out.println("Person: name = " + name + ", age = " + age);
}
}
Et maintenant dans notre classe principale (par exemple, Main) :
public class Main {
public static void main(String[] args) {
System.out.println("Création de l'objet p1:");
Person p1 = new Person();
p1.printInfo();
System.out.println("\nCréation de l'objet p2:");
Person p2 = new Person("Pierre", 30);
p2.printInfo();
}
}
La sortie sera à peu près la suivante :
Création de l'objet p1:
Bloc d'initialisation: name = Sans nom, age = 18
Constructeur sans paramètres: name = Sans nom, age = 21
Person: name = Sans nom, age = 21
Création de l'objet p2:
Bloc d'initialisation: name = Sans nom, age = 18
Constructeur avec paramètres: name = Sans nom, age = 21
Person: name = Pierre, age = 30
Attention : dans le constructeur avec paramètres, les valeurs des champs sont encore les anciennes (celles après le bloc d’initialisation). Ce n’est qu’après le constructeur que les champs reçoivent leurs valeurs finales.
6. Schéma de l’ordre d’initialisation
Voici un petit schéma (organigramme) pour visualiser :
flowchart TD
A[Allocation de mémoire, valeurs par défaut] --> B[Initialisation explicite des champs]
B --> C[Exécution des blocs d'initialisation d'instance]
C --> D[Exécution du constructeur]
D --> E[Objet prêt à être utilisé]
7. Particularités et nuances
Champs statiques et blocs statiques
Dans cette leçon, nous parlons uniquement des champs et blocs d’instance (non statiques). Les champs statiques et les blocs statiques sont initialisés une seule fois lors du chargement de la classe, et non à chaque création d’objet. Nous en reparlerons dans les thèmes consacrés à l’encapsulation.
Quand quoi est initialisé ?
- Champs — à chaque création d’un objet.
- Blocs d’initialisation — à chaque création d’un objet.
- Champs et blocs statiques — une seule fois lors du chargement de la classe.
Peut-on accéder aux champs dans les blocs d’initialisation ?
Oui, on peut ! Mais il est important de se rappeler que si un champ est déclaré plus bas que le bloc, il existe déjà, et si vous y accédez avant son initialisation explicite, vous obtiendrez sa valeur par défaut.
8. Erreurs typiques lors de l’initialisation d’objets
Erreur n°1 : penser que les champs sont initialisés avant leur déclaration.
En Java, l’ordre de déclaration des champs et des blocs d’initialisation dans la classe a de l’importance. Si, dans un bloc d’initialisation, vous accédez à un champ déclaré plus bas, il existe déjà mais n’est pas encore initialisé explicitement — sa valeur sera celle par défaut.
Erreur n°2 : dupliquer l’initialisation dans les blocs et les constructeurs.
Les débutants répètent souvent la même logique à la fois dans un bloc et dans un constructeur. Il vaut mieux utiliser soit un bloc, soit un constructeur, ou appeler un constructeur depuis un autre via this(...).
Erreur n°3 : s’attendre à ce que les champs statiques soient initialisés à chaque création d’objet.
Les champs et blocs statiques fonctionnent différemment — ils sont initialisés une seule fois lors du chargement de la classe.
Erreur n°4 : utiliser des champs de référence non initialisés.
Si vous oubliez d’initialiser explicitement un champ de référence (par exemple, String name;), il vaudra null jusqu’à ce que vous lui assigniez une valeur explicitement dans un bloc d’initialisation ou dans un constructeur.
GO TO FULL VERSION