Java-constructors of constructors in Java is een terminologie die wordt gebruikt om iets in onze programma's te construeren. Een constructor in Java is een speciale methode dat wordt gebruikt om objecten te initialiseren. De constructor wordt aangeroepen wanneer een object van een klasse wordt gemaakt. Het kan worden gebruikt om initiële waarden voor objectattributen in te stellen.

Wat zijn constructeurs in Java?

In Java is een Constructor een codeblok dat lijkt op de methode. Het wordt aangeroepen wanneer een exemplaar van de klasse wordt gemaakt. Op het moment dat de constructor wordt aangeroepen, wordt geheugen voor het object in het geheugen toegewezen. Het is een speciaal type methode dat wordt gebruikt om het object te initialiseren. Elke keer dat een object wordt gemaakt met het trefwoord new(), wordt er minstens één constructor aangeroepen.

Voorbeeld van Java-constructor

Hieronder vindt u de implementatie van Java Constructors:

// Java Program to demonstrate // Constructor import java.io.*; // Driver Class class Geeks {    // Constructor  Geeks()  {  super();  System.out.println('Constructor Called');  }  // main function  public static void main(String[] args)  {  Geeks geek = new Geeks();  } }>

Constructor Called>

Opmerking: Het is niet nodig om een ​​constructor voor een klasse te schrijven. Het komt omdat de Java-compiler een standaardconstructor (constructor zonder argumenten) maakt als uw klasse er geen heeft.

Hoe verschillen Java-constructors van Java-methoden?

• Constructors moeten dezelfde naam hebben als de klasse waarin deze is gedefinieerd. Dit is niet nodig voor de methode in Java.
• Constructors retourneren geen enkel type, terwijl methode(n) het retourtype or hebben leegte als er geen waarde wordt geretourneerd.
• Constructors worden slechts één keer aangeroepen op het moment dat het object wordt gemaakt, terwijl methode(s) een willekeurig aantal keren kunnen worden aangeroepen.

Laten we nu de syntaxis bedenken voor de constructor die wordt aangeroepen op het moment dat het object of de instantie wordt gemaakt.

class Geek {   .......  // A Constructor  Geek() {  }  ....... } // We can create an object of the above class // using the below statement. This statement // calls above constructor. Geek obj = new Geek();>

De eerste regel van een constructor is een aanroep naar super() of this(), (een aanroep naar een constructor van een superklasse of een overbelaste constructor), als je de aanroep naar super niet in je constructor typt compiler geeft u een niet-argumentaanroep naar super op de eerste regel van uw code. De superconstructor moet worden aangeroepen om een ​​object te maken:

Als u denkt dat uw klasse geen subklasse is, is dat in werkelijkheid het geval: elke klasse in Java is de subklasse van een klasse voorwerp zelfs als je niet zegt dat object wordt uitgebreid in je klassendefinitie.

Behoefte aan constructeurs op Java

Denk aan een doos. Als we het hebben over een box-klasse, dan zal deze enkele klassevariabelen hebben (bijvoorbeeld lengte, breedte en hoogte). Maar als het gaat om het creëren van zijn object (dat wil zeggen Box zal nu in het geheugen van de computer bestaan), kan er dan een box bestaan ​​zonder dat er een waarde is gedefinieerd voor de afmetingen ervan? Het antwoord is N O .
Constructors worden dus gebruikt om waarden toe te wijzen aan de klassevariabelen op het moment dat het object wordt gemaakt, hetzij expliciet door de programmeur, hetzij door Java zelf (standaardconstructor).

hadoop-tutorial

Wanneer Java Constructor wordt aangeroepen?

Elke keer dat een object wordt gemaakt met behulp van a nieuw() trefwoord, wordt ten minste één constructor (dit kan de standaardconstructor zijn) aangeroepen om initiële waarden toe te wijzen aan het gegevens leden van dezelfde klasse. Regels voor het schrijven van constructors zijn als volgt:

• De constructor(s) van een klasse moeten dezelfde naam hebben als de klassenaam waarin deze zich bevindt.
• Een constructor in Java kan niet abstract, definitief, statisch of gesynchroniseerd zijn.
• Toegangsmodificatoren kunnen worden gebruikt in de constructordeclaratie om de toegang te controleren, dat wil zeggen welke andere klasse de constructor kan aanroepen.

We hebben dus veruit geleerd dat constructors worden gebruikt om de status van het object te initialiseren. Leuk vinden methoden , bevat een constructor ook een verzameling instructies (d.w.z. instructies) die worden uitgevoerd op het moment dat het object wordt gemaakt.

Soorten constructeurs in Java

Dit is het juiste moment om de typen constructor te bespreken, dus in de eerste plaats worden er drie typen constructors in Java genoemd:

• Standaardconstructeur
• Geparametriseerde constructor
• Kopieer constructeur

1. Standaardconstructor in Java

Een constructor die geen parameters heeft, wordt standaard de constructor genoemd. Een standaardconstructor is onzichtbaar. En als we een constructor zonder argumenten schrijven, maakt de compiler geen standaardconstructor. Het wordt eruit gehaald. Het wordt overbelast en wordt een geparametriseerde constructor genoemd. De standaardconstructor is gewijzigd in de geparametriseerde constructor. Maar de geparametriseerde constructor kan de standaardconstructor niet wijzigen. De standaardconstructor kan impliciet of expliciet zijn. Als we niet expliciet definiëren, krijgen we een impliciete standaardconstructor. Als we handmatig een constructor schrijven, wordt de impliciete overschreven.

Voorbeeld:

// Java Program to demonstrate // Default Constructor import java.io.*; // Driver class class GFG {  // Default Constructor  GFG() { System.out.println('Default constructor'); }  // Driver function  public static void main(String[] args)  {  GFG hello = new GFG();  } }>

Default constructor>

Opmerking: De standaardconstructor levert de standaardwaarden voor het object, zoals 0, null, enz., afhankelijk van het type.

2. Geparametriseerde constructor in Java

Een constructor die parameters heeft, staat bekend als geparametriseerde constructor. Als we velden van de klasse willen initialiseren met onze eigen waarden, gebruik dan een geparametriseerde constructor.

Voorbeeld:

Java-tekenreeksopmaak

// Java Program for Parameterized Constructor import java.io.*; class Geek {  // data members of the class.  String name;  int id;  Geek(String name, int id)  {  this.name = name;  this.id = id;  } } class GFG {  public static void main(String[] args)  {  // This would invoke the parameterized constructor.  Geek geek1 = new Geek('Avinash', 68);  System.out.println('GeekName :' + geek1.name  + ' and GeekId :' + geek1.id);  } }>

GeekName :Avinash and GeekId :68>

Onthoud: retourneert de constructor een waarde?

Er zijn geen retourwaarde-instructies in de constructor, maar de constructor retourneert de huidige klasse-instantie. We kunnen ‘return’ in een constructor schrijven.

Het belangrijkste onderwerp dat nu een rol speelt, is de sterke integratie van OOPS met constructors die bekend staan ​​als constructor-overloading. Net als bij methoden kunnen we constructors overbelasten om objecten op verschillende manieren te maken. De compiler onderscheidt constructors op basis van het aantal parameters, soorten parameters en de volgorde van de parameters.

Voorbeeld:

// Java Program to illustrate constructor overloading // using same task (addition operation ) for different // types of arguments. import java.io.*; class Geek {  // constructor with one argument  Geek(String name)  {  System.out.println('Constructor with one '  + 'argument - String : ' + name);  }  // constructor with two arguments  Geek(String name, int age)  {  System.out.println(  'Constructor with two arguments : '  + ' String and Integer : ' + name + ' ' + age);  }  // Constructor with one argument but with different  // type than previous..  Geek(long id)  {  System.out.println(  'Constructor with one argument : '  + 'Long : ' + id);  } } class GFG {  public static void main(String[] args)  {  // Creating the objects of the class named 'Geek'  // by passing different arguments  // Invoke the constructor with one argument of  // type 'String'.  Geek geek2 = new Geek('Shikhar');  // Invoke the constructor with two arguments  Geek geek3 = new Geek('Dharmesh', 26);  // Invoke the constructor with one argument of  // type 'Long'.  Geek geek4 = new Geek(325614567);  } }>

Constructor with one argument - String : Shikhar Constructor with two arguments : String and Integer : Dharmesh 26 Constructor with one argument : Long : 325614567>

3. Kopieer Constructor in Java

In tegenstelling tot andere constructors wordt de kopieerconstructor doorgegeven met een ander object dat de beschikbare gegevens van het doorgegeven object naar het nieuw gemaakte object kopieert.

azuur abonnement

Opmerking: In Java is er niet zo'n ingebouwde kopieerconstructor beschikbaar zoals in andere programmeertalen zoals C++. In plaats daarvan kunnen we onze eigen kopieerconstructor maken door het object van dezelfde klasse door te geven aan de andere instantie (object) van de klasse.

Voorbeeld:

// Java Program for Copy Constructor import java.io.*; class Geek {  // data members of the class.  String name;  int id;  // Parameterized Constructor  Geek(String name, int id)  {  this.name = name;  this.id = id;  }  // Copy Constructor  Geek(Geek obj2)  {  this.name = obj2.name;  this.id = obj2.id;  } } class GFG {  public static void main(String[] args)  {  // This would invoke the parameterized constructor.  System.out.println('First Object');  Geek geek1 = new Geek('Avinash', 68);  System.out.println('GeekName :' + geek1.name  + ' and GeekId :' + geek1.id);  System.out.println();  // This would invoke the copy constructor.  Geek geek2 = new Geek(geek1);  System.out.println(  'Copy Constructor used Second Object');  System.out.println('GeekName :' + geek2.name  + ' and GeekId :' + geek2.id);  } }>

First Object GeekName :Avinash and GeekId :68 Copy Constructor used Second Object GeekName :Avinash and GeekId :68>

Om diep van binnen iets over constructors te weten te komen, zijn er twee concepten die veel worden gebruikt, zoals hieronder vermeld:

• Constructor-ketening
• Kopieer constructeur

Veelgestelde vragen over Java-constructors

1. Wat is een constructor in Java?

Een constructor in Java is een speciale methode gebruikt om objecten te initialiseren.

2. Kan een Java-constructor privé zijn?

Ja, een constructor kan privé worden verklaard. Er wordt een privéconstructor gebruikt om het maken van objecten te beperken.