Inleiding tot Constructor in Java
Constructors in Java zijn speciale soorten methoden die worden gebruikt om de objecten van de klasse te initialiseren. Constructors worden opgeroepen op het moment dat de klasse een object maakt. Net als methoden, hoewel ze een set regels code bevatten, verschillen ze er behoorlijk van. Constructors hebben dezelfde naam als de Java-klasse, maar hebben geen retourtype. In Java, een nieuw () sleutelwoord dat wordt gebruikt om een object te maken en telkens wanneer een nieuw object wordt gemaakt en een constructor wordt aangeroepen. De constructor wordt aangeroepen nadat het geheugen aan het object is toegewezen. Op het moment van het maken van objecten worden constructors gebruikt om de waarden van klassenvariabelen te initialiseren naar standaardwaarden of de gewenste waarden.
Als de gebruiker geen constructor in het programma maakt, maakt Java er zelf een standaardconstructor voor en wijst standaardwaarden toe aan de verschillende objecten, zoals de numerieke standaardwaarde is 0, voor een teken ('\ 0') en referentievariabelen als null . Net als methoden kunnen constructors overbelast zijn, dat wil zeggen dat een enkele klasse veel constructors kan hebben als ze allemaal een unieke handtekening hebben.
De basissyntaxis van Constructor in Java wordt hieronder gegeven:
Syntaxis
public class Student() // name of the class
(
. . . .
. . . .
. . . .
Student() // this is Constructor with the same name of class
(
. . .
. . .
)
new Student(); // object creation and value initialization
)
In de bovenstaande syntaxis is Student () de naam van de constructor die hetzelfde is als de naam van de klasse en de objecten in Java worden gemaakt met het trefwoord new.
Hoe werkt Constructor in Java?
Laten we een voorbeeld nemen dat hieronder wordt gegeven om de werking van Constructors op Java te begrijpen:
Code
public class Student()
(
int rollno;
String name;
Student(int rollno, String name)
(
this.rollno = rollno;
this.name = name;
)
public static void main(String() args)
(
Student st = new Student(12, 'Ananya');
System.out.println(“Student name = ”+ st.name + “Student rollno = ”+st.rollno);
)
)
uitgang
In het bovenstaande voorbeeld hebben we instantievariabelen (klassenvariabelen). Roll no en name en st Is de naam van het object gemaakt van de klas Student. Wanneer het object st wordt gemaakt, roept het de constructor Student op en initialiseert de klassenvariabelen met de rollno-waarde 12 en naam als 'Ananya', anders worden standaardwaarden zoals 0 voor rollno en null voor de naam toegewezen aan de variabelen. Vandaar dat na het toewijzen van de waarden en het afdrukken ervan, de studentnaam wordt afgedrukt als Ananya en Student rollno als 12.
Soorten constructeurs in Java
Er zijn 2 soorten constructors in Java op basis van parameters:
1. Niet-geparametriseerde / geen argumenten Constructor
Als we geen argumenten doorgeven in de constructor, staat die constructor bekend als een niet-geparametriseerde of geen-argument constructor. Wanneer de programmeur geen constructor in het Java-programma definieert, voegt de Java-compiler zelf een constructor toe, de zogenaamde standaardconstructor die standaardwaarden aan het object biedt, zoals 0, null, enz. De standaardconstructor is geen speciaal type constructor maar valt in de categorie geen argumenten constructor.
Voorbeeld (standaardconstructor)
Code
public class Hello()
(
String name;
void display() //method to display name the value of variables
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Output:
In het bovenstaande voorbeeld is dit geen constructor die door de programmeur wordt gedefinieerd, dus de compiler behandelt dit programma als:
Code
public class Hello()
(
String name;
Hello() //default constructor created by compiler
(
name = null
)
void display()
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Voorbeeld (niet-geparametriseerde constructor)
Code
public DemoProgram() // class
(
DemoProgram() // constructor with no arguments
(
System.out.println(“Hello this is just an example of no-arg constructor”);
)
public static void main(String() args)
(
new DermoProgram();
)
)
Output:
Net als in het bovenstaande voorbeeld worden er voor de constructor DemoProgram () geen argumenten doorgegeven, alleen het bericht wordt afgedrukt en daarom staat het bekend als No-argument constructor.
2. Geparametriseerde constructor
Geconfigureerde constructors zijn die constructors waarin we de argumenten of parameters doorgeven. In deze constructor worden waarden doorgegeven op het moment dat het object wordt gemaakt.
Voorbeeld (geparametriseerde constructors)
Code
public class Animal()
(
int legs;
String sound;
Animal(int legs, String sound) // parameterized constructor
(
this.legs = legs; // values with get initialize of what is passed while object crea-this.sound = sound; // tion, ie (4, “bow bow”)
)
void display() // method to display the values
(
System.out.println(“Legs are ”+legs+“Sound is ”+sound);
)
)
class AnimalPlanet()
(
Public static void main(String() args)
(
Animal an = new Animal(4, “bow bow”);
an.display();
)
)
Output:
In het bovenstaande voorbeeld is waarde 4 toegewezen aan de poten en de string 'bow bow' is toegewezen aan het geluid in constructor Animal. Dus wanneer de methode-weergave wordt aangeroepen, worden beide waarden in de uitvoer afgedrukt.
Belangrijke punten om te onthouden
- Elke klasse heeft een constructor, of de programmeur het maakt of niet.
- De constructornaam moet hetzelfde zijn als de klassenaam.
- De constructor heeft geen retourtype, in tegenstelling tot methoden.
- dit sleutelwoord () en super () moeten de eerste instructie in een constructor zijn.
- Net als methoden kunnen constructeurs overbelast raken.
- Constructeurs kunnen niet worden opgeheven.
- De ene constructor kan een andere constructor van dezelfde klasse aanroepen met het trefwoord this ().
- Toegangsspecificaties / modificatoren kunnen worden toegepast vóór de naam van de constructor om het bereik ervan in een klasse aan te geven.
- In Java kan een constructor nooit statisch, definitief, abstract en gesynchroniseerd zijn.
Conclusie
Constructeurs spelen een belangrijke rol als het gaat om het werken met Java-programmeertaal. Men moet de volledige concepten van Constructor begrijpen, verschillende typen Constructors, Constructor Chaining, het sleutelwoord super () dat wordt gebruikt om de bovenliggende constructor aan te roepen om volgens het specifieke scenario te werken. Hoewel het werken met constructors in Java heel gemakkelijk is, zoals het werken met methoden, maar er zijn weinig specifieke punten voor constructors die grondig moeten worden geleerd.
Aanbevolen artikel
Dit is een gids voor de constructeur in Java. Hier bespreken we hoe de constructor in Java werkt, samen met de typen en voorbeelden met de juiste code-implementatie. u kunt ook onze voorgestelde artikelen doornemen voor meer informatie-
- Constructor in JavaScript en typen
- Inleiding tot Constructor in Python
- Constructor in C ++ en typen
- Constructor in PHP (voorbeelden)