Surcharge des constructeurs et chaînage des constructeurs.

Notez que :

• Avoir un constructeur privé dans une classe indique au compilateur de ne pas fournir le constructeur sans argument par défaut.

• Les constructeurs privés ne peuvent pas être instanciés.

• this() doit être la première instruction non commentée dans un constructeur. Les commentaires n'ont pas d'importance, ils sont autorisés partout.

Qu'est-ce que la surcharge de construction ?

La surcharge de constructeur en Java fait référence à l'utilisation de plusieurs constructeurs dans une classe d'instance. Cependant, chaque constructeur surchargé doit avoir des signatures différentes. Pour que la compilation réussisse, chaque constructeur doit contenir une liste d'arguments différente.

Vous pouvez avoir plusieurs constructeurs dans la même classe à condition qu'ils aient des signatures de méthode différentes. Lors de la surcharge de méthodes, le nom de la méthode et la liste des paramètres doivent correspondre. Avec les constructeurs, le nom est toujours le même puisqu'il doit être le même que le nom de la classe. Les constructeurs doivent avoir des paramètres différents pour être surchargés.

 public class Hamster {
   private String color;
   private int weight;
   public Hamster(int weight) { // first constructor
      this.weight = weight;
      color = "brown";
   }
   public Hamster(int weight, String color) { // second constructor
      this.weight = weight;
      this.color = color;
   }
}

Dans ce qui précède, l'un des constructeurs prend un seul paramètre int. L'autre prend un int et une String. Ces listes de paramètres sont différentes, donc les constructeurs sont surchargés avec succès.
Il y a cependant un problème ici. Il y a un peu de dédoublement. Ce que nous voulons vraiment, c'est que le premier constructeur appelle le deuxième constructeur avec
deux paramètres.

Chaînage de constructeurs
C'est lorsque des constructeurs surchargés s'appellent. Une technique courante consiste à avoir chacun
Le constructeur ajoute un paramètre jusqu'à arriver au constructeur qui fait tout le travail.

public class Mouse {
   private int numTeeth;
   private int numWhiskers;
   private int weight;
   public Mouse(int weight) {
      this(weight, 16); // calls constructor with 2 parameters
   }
   public Mouse(int weight, int numTeeth) {
      this(weight, numTeeth, 6); // calls constructor with 3 parameters
   }
   public Mouse(int weight, int numTeeth, int numWhiskers) {
      this.weight = weight;
      this.numTeeth = numTeeth;
      this.numWhiskers = numWhiskers;
   }
   public void print() {
      System.out.println(weight + " " + numTeeth + " " + numWhiskers);
   }
   public static void main(String[] args) {
      Mouse mouse = new Mouse(15);
      mouse.print();
   }
}

résultat : 15 16 6

La méthode main() appelle le constructeur avec un paramètre. Ce constructeur ajoute une deuxième valeur codée en dur et appelle le constructeur avec deux
paramètres. Ce constructeur ajoute une valeur supplémentaire codée en dur et appelle le constructeur
avec trois paramètres. Le constructeur à trois paramètres attribue les variables d'instance.

Le chaînage de constructeurs est utilisé lorsque vous souhaitez appeler un constructeur
dans un autre constructeur.

Avantages combinés de la surcharge et du chaînage

Ensemble, la surcharge et le chaînage des constructeurs offrent flexibilité, efficacité et code maintenable. La surcharge vous permet de prendre en charge divers scénarios d'initialisation, tandis que le chaînage garantit que vous pouvez centraliser la logique partagée et réduire la redondance.

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!