« Bonjour, Amigo ! Je vais maintenant te parler de la façon dont les objets sont créés. »

« Qu'y a-t-il de si compliqué à cela, tonton Rishi ? Tu écris new et le nom de la classe, tu indiques le bon constructeur et c'est bon ! »

« C'est vrai. Mais que se passe-t-il à l'intérieur de l'objet quand tu fais cela ? »

« Ce qu'il se passe ? »

« Voici comment cela se passe. L'objet est créé en plusieurs étapes. »

1) D'abord, la mémoire est allouée pour toutes les variables membres de la classe.

2) Ensuite, la classe de base est initialisée.

3) Puis toutes les variables reçoivent des valeurs, si des valeurs sont spécifiées.

4) Enfin, le constructeur est appelé.

« Ça n'a pas l'air très compliqué : d'abord les variables, puis le constructeur. »

Java university

« Voyons comment cela fonctionne dans un exemple avec deux classes : »

Code Description 
class Pet
{
 int x = 5, y = 5; ←-
 int weight = 10; ←-

 Pet(int x, int y)
 {
  this.x = x; ←-
  this.y = y; ←-
 }
}
class Cat extends Pet
{
 int tailLength = 8; ←-
 int age;
 Cat(int x, int y, int age)
 {
  super(x, y); ←-
  this.age = age; ←-
 }
}
 Déclare deux classes : Pet(pet) et Cat(cat).

Dans la classe Cat, nous voyons un appel explicite au constructeur de la classe de base.
Il doit toujours se trouver sur la première ligne dans le constructeur.

Voici ce qui se passe une fois la mémoire allouée :
18 – appel au constructeur de la classe de base.
3, 4 – initialisation des variables dans Pet.
8, 9 – exécution du code dans le constructeur Pet.

Ensuite, la classe Cat commence à s'initialiser.
14 – initialisation des variables dans Cat
19 – exécution du code dans le constructeur Cat

 
public static void main(String[] args)
{
 Cat cat = new Cat (50, 50, 5);
}

« Ça me semble un peu confus. Pourquoi c'est si compliqué ? »

« Ce n'est pas si difficile si tu sais vraiment ce qui se passe : »

Si une classe n'a pas de constructeurs, un constructeur est créé automatiquement.

Constructeur par défaut 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

Si tu n'appelles pas le constructeur de la classe de base, il sera appelé automatiquement.

Appel du constructeur de la classe de base 
class Pet
{
 public String name;
}
 
class Pet extends Object
{
 public String name;
 public Pet()
 {
  super();
 }
}
 
class Cat extends Pet
{
 int x = 5;
 int y = 5;
}
 
class Cat extends Pet
{
 int x = 5;
 int y = 5;
 public Cat()
 {
  super();
 }
}

Les variables membres sont initialisées dans le constructeur.

Initialisation des variables membres 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
Ce qui se passe vraiment 
class Pet
{
 int x = 5, y = 5;
 int weight = 10;
 Pet(int x, int y)
 {
  this.x = x;
  this.y = y;
 }
}

class Cat extends Pet
{
 int tailLength = 8;
 int age;
 Cat(int x, int y, int age)
 {
  super(x, y);
  this.age = age;
 }
}
 
class Pet extends Object
{
 int x;
 int y;
 int weight;

 Pet(int x, int y)
 {
  //call of the base class's constructor
  super();
  //initialize variables
  this.x = 5;
  this.y = 5;
  this.weight = 10;
  //execute the constructor code
  this.x = x;
  this.y = y;
 }
}
class Cat extends Pet
{
 int tailLength;
 int age;
 Cat(int x, int y, int age)
 {
  //call of the base class's constructor
   super(x, y);
  //initialize variables
  this.tailLength = 8;
  //execute the constructor code
  this.age = age;
 }
}

« Maintenant c'est beaucoup plus clair : tout d'abord la classe de base, puis les variables en dehors du constructeur, et enfin le code du constructeur. »

« Bien joué, Amigo ! Tu as tout juste ! »