Wat is Constructor in Java?
CONSTRUCTOR is een speciale methode die wordt gebruikt om een nieuw gemaakt object te initialiseren en wordt aangeroepen net nadat het geheugen is toegewezen aan het object. Het kan worden gebruikt om de objecten te initialiseren naar de gewenste waarden of standaardwaarden op het moment dat het object wordt gemaakt. Het is niet verplicht voor de coder om een constructor voor een klasse te schrijven.
Als er geen door de gebruiker gedefinieerde constructor voor een klasse is opgegeven, initialiseert de compiler de lidvariabelen naar de standaardwaarden.
- numerieke gegevenstypen zijn ingesteld op 0
- char-gegevenstypen zijn ingesteld op nul-teken ('\ 0')
- referentievariabelen zijn ingesteld op null
In deze tutorial leer je-
- Regels voor het maken van een constructor
- Overbelasting van constructeurs in Java
- Constructor Chaining
Regels voor het maken van een Java Constructor
- Het heeft dezelfde naam als de klas
- Het mag geen waarde retourneren die zelfs niet ongeldig is
Voorbeeld 1 : maak uw eerste constructor in Java
Stap 1) Typ het volgende constructorprogramma in de Java-editor.
class Demo{int value1;int value2;Demo(){value1 = 10;value2 = 20;System.out.println("Inside Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();d1.display();}}
Stap 2) Bewaar, start en compileer het constructorprogramma in Java en bekijk de uitvoer.
Uitgang:
Inside ConstructorValue1 === 10Value2 === 20
Overbelasting van constructeurs in Java
Overbelasting van Java Constructor is een techniek waarbij een klasse een willekeurig aantal constructors kan hebben die verschillen in parameterlijst. De compiler onderscheidt deze constructors door rekening te houden met het aantal parameters in de lijst en hun type.
Voorbeelden van geldige constructors voor klasse Account zijn
Account(int a);Account (int a,int b);Account (String a,int b);
Voorbeeld 2 : Constructor Overloading in Java begrijpen
Stap 1) Typ de code in de editor.
class Demo{int value1;int value2;/*Demo(){value1 = 10;value2 = 20;System.out.println("Inside 1st Constructor");}*/Demo(int a){value1 = a;System.out.println("Inside 2nd Constructor");}Demo(int a,int b){value1 = a;value2 = b;System.out.println("Inside 3rd Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();Demo d2 = new Demo(30);Demo d3 = new Demo(30,40);d1.display();d2.display();d3.display();}}
Stap 2) Bewaar, compileer en voer de code uit.
Stap 3) Fout =?. Probeer de fout op te sporen voordat u doorgaat naar de volgende stap van overbelasting van de Java-constructor
Stap 4) Elke klasse heeft een standaard Constructor in Java. Standaard overbelaste constructor Java voor klasse Demo is Demo () . Als u deze constructor niet opgeeft, maakt de compiler deze voor u en initialiseert de variabelen naar de standaardwaarden. U kunt ervoor kiezen om deze standaardconstructor te overschrijven en variabelen te initialiseren naar de door u gewenste waarden, zoals weergegeven in voorbeeld 1.
Maar als u een geparametriseerde constructor specificeert zoals Demo (int a), en u wilt de standaard constructor Java Demo () gebruiken, dan is het verplicht dat u deze specificeert.
Met andere woorden, in het geval dat uw overbelastende constructor in Java wordt overschreven en u de standaard constructor Java wilt gebruiken, moet deze worden gespecificeerd.
Stap 5) Uncomment-regel # 4-8. Bewaar, compileer en voer de code uit.
Constructor Chaining
Overweeg een scenario waarin een basisklasse wordt uitgebreid door een kind. Telkens wanneer een object van de kindklasse wordt gemaakt, wordt eerst de constructor van de bovenliggende klasse aangeroepen. Dit wordt Constructor Chaining genoemd.
Voorbeeld 3: constructor chaining begrijpen
Stap 1) Kopieer de volgende code naar de editor.
class Demo{int value1;int value2;Demo(){value1 = 1;value2 = 2;System.out.println("Inside 1st Parent Constructor");}Demo(int a){value1 = a;System.out.println("Inside 2nd Parent Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){DemoChild d1 = new DemoChild();d1.display();}}class DemoChild extends Demo{int value3;int value4;DemoChild(){//super(5);value3 = 3;value4 = 4;System.out.println("Inside the Constructor of Child");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);System.out.println("Value1 === "+value3);System.out.println("Value2 === "+value4);}}
Stap 2) Voer de code uit. Als gevolg van constructorketting, wanneer het object van de onderliggende klasse DemoChild wordt gemaakt, wordt eerst de constructor Demo () van de bovenliggende klasse aangeroepen en wordt later de constructor DemoChild () van het kind gemaakt. Verwachte output =
Inside 1st Parent ConstructorInside the Constructor of ChildValue1 === 1Value2 === 2Value1 === 3Value2 === 4
Stap 3) Het is mogelijk dat de constructor van de bovenliggende klasse Demo wordt overschreven. Wat als u de overschreven constructor Demo (int a) wilt aanroepen in plaats van de standaardconstructor Demo () wanneer uw onderliggende object wordt gemaakt?
In dergelijke gevallen kunt u het trefwoord "super" gebruiken om overschreven constructors van de bovenliggende klasse aan te roepen.
Syntaxis:-
super();--or--super(parameter list);
Voorbeeld: Als uw constructor is zoals Demo (String Name, int a) , specificeert u super ("Java", 5). Indien gebruikt, moet het sleutelwoord super de eerste regel code zijn in de constructor van de child class.
Stap 4) Uncomment Line # 26 en voer de code uit. Bekijk de output.
Uitgang:
Inside 2nd Parent ConstructorInside the Constructor of ChildValue1 === 5Value2 === 0Value1 === 3Value2 === 4