Recursive constructor call in Java

Recursive constructor call is a compile-time error that occurs when a constructor calls itself. It's similar to recursion, where a method calls itself as many times as needed. A method that calls itself is called a recursive method, and a constructor that calls itself is called a recursive constructor.

In this article, we will learn about recursive constructor calling errors in Java through a few examples.

Recursive constructor call

Constructor

It is very similar to a method, but the difference is that methods define the behavior of objects, while constructors are used to initialize these objects. We can give the method any name we choose, but the constructor must be the same as the class name. Furthermore, methods can return a value, but constructors do not return any value because they cannot have any return type.

When the user does not create any constructor, the Java compiler will automatically create a constructor (we call it the default constructor).

Example 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
   }
}

Output

I am constructor

Despite the similarities between constructors and methods, Java does not allow recursive constructors. This is a bad programming practice.

Example 2

The following example illustrates a recursive constructor call error.

Here we will create a class and define its constructor and two parameters. We will then call the same constructor inside its body.

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

Output

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

Example 3

Example 3

In the following example, we will try to define an object inside the constructor to check if Java allows creation of objects inside the constructor.

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

Output

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)

We encountered a StackOverflowError error because creating an object inside a constructor results in an infinite loop of object creation.

Example 4

Example 4

The following example demonstrates that it is legal to call a constructor within another constructor.

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

Output

Constructor calling another Constructor

in conclusion

Java does not allow recursion of constructors, so this programming practice should obviously be avoided. In this article, we try to explain recursive constructors, starting with a discussion of constructors. Additionally, we found another error called StackOverflowError which was caused due to infinite loop.

The above is the detailed content of Recursive constructor call in Java. For more information, please follow other related articles on the PHP Chinese website!