În Java, înlănţuirea constructorului este o succesiune de invocare constructorii la inițializarea unui obiect. Este folosit atunci când dorim să invocăm un număr de constructori, unul după altul folosind doar o instanță. În această secțiune, vom discuta înlănțuirea constructorului în Java în detaliu cu exemple adecvate. Să aruncăm o privire rapidă la ce este un constructor în Java.
Constructor
În Java , un constructor este același cu o metodă, dar singura diferență este că constructorul are același nume ca și numele clasei. Este folosit pentru a crea o instanță a clasei. Este apelat automat atunci când creăm un obiect al clasei. Nu are niciun tip de returnare. Amintiți-vă că un constructor nu poate fi abstract , final , sincronizate , și static . Nu putem suprascrie un constructor.
Există două tipuri de constructoare în Java:
- Constructor implicit (cunoscut și ca constructor fără argument)
- Constructor parametrizat
Constructor Chaining
În lanțul de constructori, un constructor este numit de la un alt constructor din aceeași clasă ca acest proces este cunoscut înlănţuirea constructorului. Are loc prin moștenire. Când creăm o instanță a unei clase derivate, toți constructorii clasei moștenite (clasa de bază) sunt invocați mai întâi, după care este invocat constructorul clasei apelante (clasa derivată).
Putem realiza înlănțuirea constructorului în două moduri:
linux cum se redenumește un director
Amintiți-vă că modificarea ordinii constructorului nu afectează rezultatul.
Nevoia de înlănțuire a constructorilor
Să presupunem că sunt cinci sarcini de îndeplinit. Există două moduri de a efectua aceste sarcini, fie implementați toate sarcinile într-un singur constructor, fie creați sarcini separate într-un singur constructor.
Folosind mecanismul de înlănțuire a constructorului, putem implementa mai multe sarcini într-un singur constructor. Deci, ori de câte ori ne confruntăm cu astfel de probleme, ar trebui să folosim înlănțuirea constructorului. Putem face programul mai lizibil și mai ușor de înțeles utilizând înlănțuirea constructorului.
Reguli de înlănțuire a constructorului
- O expresie care folosește acest cuvântul cheie trebuie să fie prima linie a constructorului.
- Trebuie să existe cel puțin un constructor care nu folosește acest
Apelarea constructorului dintr-un alt Constructor
Apelarea constructorului se poate face în două moduri:
calcularea mandatului în excel
Notă: În același bloc constructor, nu putem folosi acest() și super() simultan.
Să înțelegem aceste două concepte prin intermediul programelor Java.
Exemple de înlănțuire a constructorului
Apelarea constructorului clasei curente
Folosim acest() cuvânt cheie dacă vrem să apelăm constructorul de clasă curent în cadrul aceleiași clase. Utilizarea acestui() este obligatorie deoarece JVM nu-l pune niciodată automat ca super() cuvânt cheie. Rețineți că this() trebuie să fie prima linie a constructorului. Trebuie să existe cel puțin un constructor fără acest cuvânt cheie (). .
Sintaxă:
this(); or this(parameters list);
De exemplu:
this(); this('Javatpoint');
Să creăm un program Java și să apelăm constructorul de clasă curent.
dacă altceva în shell bash
ConstructorChain.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(); } } Ieșire:
În exemplul de mai sus, am creat o instanță a clasei fără a trece niciun parametru. Mai întâi apelează constructorul implicit, iar constructorul implicit redirecționează apelul către cel parametrizat din cauza acestui(). Instrucțiunile din interiorul constructorului parametrizat sunt executate și revin înapoi la constructorul implicit. După aceea, restul instrucțiunilor din constructorul implicit sunt executate și obiectul este inițializat cu succes. Următoarea este secvența de apelare a constructorului:
ConstructorChain cc = new ConstructorChain(); -> ConstructorChain() -> ConstructorChain(String str) -> System.out.println() -> ConstructorChain() -> System.out.println()
Apelarea la Super Class Constructor
Uneori, trebuie să apelăm constructorul superclasei (clasa părinte) din clasa copil (clasa derivată) în astfel de cazuri, folosim cuvântul cheie super() în constructorul clasei derivate. Este opțional să scrieți super() deoarece JVM îl pune automat. Ar trebui să scrie întotdeauna în primul rând. Primim o eroare de sintaxă dacă încercăm să apelăm un constructor de superclasă în clasa copil.
Sintaxă:
super(); or super(Parameter List);
super(): Apelează constructorul fără argument sau implicit al superclasei.
super(parametri): Invocă constructorul parametrizat de superclasă.
Amintiți-vă că constructorul de superclasă nu poate fi moștenit în subclasă. Poate fi apelat din constructorul de subclase folosind cuvântul cheie super.
Să creăm un program Java și să implementăm înlănțuirea constructorului într-o clasă moștenită.
numere pentru alfabet
ConstructorChaining.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(); } } Ieșire:
