Java-constructors gebruiken: een eenvoudige handleiding

Een Java-constructor maakt een nieuw exemplaar van een reeds gedefinieerd object. In dit artikel wordt besproken hoe u Java-constructormethoden kunt gebruiken om een ​​persoonsobject te maken.

Notitie: Voor dit voorbeeld moet u twee bestanden in dezelfde map maken: Persoon.java definieert de klasse Persoon, en PersonExample.java bevat de belangrijkste methode waarmee persoonsobjecten worden gemaakt.

Laten we beginnen met het maken van een Persoonsklasse met vier privévelden: voornaam, achternaam, adres en gebruikersnaam. Deze velden zijn privévariabelen en samen vormen hun waarden de toestand van een object. We hebben ook de eenvoudigste constructormethoden toegevoegd:

 openbare klasse persoon {
private String voornaam;
private String lastName;
privé String-adres;
private String gebruikersnaam;
// De constructormethode
publieke persoon ()
{
}
}

De constructormethode is vergelijkbaar met elke andere openbare methode, behalve dat deze dezelfde naam heeft als de klasse en geen waarde kan retourneren. Het kan geen, een of meer parameters bevatten.

Momenteel doet onze constructormethode helemaal niets en het is een goed moment om na te gaan wat dit betekent voor de begintoestand van het Person-object. Als we de dingen hebben gelaten zoals ze zijn of we hebben geen constructormethode opgenomen in onze klasse Persoon (in Java u kunt een klasse zonder één definiëren), dan zouden de velden geen waarden hebben - en we willen zeker dat onze persoon een naam en adres heeft, evenals andere kenmerken. Als u denkt dat de kans bestaat dat uw object niet wordt gebruikt zoals u verwacht en dat de velden mogelijk niet worden geïnitialiseerd wanneer het object wordt gemaakt, definieer ze dan altijd met een standaardwaarde:

 openbare klasse persoon {
private String firstName = "";
private String lastName = "";
private String address = "";
private String gebruikersnaam = "";
// De constructormethode
publieke persoon ()
{
}
}

Normaal gesproken zouden we, om ervoor te zorgen dat een constructormethode nuttig is, deze zodanig ontwerpen dat er parameters worden verwacht. De waarden die door deze parameters worden doorgegeven, kunnen worden gebruikt om de waarden van de privévelden in te stellen:

 openbare klasse persoon {
private String voornaam;
private String lastName;
privé String-adres;
private String gebruikersnaam;
// De constructormethode
public Person (String personFirstname, String personLastName, String personAddress, String personUsername)
{
firstName = personFirstName;
lastName = personLastName;
adres = personAddress;
gebruikersnaam = personUsername;
}
// Een methode om de toestand van het object op het scherm weer te geven
openbare leegte displayPersonDetails ()
{
System.out.println ("Naam:" + voornaam + "" + achternaam);
System.out.println ("Adres:" + adres);
System.out.println ("Gebruikersnaam:" + gebruikersnaam);
}
}

Onze constructormethode verwacht nu dat de waarden van vier strings worden doorgegeven. Ze worden vervolgens gebruikt om de begintoestand van het object in te stellen. We hebben ook een nieuwe methode toegevoegd, genaamd displayPersonDetails () zodat we de staat van het object kunnen zien nadat het is gemaakt.

In tegenstelling tot andere methoden van een object, moet de constructormethode worden aangeroepen met het trefwoord "nieuw":

 openbare klasse PersonExample {
openbare statische leegte main (String [] args) {
Persoon dave = nieuwe persoon ("Dave", "Davidson", "12 Main St.", "DDavidson");
dave.displayPersonDetails ();
}
}

Dit is wat we hebben gedaan:

1. Om de nieuwe instantie van het Person-object te maken, definiëren we eerst een variabele van het type Person die het object zal bevatten. In dit voorbeeld hebben we het genoemd Dave.
2. Aan de andere kant van het gelijkteken noemen we de constructormethode van onze klasse Person en geven we deze vier tekenreekswaarden door. Onze constructormethode neemt deze vier waarden en stelt de begintoestand van het Person-object in op: firstName = "Dave", lastName = "Davidson", address = "12 Main St", gebruikersnaam = "DDavidson".

Merk op hoe we zijn overgeschakeld naar de Java-hoofdklasse om het Person-object aan te roepen. Wanneer u met objecten werkt, zullen programma's zich uitstrekken meerdere .java-bestanden. Zorg ervoor dat u ze in dezelfde map opslaat. Om het programma te compileren en uit te voeren, compileert en voert u eenvoudig Java uit hoofdklasse bestand (d.w.z. PersonExample.java). De Java-compiler is slim genoeg om te beseffen dat u de Persoon.java bestand omdat het kan zien dat u het in de klasse PersonExample hebt gebruikt.

De Java-compiler raakt in de war als de parameters van de constructormethode dezelfde namen hebben als de privévelden. In dit voorbeeld kunt u zien dat we ze hebben onderscheiden door de parameters vooraf te laten gaan met het woord 'persoon'. Het is vermeldenswaard dat er een andere manier is. We kunnen in plaats daarvan het trefwoord "this" gebruiken:

 // De constructormethode
publieke persoon (String voornaam, String achternaam, String adres, String gebruikersnaam)
{
this.firstName = firstName;
this.lastName = lastName;
this.address = adres;
this.username = gebruikersnaam;
}

Het trefwoord "this" vertelt de Java-compiler dat de variabele waaraan de waarde moet worden toegewezen, de variabele is die wordt gedefinieerd door de klasse, niet de parameter. Het is een kwestie van programmeerstijl, maar deze methode helpt ons constructorparameters te definiëren zonder meerdere namen te hoeven gebruiken.

Bij het ontwerpen van uw objectklassen bent u niet beperkt tot het gebruik van slechts één constructormethode. U kunt besluiten dat er een aantal manieren is waarop een object kan worden geïnitialiseerd. De enige beperking bij het gebruik van meer dan één constructormethode is dat de parameters moeten verschillen.

Stel je voor dat op het moment dat we het Person-object maken, we de gebruikersnaam misschien niet kennen. Laten we een nieuwe constructormethode toevoegen die de status van het Person-object instelt met alleen de voornaam, achternaam en adres:

 openbare klasse persoon {
private String voornaam;
private String lastName;
privé String-adres;
private String gebruikersnaam;
// De constructormethode
publieke persoon (String voornaam, String achternaam, String adres, String gebruikersnaam)
{
this.firstName = firstName;
this.lastName = lastName;
this.address = adres;
this.username = gebruikersnaam;
}
// De nieuwe constructormethode
public Person (String voornaam, String achternaam, String adres)
{
this.firstName = firstName;
this.lastName = lastName;
this.address = adres;
this.username = "";
}
// Een methode om de toestand van het object op het scherm weer te geven
openbare leegte displayPersonDetails ()
{
System.out.println ("Naam:" + voornaam + "" + achternaam);
System.out.println ("Adres:" + adres);
System.out.println ("Gebruikersnaam:" + gebruikersnaam);
}
}

Merk op dat de tweede constructormethode ook "Persoon" wordt genoemd en ook geen waarde retourneert. Het enige verschil tussen het en de eerste constructormethode zijn de parameters - deze keer verwacht het alleen drie tekenreekswaarden: voornaam, achternaam en adres.

We kunnen nu persoonobjecten op twee verschillende manieren maken:

 openbare klasse PersonExample {
openbare statische leegte main (String [] args) {
Persoon dave = nieuwe persoon ("Dave", "Davidson", "12 Main St.", "DDavidson");
Persoon jim = nieuwe persoon ("Jim", "Davidson", "15 Kings Road");
dave.displayPersonDetails ();
jim.displayPersonDetails ();
}
}

Persoon Dave wordt gemaakt met een voornaam, achternaam, adres en gebruikersnaam. Persoon Jim, krijgt echter geen gebruikersnaam, d.w.z. de gebruikersnaam is de lege string: gebruikersnaam = "".

Constructormethoden worden alleen aangeroepen wanneer een nieuw exemplaar van een object wordt gemaakt. Ze:

• Moet dezelfde naam hebben als de klasse
• Geef geen waarde terug
• Kan geen, een of veel parameters
• Kan meer dan één nummer hebben, zolang elke constructormethode een andere set parameters heeft
• Kunnen hebben parameternamen hetzelfde als de privévelden, zolang het trefwoord "this" wordt gebruikt
• Worden aangeroepen met het "nieuwe" trefwoord