En Java, chaînage de constructeur est une séquence d'invocation constructeurs lors de l'initialisation d'un objet. Il est utilisé lorsque l'on souhaite invoquer plusieurs constructeurs, l'un après l'autre en utilisant uniquement une instance. Dans cette section, nous discuterons chaînage de constructeurs en Java en détail avec des exemples appropriés. Jetons un coup d'œil rapide à qu'est-ce qu'un constructeur en Java.
Constructeur
Dans Java , un constructeur est identique à une méthode mais la seule différence est que le constructeur a le même nom que le nom de la classe. Il est utilisé pour créer une instance de la classe. Il est appelé automatiquement lorsque l'on crée un objet de la classe. Il n'a pas de type de retour. N'oubliez pas qu'un constructeur ne peut pas être abstrait , final , synchronisé , et statique . Nous ne pouvons pas remplacer un constructeur.
Il existe deux types de constructeur en Java :
- Constructeur par défaut (également connu sous le nom de constructeur sans argument)
- Constructeur paramétré
Chaînage de constructeur
Dans la chaîne de constructeurs, un constructeur est appelé depuis un autre constructeur de la même classe, ce processus est appelé chaînage des constructeurs. Cela se produit par héritage. Lorsque nous créons une instance d'une classe dérivée, tous les constructeurs de la classe héritée (classe de base) sont d'abord invoqués, après quoi le constructeur de la classe appelante (classe dérivée) est invoqué.
Nous pouvons réaliser le chaînage des constructeurs de deux manières :
divisé par chaîne java
N'oubliez pas que changer l'ordre du constructeur n'affecte pas la sortie.
Le besoin du chaînage des constructeurs
Supposons qu'il y ait cinq tâches à effectuer. Il existe deux manières d'effectuer ces tâches : soit implémenter toutes les tâches dans un seul constructeur, soit créer des tâches distinctes dans un seul constructeur.
En utilisant le mécanisme de chaînage des constructeurs, nous pouvons implémenter plusieurs tâches dans un seul constructeur. Ainsi, chaque fois que nous sommes confrontés à de tels types de problèmes, nous devons utiliser le chaînage de constructeurs. Nous pouvons rendre le programme plus lisible et compréhensible en utilisant le chaînage de constructeurs.
Règles de chaînage des constructeurs
- Une expression qui utilise ce Le mot-clé doit être la première ligne du constructeur.
- Il doit exister au moins un constructeur qui n'utilise pas ce
Constructeur Appelant un autre Constructeur
L'appel du constructeur peut se faire de deux manières :
Remarque : Dans le même bloc constructeur, nous ne pouvons pas utiliser this() et super() simultanément.
Comprenons ces deux concepts à travers des programmes Java.
police latex
Exemples de chaînage de constructeurs
Appel du constructeur de classe actuel
Nous utilisons ce() mot-clé si nous voulons appeler le constructeur de classe actuel dans la même classe. L'utilisation de this() est obligatoire car JVM ne le mettez jamais automatiquement comme le super() mot-clé. Notez que this() doit être la première ligne du constructeur. Il doit exister au moins un constructeur sans mot-clé this() .
Syntaxe:
this(); or this(parameters list);
Par exemple:
this(); this('Javatpoint');
Créons un programme Java et appelons le constructeur de classe actuel.
ConstructeurChain.java
public class ConstructorChain { //default constructor ConstructorChain() { this('Javatpoint'); System.out.println('Default constructor called.'); } //parameterized constructor ConstructorChain(String str) { System.out.println('Parameterized constructor called'); } //main method public static void main(String args[]) { //initializes the instance of example class ConstructorChain cc = new ConstructorChain(); } } Sortir:
formater une date en java
Dans l'exemple ci-dessus, nous avons créé une instance de la classe sans passer aucun paramètre. Il appelle d'abord le constructeur par défaut et le constructeur par défaut redirige l'appel vers celui paramétré à cause de this(). Les instructions à l'intérieur du constructeur paramétré sont exécutées et reviennent au constructeur par défaut. Après cela, le reste des instructions du constructeur par défaut est exécuté et l'objet est initialisé avec succès. Voici la séquence d'appel du constructeur :
ConstructorChain cc = new ConstructorChain(); -> ConstructorChain() -> ConstructorChain(String str) -> System.out.println() -> ConstructorChain() -> System.out.println()
Appel du constructeur de super classe
Parfois, nous devons appeler le constructeur de superclasse (classe parent) à partir de la classe enfant (classe dérivée). Dans de tels cas, nous utilisons le mot-clé super() dans le constructeur de classe dérivée. Il est facultatif d'écrire super() car JVM le met automatiquement. Il faut toujours l'écrire sur la première ligne. Nous obtenons une erreur de syntaxe si nous essayons d'appeler un constructeur de superclasse dans la classe enfant.
Syntaxe:
super(); or super(Parameter List);
super(): Il appelle le constructeur sans argument ou par défaut de la superclasse.
propriétés acides
super(paramètres): Il invoque le constructeur paramétré de superclasse.
N'oubliez pas que le constructeur de la superclasse ne peut pas être hérité dans la sous-classe. Il peut être appelé depuis le constructeur de sous-classe en utilisant le mot-clé super.
Créons un programme Java et implémentons le chaînage de constructeurs dans une classe héritée.
ConstructeurChaining.java
//parent class or base class class Demo { //base class default constructor Demo() { this(80, 90); System.out.println('Base class default constructor called'); } //base class parameterized constructor Demo(int x, int y) { System.out.println('Base class parameterized constructor called'); } } //derived class or child class class Prototype extends Demo { //derived class default constructor Prototype() { this('Java', 'Python'); System.out.println('Derived class default constructor called'); } //derived class parameterized constructor Prototype(String str1, String str2) { super(); System.out.println('Derived class parameterized constructor called'); } } public class ConstructorChaining { //main method public static void main(String args[]) { //initializes the instance of example class Prototype my_example = new Prototype(); } } Sortir:
