Der Konstruktor in Java wird verwendet, um eine Instanz der Klasse zu erstellen. Konstruktoren ähneln fast den Methoden, mit Ausnahme von zwei Dingen – sein Name ist der gleiche wie der Klassenname und er hat keinen Rückgabetyp. Manchmal werden Konstruktoren auch als spezielle Methoden bezeichnet, um ein Objekt zu initialisieren.
Konstruktor in Java
Immer wenn wir das Schlüsselwort new verwenden, um eine Instanz einer Klasse zu erstellen, wird der Konstruktor aufgerufen und das Objekt der Klasse zurückgegeben. Da der Konstruktor nur das Objekt zur Klasse zurückgeben kann, wird dies implizit durch die Java-Laufzeitumgebung ausgeführt und wir sollen keinen Rückgabetyp hinzufügen. Wenn wir einem Konstruktor einen Rückgabetyp hinzufügen, wird er zu einer Methode der Klasse. Auf diese Weise unterscheidet die Java-Laufzeitumgebung zwischen einer normalen Methode und einem Konstruktor. Nehmen wir an, wir haben folgenden Code in der Klasse Employee.
public Employee() {
System.out.println("Employee Constructor");
}
public Employee Employee() {
System.out.println("Employee Method");
return new Employee();
}
Hier ist der erste ein Konstruktor, beachten Sie, dass es keinen Rückgabetyp und keine Rückgabeaussage gibt. Die zweite ist eine normale Methode, in der wir erneut den ersten Konstruktor aufrufen, um eine Mitarbeiterinstanz zu erhalten und sie zurückzugeben. Es wird empfohlen, den Methodennamen nicht denselben wie den Klassennamen zu haben, da dies Verwirrung stiftet.
Arten von Konstruktoren in Java
Es gibt drei Arten von Konstruktoren in Java.
- Standardkonstruktor
- Kein-Args-Konstruktor
- Parameterisierter Konstruktor
Lassen Sie uns alle diese Arten von Konstruktoren mit Beispielprogrammen betrachten.
Standardkonstruktor in Java
Es ist nicht immer erforderlich, eine Konstruktorimplementierung im Klassencode bereitzustellen. Wenn wir keinen Konstruktor bereitstellen, bietet Java eine Standardkonstruktorimplementierung für uns zum Verwenden an. Betrachten wir ein einfaches Programm, bei dem der Standardkonstruktor verwendet wird, da wir keinen Konstruktor explizit definieren werden.
package com.journaldev.constructor;
public class Data {
public static void main(String[] args) {
Data d = new Data();
}
}
- Die einzige Aufgabe des Standardkonstruktors besteht darin, das Objekt zu initialisieren und es an den aufrufenden Code zurückzugeben.
- Der Standardkonstruktor ist immer ohne Argument und wird vom Java-Compiler nur bereitgestellt, wenn kein vorhandener Konstruktor definiert ist.
- Meistens sind wir mit dem Standardkonstruktor selbst zufrieden, da andere Eigenschaften über Getter-Setter-Methoden zugegriffen und initialisiert werden können.
Kein-Args-Konstruktor
Konstruktor ohne Argument wird als No-Args-Konstruktor bezeichnet. Es ist wie das Überschreiben des Standardkonstruktors und wird verwendet, um einige Vorinitialisierungsvorgänge wie das Überprüfen von Ressourcen, Netzwerkverbindungen, Protokollierung usw. durchzuführen. Werfen wir einen kurzen Blick auf den No-Args-Konstruktor in Java.
package com.journaldev.constructor;
public class Data {
//no-args constructor
public Data() {
System.out.println("No-Args Constructor");
}
public static void main(String[] args) {
Data d = new Data();
}
}
Jetzt, wenn wir new Data() aufrufen, wird unser No-Args-Konstruktor aufgerufen. Das folgende Bild veranschaulicht dieses Verhalten. Überprüfen Sie die Konsolenausgabe des Programms. 
Parameterisierter Konstruktor
Ein Konstruktor mit Argumenten wird als parameterisierter Konstruktor bezeichnet. Schauen wir uns das Beispiel für einen parameterisierten Konstruktor in Java an.
package com.journaldev.constructor;
public class Data {
private String name;
public Data(String n) {
System.out.println("Parameterized Constructor");
this.name = n;
}
public String getName() {
return name;
}
public static void main(String[] args) {
Data d = new Data("Java");
System.out.println(d.getName());
}
}
Konstruktorüberladung in Java
Wenn wir mehr als einen Konstruktor haben, handelt es sich um eine Konstruktorüberladung in Java. Schauen wir uns ein Beispiel für Konstruktorüberladung in einem Java-Programm an.
package com.journaldev.constructor;
public class Data {
private String name;
private int id;
//no-args constructor
public Data() {
this.name = "Default Name";
}
//one parameter constructor
public Data(String n) {
this.name = n;
}
//two parameter constructor
public Data(String n, int i) {
this.name = n;
this.id = i;
}
public String getName() {
return name;
}
public int getId() {
return id;
}
@Override
public String toString() {
return "ID="+id+", Name="+name;
}
public static void main(String[] args) {
Data d = new Data();
System.out.println(d);
d = new Data("Java");
System.out.println(d);
d = new Data("Pankaj", 25);
System.out.println(d);
}
}
Privater Konstruktor in Java
Beachten Sie, dass wir abstract, final, static und synchronized Schlüsselwörter nicht mit Konstruktoren verwenden können. Wir können jedoch Zugriffsmodifikatoren verwenden, um die Instanziierung des Klassenobjekts zu steuern. Die Verwendung von public und default Zugriff ist immer noch möglich, aber wozu dient es, einen Konstruktor privat zu machen? In diesem Fall kann keine andere Klasse eine Instanz der Klasse erstellen. Nun, ein Konstruktor wird privat gemacht, wenn wir das Singleton-Entwurfsmuster implementieren möchten. Da Java automatisch einen Standardkonstruktor bereitstellt, müssen wir explizit einen Konstruktor erstellen und ihn privat halten. Klientenklassen erhalten eine Hilfs-Static-Methode, um die Instanz der Klasse zu erhalten. Ein Beispiel für einen privaten Konstruktor für die Klasse Data ist unten angegeben.
// privater Konstruktor
private Data() {
//leerer Konstruktor für die Singleton-Musterimplementierung
//kann Code enthalten, der innerhalb der getInstance()-Methode der Klasse verwendet wird
}
Konstruktorverkettung in Java
Wenn ein Konstruktor einen anderen Konstruktor derselben Klasse aufruft, wird dies als Konstruktorverkettung bezeichnet. Wir müssen das Schlüsselwort this verwenden, um einen anderen Konstruktor der Klasse aufzurufen. Manchmal wird es verwendet, um einige Standardwerte der Klassenvariablen festzulegen. Beachten Sie, dass ein anderer Konstruktoraufruf die erste Anweisung im Codeblock sein sollte. Außerdem sollten keine rekursiven Aufrufe vorhanden sein, die eine Endlosschleife erzeugen würden. Schauen wir uns ein Beispiel für Konstruktorverkettung in einem Java-Programm an.
package com.journaldev.constructor;
public class Employee {
private int id;
private String name;
public Employee() {
this("John Doe", 999);
System.out.println("Default Employee Created");
}
public Employee(int i) {
this("John Doe", i);
System.out.println("Employee Created with Default Name");
}
public Employee(String s, int i) {
this.id = i;
this.name = s;
System.out.println("Employee Created");
}
public static void main(String[] args) {
Employee emp = new Employee();
System.out.println(emp);
Employee emp1 = new Employee(10);
System.out.println(emp1);
Employee emp2 = new Employee("Pankaj", 20);
System.out.println(emp2);
}
@Override
public String toString() {
return "ID = "+id+", Name = "+name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
I have overridden the toString() method to print some useful information about Employee object. Below is the output produced by above program.
Employee Created
Default Employee Created
ID = 999, Name = John Doe
Employee Created
Employee Created with Default Name
ID = 10, Name = John Doe
Employee Created
ID = 20, Name = Pankaj
Beachten Sie, wie ein Konstruktor aus einem anderen Konstruktor aufgerufen wird. Das wird als Konstruktorverkettungsprozess bezeichnet.
Java-Superkonstruktor
Manchmal wird eine Klasse von einer Superklasse abgeleitet. In diesem Fall können wir den Konstruktor der Superklasse mit dem Schlüsselwort super aufrufen. Schauen wir uns ein Beispiel für die Verwendung des Konstruktors der Superklasse an. Beachten Sie, dass der Aufruf des Superkonstruktors die erste Anweisung im Konstruktor der Unterklasse sein sollte. Bei der Instanziierung des Konstruktors der Unterklasse initialisiert Java zuerst die Superklasse und dann die Unterklasse. Wenn der Konstruktor der Superklasse nicht explizit aufgerufen wird, wird der Standard- oder no-args-Konstruktor von Java zur Laufzeit aufgerufen. Diese Konzepte lassen sich durch ein Beispielprogramm verdeutlichen. Nehmen wir an, wir haben zwei Klassen wie unten gezeigt.
package com.journaldev.constructor;
public class Person {
private int age;
public Person() {
System.out.println("Person Created");
}
public Person(int i) {
this.age = i;
System.out.println("Person Created with Age = " + i);
}
}
package com.journaldev.constructor;
public class Student extends Person {
private String name;
public Student() {
System.out.println("Student Created");
}
public Student(int i, String n) {
super(i); // super class constructor called
this.name = n;
System.out.println("Student Created with name = " + n);
}
}
Wenn wir jetzt ein Studentenobjekt erstellen;
Student st = new Student();
Was wird die Ausgabe sein? Die Ausgabe des obigen Codes wird sein:
Person Created
Student Created
Der Aufruf ging zum no-args-Konstruktor der Studentenklasse, da kein Superaufruf in der ersten Anweisung erfolgte, wird der no-args- oder Standardkonstruktor der Person-Klasse von Java zur Laufzeit aufgerufen. Daher die Ausgabe. Was passiert, wenn wir den parametrisierten Konstruktor der Studentenklasse verwenden, wie Student st = new Student(34, "Pankaj");, die Ausgabe wird sein:
Person Created with Age = 34
Student Created with name = Pankaj
Hier ist die Ausgabe klar, da wir den Konstruktor der Superklasse explizit aufrufen, muss Java keine zusätzliche Arbeit von ihrer Seite aus erledigen.
Java Copy Constructor
Java Copy-Konstruktor nimmt das Objekt derselben Klasse als Argument und erstellt eine Kopie davon. Manchmal benötigen wir eine Kopie eines anderen Objekts, um einige Verarbeitungen durchzuführen. Wir können dies auf folgende Weise tun:
- implementieren Klonen
- Bereitstellung einer Hilfsmethode für eine tiefe Kopie des Objekts.
- Besitz eines Kopierkonstruktors
Jetzt sehen wir uns an, wie man einen Kopierkonstruktor schreibt. Nehmen wir an, wir haben eine Klasse Früchte wie unten dargestellt.
package com.journaldev.constructor;
import java.util.ArrayList;
import java.util.List;
public class Fruits {
private List<String> fruitsList;
public List<String> getFruitsList() {
return fruitsList;
}
public void setFruitsList(List<String> fruitsList) {
this.fruitsList = fruitsList;
}
public Fruits(List<String> fl) {
this.fruitsList = fl;
}
public Fruits(Fruits fr) {
List<String> fl = new ArrayList<>();
for (String f : fr.getFruitsList()) {
fl.add(f);
}
this.fruitsList = fl;
}
}
Beachten Sie, dass Früchte(Früchte fr) eine tiefe Kopie durchführt, um die Kopie des Objekts zurückzugeben. Schauen wir uns ein Testprogramm an, um zu verstehen, warum es besser ist, einen Kopierkonstruktor zu haben, um ein Objekt zu kopieren.
package com.journaldev.constructor;
import java.util.ArrayList;
import java.util.List;
public class CopyConstructorTest {
public static void main(String[] args) {
List<String> fl = new ArrayList<>();
fl.add("Mango");
fl.add("Orange");
Fruits fr = new Fruits(fl);
System.out.println(fr.getFruitsList());
Fruits frCopy = fr;
frCopy.getFruitsList().add("Apple");
System.out.println(fr.getFruitsList());
frCopy = new Fruits(fr);
frCopy.getFruitsList().add("Banana");
System.out.println(fr.getFruitsList());
System.out.println(frCopy.getFruitsList());
}
}
Die Ausgabe des obigen Programms ist:
[Mango, Orange]
[Mango, Orange, Apple]
[Mango, Orange, Apple]
[Mango, Orange, Apple, Banana]
Bemerken Sie, dass, wenn der Kopierkonstruktor verwendet wird, sowohl das originale Objekt als auch seine Kopie nicht miteinander verbunden sind und Änderungen in einem von ihnen sich nicht in den anderen widerspiegeln werden. Das ist alles für den Konstruktor in Java.
Source:
https://www.digitalocean.com/community/tutorials/constructor-in-java