Java Konstruktor

In diesem Tutorial werden Sie durch Beispiele die Java-Konstruktoren, ihre Erstellung und Verwendung sowie verschiedene Arten von Konstruktoren kennenlernen.

Was ist ein Konstruktor?

In Java hat jede Klasse ihren eigenen Konstruktor, der automatisch aufgerufen wird, wenn ein Objekt der Klasse erstellt wird. Ein Konstruktor ähnelt einer Methode, ist aber nicht eine Methode.

einJava Methodenund Java-Konstruktoren werden durch ihren Namen und den Rückgabetyp unterschieden. Ein Konstruktor hat denselben Namen wie die Klasse und gibt nichts zurück. Zum Beispiel,

class Test {
　　　　Test() {
　　　　　　　　//Konstruktor-Body
　　　　}
}

Hier ist Test() ein Konstruktor. Es hat denselben Namen wie die Klasse und hat keinen Rückgabetyp.

class Test {
　　　　void Test() {
　　　　　　　　//　Methodenkörper
　　　　}
}

　Hier ist Test() gleich dem Namen der Klasse, aber es hat einen Rückgabetyp void. Daher ist es eine Methode und nicht ein Konstruktor.

Beispiel: Java-Konstruktor

class Main {
　　　private int x;
　　　//　Konstruktor-Body
　　　private Main(){
　　　　　　　System.out.println("Der Konstruktor wird aufgerufen");
　　　　　　　x =　5;
　　　}
　　　public static void main(String[] args){
　　　　　　　//Konstruktor wird beim Erstellen eines Objekts aufgerufen
　　　　　　　Main obj = new Main();
　　　　　　　System.out.println("Wert von x = ")　+　obj.x);
　　　}
}

Ausgabe:

Der Konstruktor wird aufgerufen
Wert von x =　5

　Im obigen Beispiel haben wir einen privaten Konstruktor namens Main(). Im main-Methode wird ein Objekt der Klasse obj erstellt.

Main obj = new Main();

　Während dieses Prozesses wird der Konstruktor aufgerufen. Daher wird der print-Befehl ausgeführt und die Variable x initialisiert.

Art des Konstruktors

In Java können Konstruktoren in3Art:

• Konstruktor ohne Parameter

• Standardkonstruktor

• Parameterkonstruktor

Konstruktor ohne Parameter

Java-Konstruktoren können Parameter haben oder nicht. Wenn ein Konstruktor keine Parameter akzeptiert, wird er als Parameterloser Konstruktor bezeichnet. Zum Beispiel,

private Constructor() {
　　　//　Konstruktor-Body
}

Beispiel für Konstruktor ohne Parameter

class Main {
　　　int i;
　　　//Konstruktor ohne Parameter
　　　private Main(){
　　　　　　　i =　5;
　　　　　　　System.out.println("Objekt erstellt und i = ")　+　i);
　　　}
　　　public　static　void　main(String[]　args)　{
　　　　　　　//Der Konstruktor wird ohne Parameter aufgerufen
　　　　　　　Main obj = new Main();
　　　}
}

Ausgabe:

Objekt erstellt und i =　5

Hier wird die Funktion Main() ohne Parameter definiert.

Haben Sie bemerkt, dass der Zugriffsmodifikator des Main() Konstruktors privat (private) ist?}

Das liegt daran, dass das Objekt aus derselben Klasse instanziert wurde. Daher kann es auf den Konstruktor zugreifen.

Wenn jedoch ein Objekt außerhalb der Klasse erstellt wird, muss der Konstruktor als public deklariert werden, um darauf zuzugreifen. Zum Beispiel:

class　Company　{
　　　　String　domainName;
　　　　//　Öffentlicher Konstruktor
　　　　public　Company(){
　　　　　　　　domainName = "oldtoolbag.com";
　　　　}
}
public class Main {
　　　　
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Objekt in einer anderen Klasse erstellen
　　　　　　　　Company companyObj = new Company();
　　　　　　　　System.out.println("Domain name = ");+　companyObj.domainName);
　　　　}
}

Ausgabe:

Domain name = oldtoolbag.com

Zusammenhängende Lektüre: Java Zugriffsmodifikatoren

Standardkonstruktor

Wenn kein Konstruktor erstellt wird, erstellt der Java-Compiler bei der Laufzeit automatisch einen leeren Konstruktor. Solcherartiger Konstruktor wird als Standardkonstruktor bezeichnet. Der Standardkonstruktor initialisiert alle nicht initialisierten Instanzvariablen mit Standardwerten.

Beispiel: Standardkonstruktor

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Aufruf des Standardkonstruktors
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = ");　+　obj.a);
　　　　　　　　System.out.println("b = ");　+　obj.b);
　　　　}
}

Ausgabe:

a = 0
b = false

Im obigen Code wurden die Variablen a und b noch nicht initialisiert. Aber wenn wir ein Objekt der Klasse erstellen, können wir im Ausgabeoutput sehen, dass diese Werte bereits mit bestimmten Werten initialisiert wurden.

