Kenmerken van Constructor
- De naam van de constructor moet gelijk zijn aan de klassenaam.
- Het retourtype is ongeldig.
- De constructor kan niet statisch, abstract en definitief zijn.
Soorten constructor
- Standaard
- Zonder parameter
- Geparametriseerd
1. Standaardconstructor
De standaardconstructor wordt gemaakt door de Java-compiler wanneer de coder geen enkele constructor voor de klasse declareert en deze constructor geen enkel argument bevat. Het Java-bestand bevat geen code voor de standaardconstructor. De standaard constructorcode wordt gemaakt op het moment dat de Java-code wordt gecompileerd en wordt opgeslagen in de .klas het dossier.
2. Constructor zonder parameters
Wanneer een constructor wordt gedeclareerd zonder enige parameter of argument, wordt het een parameterloze constructor genoemd. Een parameterloze constructor werkt als een standaardconstructor en deze constructor kan instructies bevatten, of hij kan leeg zijn.
3. Geparametriseerde Constructor:
Wanneer een constructor wordt gedeclareerd met een of meer parameters, wordt dit een geparametriseerde constructor genoemd. De parameterwaarden van de constructor worden doorgegeven op het moment dat het object wordt gemaakt.
Voorbeeld 1: Een parameterloze constructor maken
De volgende code laat zien hoe u een parameterloze constructor gebruikt. Er werd eerder vermeld dat de naam van de constructormethode hetzelfde zal zijn als de klassenaam. Hier is de klassenaam ' con1 ,' dus de parameterloze constructornaam is ' con1() .’ Twee klassenvariabelen, ‘ naam ' en ' leeftijd ,’ worden hier verklaard. Op het moment van declareren van de objectvariabele ' obj ,' wordt de constructor aangeroepen en wordt een bepaald bericht afgedrukt. Daarna worden twee waarden toegekend in de klassevariabelen en later afgedrukt met de 'Obj' object.
openbaar klascon1{// variabelen declareren
Snaar naam;
intleeftijd;
//Parameterloze constructor
con1() {
Systeem .uit.println('Constructeur wordt gebeld.');
// Initialiseer de variabelen
naam= 'Fahim Reza';
leeftijd= 30;
}
//main() methode
openbaar statisch leegtehoofd( Snaar []argumenten) {
//Maak een object
con1 obj= nieuwecon1();
//Druk de waarden van de objecteigenschappen af
Systeem .uit.afdrukken('De leeftijd van ' +obj.naam + ' is ' +obj.leeftijd);
}
}
Uitgang:
De volgende afbeelding toont de uitvoer van de code. De constructor wordt aangeroepen op het moment van het maken van het object en het bericht Constructor heet wordt afgedrukt. De waarden van ‘ naam ' en ' leeftijd ' worden toegewezen aan de binnenkant van de constructor. De waarden van deze variabelen worden later afgedrukt.
Voorbeeld 2: Maak een geparametriseerde constructor
De volgende code berekent het totale salaris van een werknemer op basis van het basissalaris en drukt de overige gegevens van die werknemer af naast het berekende salaris. Hier worden zeven klassevariabelen gedeclareerd. De bouwer, genaamd ‘ con2() ,' heeft drie parameters. De eerste twee parameters nemen de tekenreekswaarden in de ' naam ' en ' na ’ parameters, en de derde parameter krijgt de numerieke waarde in de ‘ basis ' parameter. De waarden van deze parameters worden doorgegeven op het moment dat het object wordt gemaakt. De constructor initialiseert de klassevariabelen met deze waarden en berekent de andere waarden op basis van de waarde van de ' basis ' parameter. Vervolgens worden de naam, functie en salaris van de werknemer afgedrukt.
openbaar klascon2{// Variabelen declareren
Snaar naam;
Snaar na;
intBasis;
dubbeleHuur;
dubbeleMedisch;
dubbeleVervoer;
dubbeleSalaris;
//Geparameteriseerde constructor
con2( Snaar naam, Snaar na,intbasis) {
dit.naam =naam;
dit.na =na;
dit.Basis =basis;
dit.Huur =basis*0.3;
dit.Medisch =basis*0.2;
dit.Vervoer =basis*0.1;
Salaris=basis+Huur+Medisch+Vervoer;
}
//main() methode
openbaar statisch leegtehoofd( Snaar []argumenten) {
//Maak een object
con2 obj= nieuwecon2('Mir Sabbir','Accountant',65000);
//Druk de waarden van de objecteigenschappen af
Systeem .uit.afdrukken('Naam werknemer: ' +obj.naam + 'N' + 'Na: '+obj.na +
'N' + 'Salaris: TK'+obj.Salaris);
}
}
Uitgang:
De volgende afbeelding toont de uitvoer van de code. Hier worden de naam, functie en basissalaris van de werknemer vermeld in de verklaring van objectcreatie. Het totale salaris, de naam en de functie worden hier afgedrukt.
Voorbeeld 3: Constructor Chaining maken
Het is belangrijk om te weten over de overervingsfunctie van objectgeoriënteerd programmeren om het concept van constructor-chaining te begrijpen. Wanneer een nieuwe klasse wordt gemaakt door een andere klasse te erven, wordt dit overerving genoemd. In dit geval zijn alle eigenschappen van de bovenliggende of basisklasse toegankelijk vanuit de onderliggende of afgeleide klasse. Wanneer een object van de onderliggende klasse wordt gemaakt, roept het automatisch de constructor van de bovenliggende klasse aan voordat het zijn eigen constructor aanroept. De ' Super() ’ wordt in andere talen gebruikt om de bovenliggende constructor aan te roepen, maar de Java-compiler roept deze methode automatisch aan. Het op deze manier gebruiken van constructors wordt constructor-chaining genoemd en dit proces wordt in dit voorbeeld getoond. Hier is de naam van de bovenliggende klasse ' ouder ’ en de naam van de kindklasse is ‘ con3 .' Er is een andere methode genaamd ' combineren() ' in de onderliggende klasse die de waarden combineert die zijn toegewezen in de bovenliggende en onderliggende constructors.
klasouder{// Declareer variabele
Snaar strVal;
// Bovenliggende constructor
ouder(){
Systeem .uit.println('Ouderconstructeur heet');
strVal= 'Ik hou van ';
}
}
openbaar klascon3strekt zich uitouder{
// Declareer variabele
Snaar kindStrVal;
//Kinderconstructeur
con3(){
Systeem .uit.println('Kinderconstructeur heet');
kindStrVal=strVal+ 'Java Programmeren';
}
//Een andere methode om strings te combineren
Snaar combineren()
{
opbrengst dit.kindStrVal;
}
//main() methode
openbaar statisch leegtehoofd( Snaar []argumenten) {
//Maak een object
con3 obj= nieuwecon3();
//Druk de waarden van de objecteigenschappen af
Systeem .uit.afdrukken(obj.combineren());
}
}
Uitgang:
De volgende afbeelding toont de uitvoer van de code. Het eerste bericht wordt afgedrukt vanuit de bovenliggende constructor, terwijl het tweede bericht wordt afgedrukt vanuit de onderliggende constructor. Het laatste bericht wordt afgedrukt door de ‘ combineren() ’ methode.
Conclusie
Het concept van de constructor en het gebruik van verschillende constructors worden in deze tutorial uitgelegd aan de hand van eenvoudige Java-codevoorbeelden die beginnende gebruikers kunnen volgen. Hopelijk hebben deze voorbeelden u geholpen om de basisprincipes van de Java-constructor te begrijpen.