Qu’est-ce qu’un constructeur en Java et comment l’utilisez-vous ?

Hibou Gourou

Dans la programmation orientée objet, un constructeur est une fonction spéciale que vous appelez pour créer un objet. Les constructeurs ont plusieurs caractéristiques uniques qui leur permettent de travailler.

En Java, vous nommez un constructeur d'après sa classe. Un constructeur est une méthode, définie dans la classe à laquelle elle s'applique. Les constructeurs Java peuvent utiliser la surcharge pour fournir un comportement alternatif. Les constructeurs en Java peuvent également utiliser l'héritage pour réutiliser le code.

Pourquoi avez-vous besoin de constructeurs de toute façon ?

Les constructeurs sont un pilier de la programmation orientée objet et Java ne fait pas exception. Cet exemple montre comment vous pouvez définir une classe Circle de base avec une propriété de données et une méthode :

 public class Circle {
 public double radius;
 public double area() { return 3.14159 * radius * radius; }
 }

Vous pouvez ensuite créer une instance de cette classe et interagir avec elle :

 Circle c = new Circle();
 c.radius = 2;
 System.out.println(c.area()); // 12.56636

Mais c'est moins pratique et robuste qu'il ne pourrait l'être. C'est une bonne pratique orientée objet d'encapsuler les données, en les protégeant des accès non autorisés :

 public class Circle {
 private double radius;
 public double area() { return 3.14159 * radius * radius; }
 public void setRadius(double r) { radius = r; }
 }

Désormais, le code appelant peut utiliser la méthode setRadius et ne pas avoir à se soucier de ses détails d'implémentation :

 Circle c = new Circle();
 c.setRadius(2);

Les constructeurs offrent un moyen encore meilleur de fournir des données à un objet lorsque vous le créez. Ils sont très souvent utilisés pour l'initialisation de propriétés, comme ici le rayon .

Exemples de constructeurs simples

Le constructeur le plus basique est un constructeur sans arguments, qui ne fait rien :

 public class Circle {
 public Circle() {}
 }

Voir aussi : Apprendre à créer des classes en Java

Si vous ne définissez pas de constructeur, Java en fournira un par défaut qui se comporte de la même manière.

Notez quelques éléments :

  1. Le nom du constructeur correspond au nom de la classe.
  2. Ce constructeur utilise le modificateur d'accès public , donc tout autre code peut l'appeler.
  3. Un constructeur n'inclut pas de type de retour. Contrairement aux autres méthodes, les constructeurs ne peuvent pas renvoyer de valeur.

Les constructeurs effectuent généralement une sorte d'initialisation. Notez que le code ci-dessus n'initialise pas la valeur de radius. Dans ce cas, la langue le mettra automatiquement à zéro. Cette classe s'attend à ce qu'un utilisateur utilise setRadius() . Pour utiliser une valeur par défaut plus utile que 0, vous pouvez l'affecter dans le constructeur :

 public class Circle {
 public Circle() { radius = 1; }
 }

Les cercles créés avec cette classe auront au moins maintenant une zone réelle ! L'appelant peut toujours utiliser setRadius() pour fournir un rayon autre que 1. Mais le constructeur peut être encore plus convivial :

 public class Circle {
 public Circle(double r) { radius = r; }
 }

Vous pouvez désormais créer des cercles avec un rayon spécifique dès la naissance :

 Circle c = new Circle(2);
 System.out.println(c.area()); // 12.56636

C'est une utilisation très courante pour les constructeurs. Vous les utiliserez souvent pour initialiser des variables en valeurs de paramètres.

Surcharge du constructeur

Vous pouvez spécifier plusieurs constructeurs dans une définition de classe :

 public Circle() { radius = 1; }
 public Circle(double r) { radius = r; }

Cela donne au code appelant le choix de la manière de construire des objets :

 Circle c1 = new Circle(2);
 Circle c2 = new Circle();
 System.out.println(c1.area() + ", " + c2.area()); // 12.56636, 3.14159

Avec un Circle légèrement plus complexe, vous pouvez explorer des constructeurs plus intéressants. Cette version stocke sa position :

 public class Circle {
 public double x, y, radius;
 public Circle() { radius = r; }
 public Circle(double r) { radius = r; }
 public Circle(double x, double y, double r) {
 this.x = x; this.y = y; radius = r;
 }
 public double area() { return 3.14159 * radius * radius; }
 }

Vous pouvez maintenant créer un cercle sans arguments, un seul rayon ou des coordonnées x et y à côté du rayon. C'est le même type de surcharge que Java prend en charge pour n'importe quelle méthode.

Enchaînement des constructeurs

Que diriez-vous de créer un cercle à partir d'un autre ? Cela nous donnerait la possibilité de copier facilement des cercles. Observez le bloc suivant :

 public Circle(Circle c) {
 this.x = cx;
 this.y = cy;
 this.radius = c.radius;
 }

Cela fonctionnera, mais cela répétera inutilement du code. Étant donné que la classe Circle a déjà un constructeur qui gère les propriétés individuelles, vous pouvez l'appeler à la place en utilisant le mot – clé this :

 public Circle(Circle c) {
 this(cx, cy, c.radius);
 }

Il s'agit d'une forme de chaînage de constructeurs, appelant un constructeur à partir d'un autre. Il utilise moins de code et permet de centraliser une opération plutôt que de la dupliquer.

Appel du constructeur parent

L'autre forme de chaînage de constructeurs se produit lorsqu'un constructeur appelle un constructeur de sa classe parente. Cela peut être explicite ou implicite. Pour appeler explicitement un constructeur parent, utilisez le mot – clé super :

 super(x, y);

Imaginez une classe Shape jouant le rôle de parent du Circle :

 public class Shape {
 double x, y;
 public Shape(double _x, double _y) { x = _x; y = _y; }
 }

Il gère le positionnement commun de toutes les formes, car il s'agit d'une fonctionnalité qu'elles partagent toutes. Désormais, la classe Circle peut déléguer la gestion des positions à son parent :

 public class Circle extends Shape {
 double radius;
 public Circle(double r) { super(0, 0); radius = r; }
 public Circle(double x, double y, double r) {
 super(x, y);
 radius = r;
 }
 }

La construction de superclasses est un aspect très important de l' héritage en Java . Le langage l'applique par défaut si vous n'appelez pas explicitement super dans vos constructeurs.

Modificateurs d'accès sur les constructeurs

Les constructeurs peuvent inclure un modificateur d'accès dans leur signature. Comme d'autres méthodes, cela définit quels types d'appelants peuvent accéder au constructeur :

 public class Test {
 private static Test uniqueInstance = new Test();
 private Test() { }
 public static Test getInstance() {
 return uniqueInstance;
 }
 }

Il s'agit d'un exemple plus compliqué, alors prenez soin de le comprendre :

  • La classe n'est pas abstraite, il est donc possible de l'instancier à partir de celle-ci.
  • Le constructeur est privé, donc seule cette classe elle-même peut créer une nouvelle instance.
  • Via une propriété et une méthode statiques, la classe expose une instance unique et unique d'elle-même aux appelants.

Utiliser des constructeurs en Java pour créer des objets

Les constructeurs sont essentiels à la programmation orientée objet. Ils permettent de créer des objets, ce qui est essentiel !

En Java, les constructeurs ressemblent aux autres méthodes et fonctionnent à peu près de la même manière. Vous devez vous rappeler les règles spéciales concernant les constructeurs par défaut, la surcharge et le chaînage des constructeurs. Si les constructeurs sont nouveaux pour vous, vous voudrez peut-être vous renseigner sur les autres concepts Java de base que vous devriez apprendre au début.