java constructor class
Deze tutorial bespreekt Java Constructor, de typen en concepten zoals overbelasting van constructors en constructorketting met codevoorbeelden:
Uit onze eerdere tutorials weten we dat de instantie van een klasse een object wordt genoemd. Een object van een klasse wordt gemaakt door het sleutelwoord “nieuw” te gebruiken. Een speciale methode genaamd 'constructor' wordt aangeroepen wanneer we een object maken met een nieuw trefwoord of wanneer het object wordt geïnstantieerd.
Een constructor wordt gedefinieerd als een codeblok om het klasseobject te initialiseren. Het is identiek aan de methode, maar het is geen methode. Het kan in Java echter een 'speciale methode' worden genoemd.
Kijk hier om AZ van Java-trainingshandleidingen hier te zien.
Wat je leert:
- Java Constructor
- Gevolgtrekking
Java Constructor
Java-constructor wordt gebruikt om het zojuist gemaakte object te initialiseren. Een object heeft enkele gegevens nodig voordat het in het programma wordt gebruikt. Daarom gebruiken we constructor zodat we enkele initiële gegevens aan het object kunnen toewijzen.
Beschouw als een eenvoudig voorbeeld een klasse ABC waarvoor we een object moeten maken. Laten we een object ‘myObj’ maken voor de klasse ABC met een nieuw trefwoord.
De bovenstaande instructie maakt een object myObj. Wanneer dit object wordt gemaakt, wordt een constructor voor klasse ABC zonder argument aangeroepen (ABC () geeft aan dat er geen argumenten zijn voor de constructor). Aangezien er geen argumenten zijn opgegeven voor de bovenstaande constructor, worden de lidvelden van de myObj geïnitialiseerd naar hun standaard beginwaarden.
Bijvoorbeeld,
- Numerieke gegevenstypen zoals int worden ingesteld op 0.
- De waarde van de variabele voor het gegevenstype Char is ingesteld op een nul (‘ 0’) teken.
- Verwijzingen zijn ingesteld op nul.
In deze tutorial zullen we de constructors in detail bespreken, samen met de verschillende constructors die in Java worden gebruikt.
Hoe maak je een constructor in Java
Om een constructor in Java te maken, moeten we bepaalde regels volgen, zoals hieronder aangegeven.
- De klassenconstructor heeft dezelfde naam als die van de klasse.
- Er kan geen constructor zijn die definitief, abstract, gesynchroniseerd of statisch is. Dit komt doordat de Final werkt als een constante, abstractie die niet kan worden geïnstantieerd. Terwijl gesynchroniseerd wordt gebruikt in het geval van multi-threading, en het statische sleutelwoord wordt gebruikt op klassenniveau.
- We kunnen toegangsmodificatoren gebruiken met de constructors.
- Een constructor kan geen retourtype hebben.
Bijvoorbeeld,laten we een klasstudent als volgt definiëren:
We kunnen objecten van de bovenstaande klasse maken met behulp van het nieuwe trefwoord. Terwijl het object wordt gemaakt, kunnen we de variabelen met twee leden van deze klasse initialiseren door een constructor op te geven. Merk op dat zelfs als we geen constructor bieden en gewoon de onderstaande instructie uitvoeren,
Student student = nieuwe student ();
Toch zal Java een standaardconstructor uitvoeren die de variabelen met twee leden initialiseert naar hun systeemstandaarden. Als we nu willen dat de oorspronkelijke waarde van Student.name 'Keith' is en roll_no 27, dan kunnen we hiervoor de volgende constructormethode maken.
Wanneer we een object van de leerlingklasse maken met de onderstaande verklaring
De beginwaarden van de lidvariabelen name en roll_no zijn respectievelijk Keith en 27.
Nu een constructor is gemaakt, wanneer wordt deze aangeroepen?
Een constructor wordt elke keer aangeroepen wanneer een object wordt gemaakt met het nieuwe trefwoord, zoals in het bovenstaande geval. Zoals eerder vermeld, biedt Java, als er geen constructor is opgegeven, een standaardconstructor die wordt aangeroepen wanneer het object wordt gemaakt met het nieuwe sleutelwoord.
Constructor Voorbeeld
Het volgende programma toont een constructor-voorbeeld waarin we een eenvoudige constructor hebben zonder argumenten. Deze constructor wijst eenvoudig beginwaarden toe aan zijn lidvariabelen.
Uitgang:
Standaardconstructor in Java
De standaardconstructor wordt ook wel de lege constructor genoemd Deze constructor wordt door de Java-compiler ingevoegd in de klassencode als er geen constructor is geïmplementeerd door de programmeur. De standaardconstructor wordt ingevoegd tijdens het compileren en zal daarom alleen in het ‘.class’ -bestand verschijnen en niet in de broncode.
Beschouw de volgende Java-klasse.
bronbestand (.java) class-bestand (.class)
In de bovenstaande afbeelding toont de eerste afbeelding de broncode waarin we geen constructor hebben gespecificeerd. Dus als we deze code compileren en het .class-bestand wordt gegenereerd, kunnen we zien dat de Java-compiler een standaardconstructor heeft ingevoegd, zoals weergegeven in de aangrenzende figuur (in blauwe kleur).
Notitie:
Soms wordt een standaardconstructor gebruikt om de no-arg constructor in Java te beschrijven. Maar deze twee termen zijn in werkelijkheid verschillend. No-arg constructor is een type constructor in Java dat wordt gespecificeerd door de programmeur. De standaardconstructor is de constructor die wordt ingevoegd door de Java-compiler.
hoe swf-bestanden op Windows af te spelen
Hoewel deze twee termen door de meeste programmeurs door elkaar worden gebruikt, is het daarom raadzaam deze twee termen niet te verwarren.
Als Java een standaardconstructor invoegt en het programma variabelen heeft, krijgen deze de standaardwaarden toegewezen.
De onderstaande tabel toont de standaardwaarden van elk gegevenstype.
| Type | Standaardwaarde |
|---|---|
| char | u0000 |
| Voorwerp | Referentie null |
| boolean | false |
| byte | 0 |
| kort | 0 |
| int | 0 |
| lang | 0L |
| vlotter | 0.0f |
| dubbele | 0.0d |
Het volgende programma geeft een voorbeeld van een standaardconstructor in Java.
Uitgang:
Soorten constructeurs in Java
Er zijn twee soorten constructeurs in Java, zoals hieronder wordt weergegeven.
# 1) Constructor zonder argumenten
Een constructor zonder argumenten wordt no-args of no-argument constructor genoemd. Als we geen constructor zonder argumenten hebben, maakt de Java-compiler geen standaardconstructor voor de klasse.
Over het algemeen geldt dat als we een constructor in onze klasse definiëren, de standaardconstructor niet wordt ingevoegd door de Java-compiler.
Hieronder wordt een voorbeeld gegeven van de No-arg Constructor
Uitgang:
In dit programma hebben we een constructor zonder args geleverd. Hier drukken we enkele berichten af, inclusief de lidvariabelen. We kunnen in de uitvoer zien dat de berichten van de constructor worden weergegeven, wat aangeeft dat de constructor no-args wordt uitgevoerd.
# 2) Geparametriseerde constructor
Een constructor met parameters heeft een of meer parameters. We kunnen een geparametriseerde constructor gebruiken voor het geval we een aantal beginwaarden moeten doorgeven aan de lidvariabele van de klasse.
Uitgang:
Hier hebben we een constructor met parameters opgegeven die twee argumenten accepteert, namelijk naam en id.
Binnen de constructor worden de argumenten toegewezen als waarden aan respectievelijk de lidvariabelen name en id.
Wanneer we vervolgens in de hoofdmethode een nieuw object maken met behulp van het nieuwe trefwoord, geven we twee waarden door aan de klassenaam na een nieuw trefwoord. Dit geeft aan dat we de constructor met parameters aanroepen. Wanneer we de lidvariabelen weergeven, kunnen we zien dat ze de waarden hebben die we hebben doorgegeven tijdens het maken van het object.
Overbelaste constructeurs in Java
Nu rijst de vraag of een klasse meer dan één constructor kan hebben of kan een klasse maar één constructor hebben?
Nou, we kunnen meerdere constructeurs in een klas hebben. Een klasse kan zoveel constructors bevatten, zolang ze maar goed worden overbelast.
Dus wat wordt er precies bedoeld met de overbelasting van constructeurs?
Constructor Overloading is een mechanisme waarmee een klasse evenveel constructors kan hebben, zodat al deze constructors verschillende parameterlijsten hebben, afhankelijk van parametertypes of volgorde van parameters.
Het onderstaande programma demonstreert de Constructor Overloading.
Uitgang:
In het bovenstaande programma hebben we een klasse met drie constructors. De eerste constructor is een constructor zonder argumenten, en dan hebben we er een met elk één argument en twee argumenten. Omdat de constructor een unieke parameterlijst heeft, kunnen we zeggen dat de constructors overbelast zijn.
‘This ()’ Constructor in Java
In een klasse met meerdere constructors, wat als we de ene constructor van een andere constructor in deze klasse willen aanroepen?
Voor dit doel gebruiken we het sleutelwoord “dit” binnen de constructor van waaruit we een andere constructor willen aanroepen.
Dus als een klasse meerdere constructors heeft, een no-arg constructor en een constructor met parameters, gebruiken we het trefwoord ‘this’ om een constructor met parameters aan te roepen vanuit de constructor no-args. Dit wordt ook wel 'Expliciete aanroep van constructor'.
Waarom hebben we dit zoekwoord nodig?
We hebben het nodig omdat het expliciet aanroepen van constructors niet rechtstreeks mogelijk is door alleen de constructornaam te gebruiken.
Aandachtspunten:
- Het sleutelwoord ‘this’ zou de eerste instructie in de aanroepende constructor moeten zijn.
- Als een constructor het sleutelwoord “dit” heeft, kan het geen “super” hebben. Dit betekent dat de constructor super of dit kan hebben.
Uitgang:
In het bovenstaande programma hebben we een ‘TestClass’ met twee constructeurs. We noemen dit ('SoftwareTestingHelp') vanuit de constructor no-args. Dit is de expliciete aanroep van de geparameteriseerde constructor.
Kopieer Constructor in Java
We kennen de kopieerconstructor in C ++. De kopieerconstructor is een constructor die een objectreferentie als argument heeft en een nieuw object wordt gemaakt met behulp van de gegevens van het referentieobject.
C ++ biedt een standaard kopieerconstructor als deze niet in het programma wordt geleverd.
Java biedt ook ondersteuning voor de kopieerconstructor, maar het biedt geen standaard kopieerconstructor.
Het volgende Java-programma demonstreert de kopieerconstructor aan de hand van het klassieke voorbeeld van complexe getallen met reële en imaginaire componenten.
Uitgang:
Het bovenstaande programma heeft een ‘Complex’ klasse met een constructor met parameters en een constructor voor kopiëren. In de hoofdmethode maken we eerst een object c1 met behulp van een geparametriseerde constructor. Gebruik vervolgens de onderstaande verklaring,
De bovenstaande instructie roept de kopieerconstructor aan terwijl de referentie c1 wordt doorgegeven aan de constructor terwijl een nieuw object c2 wordt gemaakt.
Constructor Chaining in Java
Constructorketting is een proces waarbij de ene constructor een andere constructor van dezelfde klasse aanroept.
Zelfs als we hebben geërfd van een basisklasse, wordt de constructor van de basisklasse als eerste aangeroepen wanneer het onderliggende klasseobject wordt gemaakt. Dit is ook een voorbeeld van constructorketting.
In Java kan Constructor-chaining worden bereikt met behulp van twee benaderingen:
- Binnen dezelfde klas : Als we een constructor aanroepen vanuit een andere constructor van dezelfde klasse, dan kunnen we dit () sleutelwoord gebruiken.
- Vanaf basisklasse: Een constructor van de basisklasse kan worden aangeroepen door die van de afgeleide klasse met behulp van het super sleutelwoord.
Waarom hebben we constructorketting nodig?
beste dvd-kopie-software windows 10
Als we meerdere taken in onze constructor willen uitvoeren, verdelen we in plaats van elke taak in één constructor uit te voeren, de taken in meerdere constructors, en dan roepen we constructors van elkaar op, wat resulteert in constructor chaining.
Hieronder staan enkele van de regels die we moeten volgen tijdens het uitvoeren van constructorketting.
- Constructorketting wordt in willekeurige volgorde gedaan en levert dezelfde resultaten op.
- De uitdrukking ‘dit’ zoekwoord moet de eerste uitdrukking in de constructor zijn.
- We zouden minstens één constructor moeten hebben zonder dit sleutelwoord.
Als we een overerving in ons programma hebben, kunnen we ook constructor chaining uitvoeren. In dit geval roept de subklasse de constructor van de basisklasse aan. Door dit te doen, begint het maken van subklasse-objecten met de initialisatie van de superklasse-leden.
Nu zullen we de constructorketting in Java implementeren met behulp van de bovenstaande benaderingen.
# 1) Constructor Chaining binnen dezelfde klasse
Uitgang:
Zoals eerder vermeld, bereiken we constructorketting binnen dezelfde klasse met ‘dit’ zoekwoord. In het bovenstaande programma hebben we drie constructors en we roepen de ene constructor van de andere op met ‘dit’ trefwoord.
Van basisklasse
Wanneer een klasse een andere klasse erft, wordt de constructor van de bovenliggende klasse als eerste aangeroepen wanneer we een object van een afgeleide klasse maken dat constructorketting is.
Als we de constructor van de basisklasse expliciet willen aanroepen in de afgeleide klasse, dan moeten we hiervoor het sleutelwoord “super” gebruiken. Met behulp van het trefwoord ‘super’ kunnen we de constructors van de superklasse in de overervingshiërarchie aanroepen totdat we de hoogste klasse bereiken.
Het onderstaande programma demonstreert het gebruik van een ‘super’ -zoekwoord voor constructorketting.
Uitgang:
In het bovenstaande programma roepen we de geparameteriseerde constructor van de afgeleide klasse aan met de waarde “Java”. Deze constructor heeft op zijn beurt een aanroep naar de constructor van de basisklasse met behulp van 'super (naam);' die de geparameteriseerde constructor van de basisklasse uitvoert.
Veel Gestelde Vragen
V # 1) Hoe maak je een constructor in Java?
Antwoord: We maken een constructor als een speciale methode die dezelfde naam heeft als de naam van de klasse. Een constructor kan ook geen retourtype hebben. Het kan toegangsmodificatoren hebben, maar het kan niet definitief, statisch, abstract of gesynchroniseerd zijn.
Als ABC een klasse is, kunnen we de constructor ervan definiëren als
Vraag 2) Wat is het voordeel van een constructeur in Java?
Antwoord: Met behulp van de constructor kunnen we de leden van de klasse initialiseren als het eerste op het moment dat het object wordt gemaakt. Constructor elimineert de noodzaak om de normale methoden impliciet aan te roepen.
We kunnen verschillende taken uitvoeren met betrekking tot het initialiseren, starten van taken, enz. In de constructor, aangezien constructors worden aangeroepen tijdens de fase van het maken van objecten.
V # 3) Waarom worden constructeurs gebruikt?
Antwoord: Constructors worden voornamelijk gebruikt om de leden van de klasse te initialiseren en worden aangeroepen wanneer het object van de klasse wordt gemaakt.
V # 4) Kan Constructor privé zijn?
Antwoord: Ja, we kunnen een particuliere constructeur hebben. Als de constructor privé is, kan worden voorkomen dat de klasse wordt geïnstantieerd.
V # 5) Kan Constructor definitief zijn?
Antwoord: Nee, we kunnen geen definitieve constructor hebben.
Gevolgtrekking
In deze tutorial zijn we onze discussie over constructors in Java begonnen. We hebben de basisprincipes van de constructor, het maken ervan en de te volgen regels geleerd. We hebben ook gesproken over kopieerconstructors in Java.
De standaard constructor & soorten constructors en concepten zoals constructor overloading en constructor chaining werden ingelicht met voorbeelden. Als onderdeel van deze onderwerpen zagen we ook het gebruik van ‘dit’ zoekwoord in constructeurs.
Lees de Easy Java Training Series door.
Aanbevolen literatuur
- Java Class Vs Object - Hoe klasse en object in Java te gebruiken
- Java Basics: Java Syntax, Java Class en Core Java Concepts
- Java Integer en Java BigInteger-klasse met voorbeelden
- Zelfstudie voor Java-scannerklassen met voorbeelden
- Zelfstudie voor Java-array-klassen - java.util.Arrays-klasse met voorbeelden
- Wat is Java-vector | Java Vector Class-zelfstudie met voorbeelden
- Java-interface en abstracte les met voorbeelden
- Robotklasse in Selenium WebDriver met Java