Exécution de constructeurs Java dans l'héritage
- Exécution de constructeurs Java dans l’héritage
- Exécution du constructeur Java par défaut dans l’héritage
- Exécution du constructeur Java dans l’héritage lorsque la classe parent a un constructeur par défaut et paramétré
-
Utilisez
superpour appeler le constructeur paramétré de la classe parent et de toutes les classes enfants
Aujourd’hui, nous allons découvrir l’exécution des constructeurs Java en héritage. Nous verrons des exemples de code des constructeurs par défaut et paramétrés dans les classes dérivées (également appelées classes et sous-classes enfants).
Exécution de constructeurs Java dans l’héritage
Des connaissances suffisantes sur l’héritage sont nécessaires pour continuer avec cet article. Si vous lisez ce didacticiel, nous supposons que vous avez une solide compréhension de l’héritage Java.
Découvrons le processus d’exécution des constructeurs Java pendant que nous étendons la classe parente (également appelée classe de base ou superclasse) à l’aide du mot-clé extends.
Exécution du constructeur Java par défaut dans l’héritage
Exemple de code :
class parentClass {
parentClass() {
System.out.println("Default constructor of the parent class.");
}
}
class childClass extends parentClass {
childClass() {
System.out.println("Default constructor of the child class.");
}
}
class grandChildClass extends childClass {
grandChildClass() {
System.out.println("Default constructor of the grand child class.");
}
}
public class constructorsInInheritance {
public static void main(String[] args) {
grandChildClass obj = new grandChildClass();
}
}
Production:
Default constructor of the parent class.
Default constructor of the child class.
Default constructor of the grand child class.
Ici, nous avons une classe de test nommée constructorsInInheritance, qui crée l’objet de grandChildClass.
Nous avons trois autres classes nommées parentClass, childClass, grandChildClass, où la grandChildClass hérite de la childClass et childClass étend la parentClass.
Ici, le constructeur par défaut parentClass est automatiquement appelé par un constructeur childClass. Chaque fois que nous instancions la classe enfant, le constructeur de la classe parent est exécuté automatiquement, suivi du constructeur de la classe enfant.
Observez la sortie donnée ci-dessus. Si vous êtes toujours confus, consultez l’explication visuelle suivante.
Et si on créait un objet de la childClass dans la méthode main ? Comment les constructeurs par défaut seront-ils exécutés maintenant ?
Le constructeur de la parentClass sera exécuté en premier, puis le constructeur de la childClass produira le résultat suivant.
Production:
Default constructor of the parent class.
Default constructor of the child class.
Exécution du constructeur Java dans l’héritage lorsque la classe parent a un constructeur par défaut et paramétré
Exemple de code :
class parentClass {
parentClass() {
System.out.println("Default constructor of the parent class.");
}
parentClass(String name) {
System.out.println("Hi " + name + "! It's a parameterized constructor of the parent class");
}
}
class childClass extends parentClass {
childClass() {
System.out.println("Default constructor of the child class.");
}
}
class grandChildClass extends childClass {
grandChildClass() {
System.out.println("Default constructor of the grand child class.");
}
}
public class constructorsInInheritance {
public static void main(String[] args) {
grandChildClass obj = new grandChildClass();
}
}
Production:
Default constructor of the parent class.
Default constructor of the child class.
Default constructor of the grand child class.
Ici, nous avons un constructeur paramétré dans la parentClass. Cependant, les constructeurs par défaut sont toujours appelés car nous invoquons le constructeur par défaut grandChildClass() dans la méthode main, appelant en outre le constructeur par défaut de la classe parent.
Écrivons également les constructeurs paramétrés dans la childClass et la grandChildClass. Appelez ensuite le constructeur paramétré de la grandChildClass dans la fonction main.
Observez quels constructeurs sont appelés, qu’ils soient par défaut ou paramétrés.
Exemple de code :
class parentClass {
parentClass() {
System.out.println("Default constructor of the parent class.");
}
parentClass(String name) {
System.out.println("Hi " + name + "! It's a parameterized constructor of the parent class");
}
}
class childClass extends parentClass {
childClass() {
System.out.println("Default constructor of the child class.");
}
childClass(String name) {
System.out.println("Hi " + name + "! It's a parameterized constructor of the child class");
}
}
class grandChildClass extends childClass {
grandChildClass() {
System.out.println("Default constructor of the grand child class.");
}
grandChildClass(String name) {
System.out.println(
"Hi " + name + "! It's a parameterized constructor of the grand child class");
}
}
public class constructorsInInheritance {
public static void main(String[] args) {
grandChildClass obj = new grandChildClass("Mehvish");
}
}
Production:
Default constructor of the parent class.
Default constructor of the child class.
Hi Mehvish! It's a parameterized constructor of the grand child class
Le code ci-dessus appelle uniquement le constructeur paramétré de la grandChildClass. Nous utilisons le super() pour appeler le constructeur paramétré de la parentClass, de la childClass et de la grandChildClass.
N’oubliez pas que l’appel du constructeur de la classe parent doit être sur la première ligne du constructeur de la classe enfant.
Utilisez super pour appeler le constructeur paramétré de la classe parent et de toutes les classes enfants
Exemple de code :
class parentClass {
parentClass() {
System.out.println("Default constructor of the parent class.");
}
parentClass(String name) {
System.out.println("Hi " + name + "! It's a parameterized constructor of the parent class");
}
}
class childClass extends parentClass {
childClass() {
System.out.println("Default constructor of the child class.");
}
childClass(String name) {
super(name);
System.out.println("Hi " + name + "! It's a parameterized constructor of the child class");
}
}
class grandChildClass extends childClass {
grandChildClass() {
System.out.println("Default constructor of the grand child class.");
}
grandChildClass(String name) {
super(name);
System.out.println(
"Hi " + name + "! It's a parameterized constructor of the grand child class");
}
}
public class constructorsInInheritance {
public static void main(String[] args) {
grandChildClass obj = new grandChildClass("Mehvish");
}
}
Production:
Hi Mehvish! It's a parameterized constructor of the parent class
Hi Mehvish! It's a parameterized constructor of the child class
Hi Mehvish! It's a parameterized constructor of the grand child class
Nous avons utilisé le mot-clé super pour appeler le constructeur de classe parent paramétré. Il fait référence à la classe parente (superclasse ou classe de base).
Nous l’avons utilisé pour accéder au constructeur de la classe parent et appelé les méthodes de la classe parent.
super est très utile pour les méthodes avec les noms exacts dans les classes parent et enfant.