　Das liegt daran, dass der Java-Compiler automatisch einen Standardkonstruktor erstellt. Der Konstruktor initialisiert die Variablen a und b mit den Standardwerten 0 und false.

Der obige Code ist äquivalent zu:

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　//Privater Konstruktor　
　　　　private DefaultConstructor() {
　　　　　　　　a = 0;
　　　　　　　　b = false;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Aufruf des Konstruktors
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = ");　+　obj.a);
　　　　　　　　System.out.println("b = ");　+　obj.b);
　　　　}
}

Ausgabe:

a = 0
b = false

Parameterisierte Konstruktoren

Ähnlich wie bei Methoden können wir Parameter an den Konstruktor übergeben. Solcherartige Konstruktoren werden als parameterisierte Konstruktoren bezeichnet. Zum Beispiel,

private Constructor (arg1arg2..., argn) {
　　　　//　Konstruktor-Body
}

Beispiel: Parameterisierter Konstruktor

class　Vehicle　{
　　　　int　wheels;
　　　　//Konstruktor, der einen einzigen Wert akzeptiert
　　　　private　Vehicle(int　wheels){
　　　　　　　　this.wheels　=　wheels;
　　　　　　　　System.out.println(wheels　+　"　wheeler　vehicle　created.");
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Aufruf des Konstruktors durch Übermittlung eines einzigen Wertes
　　　　　　　　Vehicle　v1　=　new　Vehicle(2);
　　　　　　　　Vehicle　v2　=　new　Vehicle(3);
　　　　　　　　Vehicle　v3　=　new　Vehicle(4);
　　　　}
}

Ausgabe:

2　Wheeler vehicle created.
3　Wheeler vehicle created.
4　Wheeler vehicle created.

Im obigen Beispiel haben wir einen Konstruktor namens Vehicle(). Der Konstruktor akzeptiert einen Parameter namens wheels.

Hier geben wir bei der Erstellung von Objekten Parameter an die Konstruktoren weiter. Und basierend auf diesen Parametern wird eine Ausgabe generiert.

Konstruktorüberschreibung in Java

　Wie bei der Methodenüberschreibung können wir auch in Java Konstruktoren überschreiben. Wenn Sie mit der Methodenüberschreibung nicht vertraut sind, besuchen Sie bitteJava Methodenüberladung.

Bei der Überschreibung von Konstruktoren gibt es zwei oder mehr Konstruktoren mit verschiedenen Parametern. Zum Beispiel,

class　Company　{
　　　　String　domainName;
　　　　//Konstruktor ohne Parameter
　　　　public　Company(){
　　　　　　　　this.domainName　=　"default";
　　　　}
　　　　//Konstruktor mit einem einzigen Parameter
　　　　public　Company(String　domainName){
　　　　　　　　this.domainName　=　domainName;
　　　　}
　　　　public　void　getName(){
　　　　　　　　System.out.println(this.domainName);
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Aufruf des Konstruktors ohne Parameter
　　　　　　　　Company　defaultObj　=　new　Company();
　　　　　　　　//Aufruf des Konstruktors mit einem einzigen Parameter
　　　　　　　　Company　w3codeboxObj　=　new　Company("oldtoolbag.com");
　　　　　　　　defaultObj.getName();
　　　　　　　　w3codeboxObj.getName();
　　　　}
}

Ausgabe:

default
oldtoolbag.com

Im obigen Beispiel haben wir zwei Konstruktoren: public Company() und public Company(String domainName).

Hier werden beide Konstruktoren mit verschiedenen Werten die Variable domainName initialisiert.Daher können wir den Konstruktor basierend auf den benötigten Werten aus dem main() Methode aufrufen.

Beachten Sie, dass wir den this-Schlüsselwort verwenden, um die Variablen der Klasse zu spezifizieren. Für mehr Informationen über das this-Schlüsselwort besuchen Sie bitteJava this Schlüsselwort.

Wichtige Notiz

• 　Konstruktoren werden bei der Instanziierung von Objekten implizit aufgerufen.
  

• Die zwei Regeln für die Erstellung von Konstruktoren sind:

• Der Name des Konstruktors sollte mit dem Namens des Klassen identisch sein.

• Java-Konstruktoren dürfen keine Rückgabetyp haben.

• Fehlt eine Klasse einen Konstruktor, erstellt der Java-Compiler automatisch einen Konstruktor bei der Laufzeit.Standardkonstruktor. Der Standardkonstruktor initialisiert die Instanzvariablen mit Standardwerten. Zum Beispiel wird ein int-Variable auf 0 initialisiert.

• Konstruktortyp:

• Konstruktor ohne Parameter　 - Keine Parameter akzeptierender Konstruktor

• Standardkonstruktor　 - Fehlt eine explizite Definition, erstellt der Java-Compiler automatisch einen Konstruktor.

• Parameterisierte Konstruktoren　 - Konstruktoren mit Parametern

• Konstruktoren dürfen nicht abstract, static oder final sein.
  

• Konstruktoren können überladen, aber nicht überschrieben werden.