Chaîne de constructeur implicite et explicite

Chaînage de constructeur en Java est simplement l'acte d'un constructeur appelant un autre constructeur via héritage. Cela se produit implicitement lors de la construction d'une sous-classe: sa première tâche consiste à appeler la méthode constructeur de son parent. Mais les programmeurs peuvent également appeler un autre constructeur explicitement en utilisant les mots clés cette() ou super(). le cette() mot-clé appelle un autre constructeur surchargé dans la même classe; le super() Le mot clé appelle un constructeur non par défaut dans une superclasse.

Le chaînage de constructeur se produit par l'utilisation de l'héritage. La première tâche d'une méthode de constructeur de sous-classe consiste à appeler la méthode de constructeur de sa super-classe. Cela garantit que la création de l'objet de sous-classe commence par l'initialisation des classes au-dessus de lui dans la chaîne d'héritage.

Il peut y avoir un certain nombre de classes dans une chaîne d'héritage. Chaque méthode constructeur appelle la chaîne jusqu'à ce que la classe du haut soit atteinte et initialisée. Ensuite, chaque classe suivante ci-dessous est initialisée lorsque la chaîne revient à la sous-classe d'origine. Ce processus est appelé chaînage de constructeur.

Notez que:

• Cet appel implicite à la superclasse est le même que si la sous-classe avait inclus le super() mot-clé, c'est-à-dire super() est implicite ici.
• Si un constructeur sans argument n'est pas inclus dans la classe, Java en crée un en arrière-plan et l'invoque. Cela signifie que si votre seul constructeur prend un argument, vous devez explicitement utiliser un cette() ou super() pour l'invoquer (voir ci-dessous).

Considérez cette superclasse animale étendue par les mammifères:

classe Animal {
// constructeur
Animal(){

 System.out.println ("Nous sommes dans le constructeur de la classe Animal.");
}
}

classe Mammifère étend Animal {
//constructor
Mammifère(){

 System.out.println ("Nous sommes dans le constructeur de classe Mammal.");
}
}

Maintenant, instancions la classe Mammal:

public class ChainingConstructors {

 /**
* @param args
*/
public static void main (String [] args) {
Mammifère m = nouveau Mammifère ();
}
}

Lorsque le programme ci-dessus s'exécute, Java déclenche implicitement un appel au constructeur Animal de la superclasse, puis au constructeur de la classe. Le résultat sera donc:

Nous sommes en classe constructeur d'Animal
Nous sommes dans le constructeur de classe Mammal

Utilisation explicite du cette() ou super() mots-clés vous permet d'appeler un constructeur non par défaut.

• Pour appeler un constructeur par défaut non-args ou un constructeur surchargé à partir de la même classe, utilisez le cette() mot-clé.
• Pour appeler un constructeur de superclasse non par défaut à partir d'une sous-classe, utilisez le super() mot-clé. Par exemple, si la superclasse a plusieurs constructeurs, une sous-classe peut toujours vouloir appeler un constructeur spécifique, plutôt que la valeur par défaut.

Notez que l'appel à un autre constructeur doit être la première instruction du constructeur ou Java générera une erreur de compilation.

Considérez le code ci-dessous dans lequel une nouvelle sous-classe, Carnivore, hérite de la classe Mammal qui hérite de la classe Animal, et chaque classe a maintenant un constructeur qui prend un argument.

Voici l'animal superclasse:

public class Animal
nom de chaîne privé;
public Animal (String name) // constructeur avec un argument
{
this.name = nom;
System.out.println ("Je suis exécuté en premier.");
}
}

Voici la sous-classe Mammal:

public class Mammal étend Animal {
Mammifère public (nom de chaîne)
{
super (nom);
System.out.println ("Je suis exécuté en second");
}
}

Son constructeur prend également un argument, et il utilise super (nom) pour invoquer un constructeur spécifique dans sa superclasse.

Voici une autre sous-classe Carnivore. Cela hérite de Mammal:

public class Carnivore étend Mammal {
Carnivore public (nom de chaîne)
{
super (nom);
System.out.println ("Je suis exécuté en dernier");
}
}

Lors de l'exécution, ces trois blocs de code s'impriment:

Je suis exécuté en premier.
Je suis exécuté en second.
Je suis exécuté en dernier.

Récapituler: Lorsqu'une instance de la classe Carnivore est créée, la première action de sa méthode constructeur est d'appeler la méthode constructeur Mammal. De même, la première action de la méthode constructeur Mammal est d'appeler la méthode constructeur Animal. Une chaîne d'appels de méthode constructeur garantit que l'instance de l'objet Carnivore a correctement initialisé toutes les classes de sa chaîne d'héritage.