Op Java, constructor-ketening is een reeks aanroepen constructeurs bij het initialiseren van een object. Het wordt gebruikt wanneer we een aantal constructors de een na de ander willen aanroepen door slechts één instantie te gebruiken. In deze sectie zullen we bespreken constructorketening in Java in detail met de juiste voorbeelden. Laten we er snel naar kijken wat is een constructor in Java.
Constructeur
In Java , is een constructor hetzelfde als een methode, maar het enige verschil is dat de constructor dezelfde naam heeft als de klassenaam. Het wordt gebruikt om een instantie van de klasse te maken. Het wordt automatisch aangeroepen wanneer we een object van de klasse maken. Het heeft geen retourtype. Onthoud dat een constructor dat niet kan zijn abstract , laatste , gesynchroniseerd , En statisch . We kunnen een constructor niet overschrijven.
Er zijn twee soorten constructor in Java:
- Standaardconstructor (ook bekend als een constructor zonder argumenten)
- Geparametriseerde constructor
Constructor-ketening
In de constructorketen wordt een constructor aangeroepen vanuit een andere constructor in dezelfde klasse als dit proces constructor-ketening. Het ontstaat door overerving. Wanneer we een instantie van een afgeleide klasse maken, worden eerst alle constructors van de overgeërfde klasse (basisklasse) aangeroepen, waarna de constructor van de aanroepende klasse (afgeleide klasse) wordt aangeroepen.
We kunnen constructor-chaining op twee manieren bereiken:
c-tekenreeks in array
Houd er rekening mee dat het wijzigen van de volgorde van de constructor geen invloed heeft op de uitvoer.
De noodzaak van constructorketens
Stel dat er vijf taken moeten worden uitgevoerd. Er zijn twee manieren om deze taken uit te voeren: u kunt alle taken in één constructor implementeren of afzonderlijke taken in één constructor maken.
Door het constructor-ketenmechanisme te gebruiken, kunnen we meerdere taken in één constructor implementeren. Dus wanneer we met dit soort problemen worden geconfronteerd, moeten we constructor-chaining gebruiken. We kunnen het programma leesbaarder en begrijpelijker maken door constructor-chaining te gebruiken.
Regels voor constructorketening
- Een uitdrukking die gebruikt dit trefwoord moet de eerste regel van de constructor zijn.
- Er moet ten minste één constructor bestaan die geen gebruik maakt dit
Constructor Bellen met een andere constructor
Het aanroepen van de constructor kan op twee manieren gebeuren:
Opmerking: in hetzelfde constructorblok kunnen we this() en super() niet tegelijkertijd gebruiken.
Laten we deze twee concepten begrijpen via Java-programma's.
Voorbeelden van constructorketens
Bellen met de huidige klasseconstructeur
We gebruiken dit() trefwoord als we de huidige klassenconstructor binnen dezelfde klasse willen aanroepen. Het gebruik van this() is verplicht omdat JVM zet het nooit automatisch zoals de super() trefwoord. Merk op dat this() de eerste regel van de constructor moet zijn. Er moet minstens één constructor bestaan zonder dit() trefwoord .
Syntaxis:
Download youtube vlc mediaspeler
this(); or this(parameters list);
Bijvoorbeeld:
this(); this('Javatpoint');
Laten we een Java-programma maken en de huidige klassenconstructor aanroepen.
Windows-opdracht arp
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(); } } Uitgang:
In het bovenstaande voorbeeld hebben we een instantie van de klasse gemaakt zonder een parameter door te geven. Het roept eerst de standaardconstructor aan en de standaardconstructor leidt hierdoor de aanroep om naar de geparametriseerde constructor(). De instructies binnen de geparametriseerde constructor worden uitgevoerd en keren terug naar de standaardconstructor. Daarna wordt de rest van de instructies in de standaardconstructor uitgevoerd en wordt het object succesvol geïnitialiseerd. Het volgende is de aanroepende reeks van de constructor:
ConstructorChain cc = new ConstructorChain(); -> ConstructorChain() -> ConstructorChain(String str) -> System.out.println() -> ConstructorChain() -> System.out.println()
Superklasse-constructeur bellen
Soms moeten we de superklasse-constructor (bovenliggende klasse) aanroepen vanuit de onderliggende klasse (afgeleide klasse). In dergelijke gevallen gebruiken we het sleutelwoord super() in de afgeleide klasse-constructor. Het is optioneel om super() te schrijven omdat JVM dit automatisch plaatst. Het moet altijd in de eerste regel worden geschreven. We krijgen een syntaxisfout als we proberen een superklasse-constructor in de onderliggende klasse aan te roepen.
Syntaxis:
super(); or super(Parameter List);
super(): Het roept de no-argument- of standaardconstructor van de superklasse aan.
Java-hoofdmethode
super(parameters): Het roept de geparametriseerde constructor van de superklasse aan.
Houd er rekening mee dat de superklasseconstructor niet kan worden overgenomen in de subklasse. Het kan worden aangeroepen vanuit de subklasseconstructor met behulp van het sleutelwoord super.
Laten we een Java-programma maken en constructor-chaining implementeren in een overgeërfde klasse.
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(); } } Uitgang:
