Je trouve que la notion de constructeur n’est pas très facile à comprendre pour une personne qui débute dans l’étude du langage java sans jamais avoir étudié de programmation orientée objet.
Un constructeur permet, entre autre, d’assigner des valeurs aux variables de l’objet, lors de son instanciation.
Exemple avec du code :
Pour comprendre à quoi servent les constructeur, peut être vaut-il mieux commencer à lire le code à partir de la ligne n°30. Commencer par lire les déclarations des constructeurs, avant que l’on instancie les objets de ces constructeurs dans la méthode main.
public class Constructeurs {
public static void main(String[] args) {
Maman m = new Maman();
Maman m1 = new Maman("Jojo", "Marie", 29);
Papa p = new Papa();
Papa p1 = new Papa();
Papa p2 = new Papa();
p1.setNom("Dupont");// ici on va créer un premier objet de type papa et on assigne des valeurs aux variables qui caractérisent l'objet papa, en utilisant la méthode "set"
p1.setPrenom("Pierre");
p1.setAge(50);
p2.setNom("Paul");//idem que le premier objet de type papa (p1), on crée un deuxième objet de type papa, pour l'exemple, et on lui assigne des valeurs de variable via la méthode set
p2.setPrenom("Julien");
p2.setAge(49);
// les variables p3 et p4 permettent de distinguer les deux objets issus de la classe Papa
Papa p3 = new Papa("Marc", "Louis", 34);// les variables assignées aux 3èmes et 4èmes objets de type papa le sont directement via leur constructeurs respectif, ici même.
Papa p4 = new Papa("Pierre", "Luc", 47);
System.out.println(p1.prenom);// on affiche le tout pour l'exemple
System.out.println(p2.prenom);
System.out.println(p3.prenom);
System.out.println(p4.prenom);
}
}
class Personne {
String nom, prenom;
int age;
}
class Parent extends Personne {
}
class Papa extends Parent {
public Papa() {// constructeur par défault
}
public Papa(String n, String p, int a) {// Ici on utilise un constructeur personnalisé pour assigner des valeurs aux variables qui caractérisent la classe papa
nom = n;
prenom = p;
age = a;
}
public void setNom(String n) {
nom = n;
}
public void setPrenom(String prenom) {
this.prenom = prenom;//le mot clef "this" permet de dire à Java qu'il s'agit de la variable "prenom" issue de la classe personne.
}
public void setAge(int a) {
age = a;
}
}
class Maman extends Parent {
//int taille;
public Maman() {
System.out.println("Maman vide");
}
public Maman(String nom, String prenom, int a) {
this.nom = nom;
this.prenom = prenom;
age = a;
System.out.println("Maman remplie");
}
}
Explication sur l’utilisation des constructeurs dans ce code :
Dans ces lignes de code, on va créer quatre classes.
- La classe « personne »
- La classe « Parent »
- La classe « Papa »
- La classe « maman »
On commence par créer une classe personne (personne dans le sens « une personne-un personnage »). On y déclare 3 variables qui permettent de stocker un nom, un prénom et un âge.
On construit ensuite la classe Parent qui reprend les caractéristiques de la classe personne (via le mot-clef « extends »).
On construit la classe Papa qui reprend les caractéristiques de la classe nommée « Parent » (encore via le mot clef « extends ».) A partir de la classe Papa, on commence à voir l’utilité d’utiliser un constructeur, parce que l’on va assigner des valeurs de variable via le constructeur.
Dans cette classe Papa, on place les variables d’instance dans des variables définis par le constructeur de la classe. Ensuite, on va assigner des valeurs à ces variables du constructeur (D’abord via le constructeur, et ensuite pour l’exemple via la méthode set).
On construit ensuite la classe Maman.
Cette classe utilise le mot-clef extends pour reprendre les caractéristiques de la classe Parent. Pour l’exemple, on a déclaré 3 variables dans les variables du constructeur : deux variables (nom, prénom) qui portent le même nom que les variables d’instance de la classe, et une variable qui porte un nom différent. Cela nous permet de voir quel est l’utilité du mot-clef « this » dans le cas présent.
Lorsqu’une variable déclarée dans un constructeur porte le même nom qu’une variable d’instance de classe, on utilise le mot clef « this » pour distinguer les deux variables portant le même nom.
La méthode main
Jusqu’à présent, on s’est contenté de définir des constructeurs dans les classes Papa et Maman. Dans la méthode main, on va utiliser les définitions déclarées par ces constructeurs pour créer tout les objets que l’on souhaite. L’avantage des constructeurs est donc de définir plusieurs prototypes avant leur instanciation.
Dans cette méthode main, on va créer 2 objets de type Maman, et 5 objets de type Papa.
Voyons ce qui se passe pour chacune des instanciations d’objets :
- Maman m = new Maman(); //ici rien à commenter. Il s’agit du constructeur par défaut.
- Maman m1 = new Maman( »Jojo », « Marie », 29); //Ici par contre on peut voir toute l’utilité des constructeurs, pourquoi ? car on définit directement des valeurs de variable dans les constructeurs.
- Papa p1 = new Papa(); //constructeur par défaut, qui va nous servir à appeler la méthode set sur les objets crées.
- p1.setNom( »Dupont »); // contrairement à « m1 » on ne donne pas de valeurs aux variables de l’objet via son constructeur mais via l’appel de la méthode « set »
p1.setPrenom( »Pierre »);
p1.setAge(50);
- Papa p2 = new Papa(); //idem que pour Papa p1, on assigne des valeurs aux variables qui caractérisent l’objet, via la méthode set.
p2.setNom( »Paul »);
p2.setPrenom( »Julien »);
p2.setAge(49);
- Papa p3 = new Papa( »Marc », « Louis », 34); //ici par contre, on assigne des valeurs aux variables qui caractérisent l’objet, directement dans sont constructeur lors de son instanciation. Tout comme on le faisait pour l’objet contenu dans la variable « m1 »
- Papa p4 = new Papa ( »Pierre », « Luc », 47); // idem que pour Papa p3
Ensuite on appel la méthode System.out.println () ; afin de faire afficher les prénoms des objets de type Papa (p1, p2, p3, p4).
