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

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

Maintenant, le code d'appel peut utiliser le setRadius méthode et ne pas avoir à se soucier de ses détails de mise en œuvre :

où trouver des pièces d'ordinateur pas chères

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 le rayon ici.

Exemples de constructeurs simples

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

public class Circle {  
  public Circle() {}   
}

Voir également: Apprenez à 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 :

Le nom du constructeur correspond au nom de la classe.
Ce constructeur utilise le Publique modificateur d'accès, donc n'importe quel autre code peut l'appeler.
Un constructeur n'inclut pas de type de retour. Contrairement à d'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 désormais une zone réelle ! L'appelant peut toujours utiliser setRadius() pour fournir un rayon différent de 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 :

copier google drive sur un autre compte

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 = c.x;  
 this.y = c.y;  
 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 cette mot-clé:

public Circle(Circle c) {  
 this(c.x, c.y, 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 super mot-clé:

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 superclasse est un aspect très important de 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.

Partager Partager Tweeter E-mail 10 concepts Java de base que vous devriez apprendre pour commencer

Que vous écriviez une interface graphique, développiez un logiciel côté serveur ou une application mobile utilisant Android, l'apprentissage de Java vous sera très utile. Voici quelques concepts Java de base pour vous aider à démarrer.

Lire la suite Rubriques connexes

La programmation
Java
Conseils de codage

A propos de l'auteur Bobby Jack(58 articles publiés)

Bobby est un passionné de technologie qui a travaillé comme développeur de logiciels pendant près de deux décennies. Il est passionné par les jeux, travaillant comme rédacteur de critiques au Switch Player Magazine, et est immergé dans tous les aspects de la publication en ligne et du développement Web.

rechercher tous les réseaux sociaux à la fois gratuitement

Plus de Bobby Jack

Abonnez-vous à notre newsletter

Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !

Cliquez ici pour vous abonner