Surcharger un constructeur en Java

Mohammad Irfan 12 octobre 2023

Java Java Constructor

Constructeur par défaut en Java
Constructeur paramétré en Java
Code sans surcharge de constructeur
Surcharge de constructeur en Java
Bonnes pratiques de surcharge des constructeurs
Surcharger un constructeur

Ce tutoriel présente comment surcharger les constructeurs en Java. Nous avons également répertorié quelques exemples de codes que vous pouvez suivre pour mieux comprendre ce sujet.

Un constructeur est une méthode appelée pour allouer de la mémoire à un objet de classe et initialiser les attributs de classe pour cet objet. Si aucun constructeur n’a été créé pour une classe, alors Java fournit un constructeur par défaut.

Par exemple, aucun constructeur n’a été défini dans la classe ci-dessous. Néanmoins, nous pouvons créer un objet de cette classe pendant que les attributs sont initialisés à leurs valeurs par défaut (null, dans ce cas).

Constructeur par défaut en Java

class Student {
  String name;
  Double gpa;
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student();
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Production:

null	null

Le concept de surcharge de constructeur est similaire à la surcharge de méthode, ce qui signifie que nous avons plusieurs constructeurs pour une même classe. La surcharge du constructeur est effectuée pour initialiser les variables membres de la classe de différentes manières.

Nous pouvons créer autant de constructeurs surchargés que nous le souhaitons. La seule condition est que les constructeurs surchargés diffèrent par le nombre et le type de paramètres qu’ils prennent.

Par exemple, considérons la classe Student ci-dessous avec deux attributs : nom de l'élève et GPA. Un constructeur est défini pour la classe, qui prend comme paramètres un nom de chaîne et un double GPA et initialise les attributs correspondants pour le nouvel objet.

Constructeur paramétré en Java

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student("Justin", 9.75);
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Production:

Justin	9.75

Code sans surcharge de constructeur

Considérez un scénario où seul le nom de l’étudiant est transmis au constructeur lors de la création d’un nouvel objet ; le GPA doit être automatiquement mis à null dans ce cas. Si nous ne surchargeons pas le constructeur et passons simplement le nom, nous obtenons l’erreur de compilation suivante.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student("Justin");
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Production:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor Student(String) is undefined

	at ConstructorOverloading.main(ConstructorOverloading.java:18)

Surcharge de constructeur en Java

Nous pouvons créer un constructeur surchargé avec uniquement le nom de l’étudiant comme paramètre pour résoudre la situation ci-dessus. Nous définirons le GPA sur null lorsque ce constructeur sera appelé.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    this.gpa = g;
  }
  Student(String s) {
    name = s;
    gpa = null; // Setting GPA to null
  }
}
public class Main {
  public static void main(String[] args) {
    Student s1 = new Student("Justin");
    Student s2 = new Student("Jessica", 9.23);
    System.out.println(s1.name + "\t" + s1.gpa);
    System.out.println(s2.name + "\t" + s2.gpa);
  }
}

Production:

Justin	null
Jessica	9.23

Considérons une autre situation où un objet Student est créé, mais ni le nom ni le GPA n’ont été mentionnés. Nous pouvons créer un autre constructeur surchargé qui ne prend aucun argument (constructeur par défaut) et définit les attributs name et GPA sur null.

N’oubliez pas que Java fournit un constructeur par défaut uniquement lorsqu’aucun autre constructeur n’est créé pour une classe. Mais pour notre classe, les constructeurs existent déjà et nous devons donc créer un constructeur par défaut.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
  Student(String s) {
    name = s;
    gpa = null;
  }
  Student() {
    name = null;
    gpa = null;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s1 = new Student();
    Student s2 = new Student("Justin");
    Student s3 = new Student("Jessica", 9.23);
    System.out.println(s1.name + "\t" + s1.gpa);
    System.out.println(s2.name + "\t" + s2.gpa);
    System.out.println(s3.name + "\t" + s3.gpa);
  }
}

Production:

null	null
Justin	null
Jessica	9.23

Bonnes pratiques de surcharge des constructeurs

Il n’y a pas de directives définies à suivre lors de la surcharge des constructeurs. Cependant, il existe quelques bonnes pratiques recommandées que nous pouvons suivre pour éviter toute confusion et réduire la portée des erreurs.

Il faut utiliser le mot-clé this pour référencer les variables membres de la classe. Cela évite les confusions et rend notre code plus lisible.
Nous pouvons également passer des noms de paramètres plus intuitifs au constructeur. Par exemple, si un constructeur initialise le champ de nom, la signature du constructeur pourrait être Student(String name) au lieu de Student(String s). A l’aide du mot-clé this, on peut différencier le paramètre, appelé name, et l’attribut class, également appelé name.

Continuons avec l’exemple de la classe Student et utilisons le mot-clé this à l’intérieur des constructeurs.

class Student {
  String name;
  Double gpa;
  Student(String name, Double gpa) // passing more intuitive parameter names
  {
    this.name = name; // using this keyword to avoid confusion
    this.gpa = gpa;
  }
  Student(String name) {
    this.name = name;
    this.gpa = null;

    Student()

        this.name = null;
    this.gpa = null;
  }
}

C’est aussi une bonne pratique pour une classe de n’avoir qu’un constructeur primaire unique, et tous les constructeurs restants devraient appeler ce constructeur primaire pour initialiser les attributs.
On peut appeler un constructeur depuis un autre constructeur en utilisant la fonction this(). Le nombre et les types d’attributs que nous passons à this() décideront quel constructeur sera appelé.
Cela réduira la redondance du code, et nous n’avons besoin d’écrire la logique que pour un seul constructeur.
Dans la classe Student, nous avons besoin de trois constructeurs surchargés. Le constructeur principal sera celui paramétré qui prend à la fois name et GPA comme paramètres. Les deux autres constructeurs surchargés appelleront simplement le constructeur principal et passeront les valeurs des paramètres comme null.

class Student {
  String name;
  Double gpa;
  Student(String name, Double gpa) // Primary Constructor that sets the attribute values
  {
    this.name = name;
    this.gpa = gpa;
  }
  Student(String name) {
    this(name, null); // Calling the primary constructor with GPA as null
  }
  Student() {
    this(null, null); // Calling the primary constructor with both parameters as null
  }
}