Rekursiver Konstruktoraufruf in Java

Rekursiver Konstruktoraufruf ist ein Fehler bei der Kompilierung, der auftritt, wenn sich ein Konstruktor selbst aufruft. Es ähnelt der Rekursion, bei der sich eine Methode so oft wie nötig aufruft. Eine Methode, die sich selbst aufruft, wird als rekursive Methode bezeichnet, und ein Konstruktor, der sich selbst aufruft, wird als rekursiver Konstruktor bezeichnet.

In diesem Artikel erfahren Sie anhand einiger Beispiele etwas über rekursive Konstruktoraufruffehler in Java.

Rekursiver Konstruktoraufruf

Konstrukteur

Es ist Methoden sehr ähnlich, der Unterschied besteht jedoch darin, dass Methoden das Verhalten von Objekten definieren, während Konstruktoren zum Initialisieren dieser Objekte verwendet werden. Wir können der Methode einen beliebigen Namen geben, aber der Konstruktor muss mit dem Klassennamen identisch sein. Darüber hinaus können Methoden einen Wert zurückgeben, Konstruktoren geben jedoch keinen Wert zurück, da sie keinen Rückgabetyp haben können.

Wenn der Benutzer keinen Konstruktor erstellt, erstellt der Java-Compiler automatisch einen Konstruktor (wir nennen ihn den Standardkonstruktor).

Beispiel 1

public class Cnst { // class name
   Cnst() { 
     // constructor 
     System.out.println("I am constructor");
   }
   public static void main(String[] args) {
     Cnst obj = new Cnst();  
     // calling the Constructor
   }
}

Ausgabe

I am constructor

Trotz der Ähnlichkeiten zwischen Konstruktoren und Methoden erlaubt Java keine rekursiven Konstruktoren. Dies ist eine schlechte Programmierpraxis.

Beispiel 2

Das folgende Beispiel veranschaulicht einen Fehler beim Aufruf eines rekursiven Konstruktors.

Hier erstellen wir eine Klasse und definieren ihren Konstruktor und zwei Parameter. Anschließend rufen wir denselben Konstruktor innerhalb seines Körpers auf.

public class Cart {
   String item;
   double price;
   Cart(String item, int price) { // constructor
     this(item, price); // constructor is calling itself
	// this keyword shows these variables belong to constructor
     this.item = item; 
     this.price = price;
   }
   public static void main(String[] args) {
     Cart obj = new Cart("Bread", 15); // creating object
     System.out.println("Constructor calling another Constructor");
   }
}

Ausgabe

Cart.java:4: error: recursive constructor invocation
Cart(String item, int price) { // constructor
   ^
1 error

Die chinesische Übersetzung von

Beispiel 3

lautet:

Beispiel 3

Im folgenden Beispiel werden wir versuchen, ein Objekt innerhalb des Konstruktors zu definieren, um zu prüfen, ob Java die Erstellung von Objekten innerhalb des Konstruktors zulässt.

public class Cart {
   String item;
   double price;
   Cart(String item, int price) { 
   // constructor
	// this keyword shows these variables belong to constructor
     this.item = item; 
     this.price = price;
     Cart obj2 = new Cart("Milk", 55); 
     // creating object
   }
   public static void main(String[] args) {
     Cart obj1 = new Cart("Bread", 15); 
     // creating another object
     System.out.println("Constructor calling another Constructor");
   }
}

Ausgabe

Exception in thread "main" java.lang.StackOverflowError
	at Cart.<init>(Cart.java:9)
	at Cart.<init>(Cart.java:9)
	at Cart.<init>(Cart.java:9)
	at Cart.<init>(Cart.java:9)
	at Cart.<init>(Cart.java:9)
	at Cart.<init>(Cart.java:9)
	at Cart.<init>(Cart.java:9)

Wir erhalten einen StackOverflowError, weil das Erstellen eines Objekts innerhalb eines Konstruktors zu einer Endlosschleife der Objekterstellung führt.

Die chinesische Übersetzung von

Beispiel 4

lautet:

Beispiel 4

Das folgende Beispiel zeigt, dass es legal ist, einen Konstruktor innerhalb eines anderen Konstruktors aufzurufen.

public class Cart { 
   // class
   String item;
   double price;
   Cart(String item, int price) { 
   // first constructor
	// this keyword shows these variables belong to constructor
     this.item = item; 
     this.price = price;
   }
   public Cart (int price) { 
   // second constructor
     this(null, price); 
     // calling the 1st constructor
   }
   public static void main(String[] args) {
     Cart obj = new Cart(15); 
     // creating object
     System.out.println("Constructor calling another Constructor");
   }
}

Ausgabe

Constructor calling another Constructor

Fazit

Java erlaubt keine Rekursion von Konstruktoren, daher sollte diese Programmierpraxis natürlich vermieden werden. In diesem Artikel versuchen wir, rekursive Konstruktoren zu erklären, beginnend mit einer Diskussion der Konstruktoren. Darüber hinaus haben wir einen weiteren Fehler namens StackOverflowError gefunden, der durch eine Endlosschleife verursacht wurde.

Das obige ist der detaillierte Inhalt vonRekursiver Konstruktoraufruf in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!