Java 中的递归构造函数调用

---

递归构造函数调用是一个编译时错误，当构造函数调用自身时发生。它类似于递归，其中方法根据需要调用自身。调用自身的函数称为递归函数，调用自身的构造函数称为递归构造函数。

在本文中，我们将通过几个示例了解 Java 中的递归构造函数调用错误。

递归构造函数调用

构造函数

它与方法非常相似，但区别在于方法定义了对象的行为，而构造函数用于初始化这些对象。我们可以为方法提供任何我们选择的名称，但构造函数必须与类名相同。此外，方法可以返回值，但构造函数不返回值，因为它们不能有任何返回类型。

当用户没有创建任何构造函数时，Java 编译器会自动创建一个（我们称之为默认构造函数）。

示例 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
   }
}

输出

I am constructor

尽管构造函数和方法之间存在相似之处，但 Java 不允许递归构造函数。这是一种不好的编程实践。

示例 2

以下示例说明了递归构造函数调用错误。

在这里，我们将创建一个类并定义其构造函数以及两个参数。然后，我们将在其主体中调用相同的构造函数。

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");
   }
}

输出

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

示例 3

在以下示例中，我们将尝试在构造函数内部定义一个对象，以检查 Java 是否允许在构造函数内部创建对象。

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");
   }
}

输出

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)

我们得到 StackOverflowError，因为在构造函数内部创建对象会导致对象创建的无限循环。

示例 4

以下示例演示了在另一个构造函数内部调用构造函数是合法的。

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");
   }
}

输出

Constructor calling another Constructor

结论

Java 不允许构造函数的递归，因此避免这种编程实践是显而易见的。在本文中，我们首先讨论了构造函数，并试图解释递归构造函数。此外，我们还发现了另一个名为 StackOverflowError 的错误，该错误是由于无限循环引起的。