Appel de constructeur récursif en Java

L'appel récursif du constructeur est une erreur de compilation qui se produit lorsqu'un constructeur s'appelle lui-même. C'est similaire à la récursivité, où une méthode s'appelle autant de fois que nécessaire. Une méthode qui s’appelle elle-même est appelée méthode récursive, et un constructeur qui s’appelle est appelé constructeur récursif.

Dans cet article, nous découvrirons les erreurs d'appel récursif des constructeurs en Java avec quelques exemples.

Appel de constructeur récursif

Constructeur

C'est très similaire aux méthodes, mais la différence est que les méthodes définissent le comportement des objets, tandis que les constructeurs sont utilisés pour initialiser ces objets. Nous pouvons donner à la méthode le nom de notre choix, mais le constructeur doit être le même que le nom de la classe. De plus, les méthodes peuvent renvoyer une valeur, mais les constructeurs ne renvoient aucune valeur car ils ne peuvent avoir aucun type de retour.

Lorsque l'utilisateur ne crée aucun constructeur, le compilateur Java crée automatiquement un constructeur (nous l'appelons le constructeur par défaut).

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

Sortie

I am constructor

Malgré les similitudes entre les constructeurs et les méthodes, Java n'autorise pas les constructeurs récursifs. C'est une mauvaise pratique de programmation.

Exemple 2

L'exemple suivant illustre une erreur d'appel récursif du constructeur.

Ici, nous allons créer une classe et définir son constructeur et deux paramètres. Nous appellerons ensuite le même constructeur à l’intérieur de son corps.

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

Sortie

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

La traduction chinoise de

Exemple 3

est :

Exemple 3

Dans l'exemple suivant, nous allons essayer de définir un objet à l'intérieur du constructeur pour vérifier si Java autorise la création d'objets à l'intérieur du constructeur.

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

Sortie

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)

Nous obtenons une StackOverflowError car la création d'un objet à l'intérieur d'un constructeur entraîne une boucle infinie de création d'objet.

La traduction chinoise de

Exemple 4

est :

Exemple 4

L'exemple suivant démontre qu'il est légal d'appeler un constructeur au sein d'un autre constructeur.

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

Sortie

Constructor calling another Constructor

Conclusion

Java ne permet pas la récursivité des constructeurs, cette pratique de programmation est donc évidemment à éviter. Dans cet article, nous essayons d'expliquer les constructeurs récursifs, en commençant par une discussion sur les constructeurs. De plus, nous avons trouvé une autre erreur appelée StackOverflowError qui était due à une boucle infinie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!