| ← (précédent) C.1 La contruction d'une classe : la notion d'objet |
| C.3 La nature profonde de l'objet → |
| Accueil ↔ S O M M A I R E |
C.2 Les constructeurs (d'objets) |
|
Quand on parle de constructeur, on dit toujours le constructeur d' une classe. Ce qui n' est pas faux. Pour ma part, je parle beaucoup plus de constructeur d' objet. Pourquoi ? Parce que c' est une méthode dont la tâche première est de donner
des valeurs initiales aux champs de cet Objet. Un peu comme la méthode initialiser() dans le chapitre précédent. En réalité, un constructeur ne fait pas que ça. Mais pour l' instant, contentons nous de ça. Un constructeur ne s' utilise pas comme n' importe quelle méthode. En l' occurrence, on n' écrit jamais : nom de l' objet, suivi d' un point, suivi du nom de la méthode. Un constructeur est une méthode particulière qui s' utilise de façon particulière. Sans plus tarder, voyons un exemple. |
Une classe qui sert à fabriquer des cercles dans l' espace dimension 2
1. public class Cercle1
2. {
3. private double centreX;
4. private double centreY;
5. private double rayon;
6.
7. public Cercle1(double x, double y, double r)
8. {
9. centreX = x; centreY = y; rayon = r;
10. }
11.
12. public void afficherCoord()
13. {
14. System.out.println("coordonnées du cercle : " + centreX + ", " + centreY + " et " + rayon);
15. }
16. }
|
|
Vous vous souvenez, c' est la classe Cercle du chapitre précédent. La plupart des des méthodes ont disparue. Ce sont les mêmes champs. Nous avons ici une
nouvelle méthode, déclarée en ligne 7. Elle semble bizarre. Parce qu' elle a le même nom que la classe. Même la première lettre majuscule est
respectée. De plus, elle n' a pas de type. Même pas void. On écrit public et aussitôt le nom de la méthode. Vous y êtes, c' est le constructeur. un constructeur porte le même nom que la classe dans laquelle il est défini un constructeur n'a pas de type de retour (même pas void) un constructeur peut avoir des arguments Ici, le constructeur de la classe Cercle possède 3 instructions. Elles permettent de donner des valeurs initiales aux 3 champs du cercle. Sachez que le constructeur d' une classe n' initialise pas forcément tous les champs. C' est à vous de voir selon le problème à résoudre. Le constructeur d' une classe peut faire autre chose qu' initialiser les champs d' un objet. Nous le verront plus tard. ATTENTION, ATTENTION, ATTENTION !!!.... Cette méthode particulière qu' on appelle constructeur ne s' utilise pas comme les autres méthodes. En l' occurence, on n' écrit jamais ceci : nomDeL'Objet, suivi d' un point, suivi de nomDuConstruteur. On utilise le constructeur de façon indirecte. Pendant l' instanciation de l' objet. Voyons tout de suite avec un exemple. |
EXEMPLE 1 :
1. public class ConstructeurCercle1
2. {
3. public static void main(String [] args)
4. {
5. Cercle1 A = new Cercle(1, 2, 3);
6. A.afficherCoord();
6. }
7. }
|
|
Compilez puis exécutez. Il sera affiché : coordonnées du cercle : 1.0, 2.0 et 3.0 Que s' est-il passé ? ... Ligne 5 : j' ai instancié un objet A de type Cercle. Mais cette fois, dans les parenthèses, y a des valeurs. Dans le chapitre précédent, il n' y en avait pas. Pourquoi je met les valeurs 1, 2 et 3 dans les parenthèses ? Parce que ici, dans la classe Cercle, il y a un constructeur (déclaré en ligne 7 de la classe Cercle). Ce constructeur requiert 3 argument de type double : x, y et r. Vous voyez bien dans la définition de ce constructeur, que les valeurs de ces arguments sont respectivement affectées aux coordonnées du centre (centreX et centreY) et au rayon (rayon). C' est pourquoi, en écrivant Cercle A = new Cercle(1, 2, 3); dans mon exemple de programme, les valeurs 1, 2 et 3 sont respectivement affectées aux champs centreX, centreY et rayon de l' objet A. D' où l' affichage. La question très pertinente que vous pourriez vous poser tout de suite est de savoir ce qui se passe lorsqu' une classe n' a pas de constructeur comme dans le chapitre précédent. Réponse : dans l' exemple suivant. |
Une classe quelconque
1. public class Cercle2
2. {
3. private byte b; private short s; private int i; private long l;
4. private float f; private double d;
5. private char c; private String S;
6. private boolean bool;
7.
8. public afficherCoord()
9. {
10. System.out.println("valeur de byte : " + b);
11. System.out.println("valeur de short : " + s);
12. System.out.println("valeur de int : " + i);
13. System.out.println("valeur de long : " + l);
14. System.out.println("valeur de float : " + f);
15. System.out.println("valeur de double : " + d);
16. System.out.println("valeur de char : " + c);
17. System.out.println("valeur de String : " + S);
18. System.out.println("valeur de boolean : " + bool);
18. }
19. }
EXEMPLE 2 :
1. public class ConstructeurCercle2
2. {
3. public static void main(String [] args)
4. {
5. Cercle2 A = new Cercle();
6. A.afficherCoord();
6. }
7. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : valeur de byte : 0 valeur de short : 0 valeur de int : 0 valeur de long : 0 valeur de float : 0.0 valeur de double : 0.0 valeur de char : valeur de String : null valeur de boolean : false Pourquoi tous les champs sont initialisés à une valeur nulle alors qu' on n' a pas utilisé de constructeur ? En réalité, on n' en a utilisé un. Lorsque vous concevez une classe sans y mettre un constructeur (ce qui n' est pas interdit), au moment de créer (instancier) un objet grâce à l' opérateur new, le compilateur java vous fournit un constructeur par défaut. Ce constructeur par défaut initialise toujours les variables entières à 0. Les variabres décimales à 0.0 la variable char à une absence de caractère, la variable String à null. Le mot clé null signifie absence d' objet. la variable boolean quant à elle est initialisée à false. Ce qui correspond à l' état zéro. (1 = vrai et 0 = faux). Pigé ? Ce qui veut dire alors que dans les exemples du chapitre précédent, en écrivant par exemple : Cercle A = new Cercle(); il y avait déjà initialisation des champs. Donc, en appliquant la méthode initialiser() à l' objet, on ne faisait que changer les valeurs des coordonnées. Et pas du tout initialiser. |
|
En fin de compte, l' opérateur new induit en réalité 2 choses : instanciation d' un nouvel objet. Puis initialisation des champs de cet objet. Lorsque vous créez une classe en y mettant un constructeur, le fameux constructeur par défaut disparait. Si vous voulez donc que les valeurs initiales de tous les champs d' un objet soient à l' état nul, pas la peine de créer un constructeur. Si vous voulez que les valeurs initiales des champs de certains objets que vous instanciez soient à l' état nul et que d' autres objets aient des valeurs initiales de champs non nuls, ne comptez pas sur le constructeur par défaut (sans arguments). Vous devez en créer un exprès. Puis un autre constructeur dont les valeurs initiales de champs ne seront pas nulles. |
Une classe qui sert à fabriquer des cercles dans l' espace dimension 2
1. public class Cercle3
2. {
3. private double centreX;
4. private double centreY;
5. private double rayon;
6.
7. public Cercle3(double x, double y, double r)
8. {
9. centreX = x; centreY = y; rayon = r;
10. }
11.
12. public Cercle3()
13. {
14. centreX = 0; centreY = 0; rayon = 0;
15. }
16.
17. public void afficherCoord()
18. {
19. System.out.println("coordonnées du cercle : " + centreX + ", " + centreY + " et " + rayon);
20. }
21. }
|
| Le premier constructeur, déclaré ligne 7 permet d' initialiser les champs aux valeurs mises entre parenthèses. Alors que le deuxième constructeur déclaré ligne 12, permet d' initialiser les champs à zéro. |
EXEMPLE 3 :
1. public class ConstructeurCercle3
2. {
3. public static void main(String [] args)
4. {
5. Cercle3 A = new Cercle3(2, 5, 1);
6. A.afficherCoord();
7. Cercle3 B = new Cercle3();
8. B.afficherCoord();
9. }
10. }
|
|
Compilez puis exécutez : il sera affiché coordonnÚes du cercle : 2.0, 5.0 et 1.0 coordonnÚes du cercle : 0.0, 0.0 et 0.0 Pour l' objet B, j' ai utilisé le 2ème constructeur (sans arguments) qui initialise les champs à, zéro. |
Une classe qui sert à fabriquer des cercles dans l' espace dimension 2
1. public class Cercle4
2. {
3. private double centreX;
4. private double centreY;
5. private double rayon;
6.
7. public Cercle4(double x, double y, double r)
8. {
9. centreX = x; centreY = y; rayon = r;
10. System.out.println("Vous venez de créer un nouvel objet");
11. }
12.
13. public void afficherCoord()
14. {
15. System.out.println("coordonnées du cercle : " + centreX + ", " + centreY + " et " + rayon);
16. }
17. }
|
| Un constructeur ne sert pas seulement à initialiser les champs d' un objet. Selon le problème que avez à résoudre, vous pouvez l' uttiliser pour d' autres actions. Ici, j' ai mis une instruction autre que l' initialisation. Regardez ligne 10 : System.out.println("Vous venez de créer un nouvel objet"); Au cours d' un programme, vous pouvez savoir qu' un nouvel objet vient d' être créé. Si cela est utile bien entendu. Voyons l' exemple ci-dessous. |
EXEMPLE 4 :
1. public class ConstructeurCercle4
2. {
3. public static void main(String [] args)
4. {
5. Cercle4 A = new Cercle(1, 2, 3);
6. A.afficherCoord();
6. }
7. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Vous venez de crÚer un nouvel objet coordonnÚes du cercle : 1.0, 2.0 et 3.0 En écrivant Cercle A = new Cercle(1, 2, 3); Vous créez un nouvel objet Cercle. Mais vous faites aussi appel au constructeur puisque vous utilisez les valeurs 1, 2 et 3. En faisant appel au constructeur, toutes les instructions du constructeur sont exécutées. Non seulement centreX = x; centreY = y; rayon = r; Mais aussi l' instruction : System.out.println("Vous venez de créer un nouvel objet"); D' où l' affichage de cette phrase : Vous venez de créer un nouvel objet. Puis l' instruction A.afficherCoord(); permet d' exécuter l'unique instruction de la méthode afficherCoor(). D' où l' affichage de coordonnÚes du cercle : 1.0, 2.0 et 3.0 |
Une classe qui sert à fabriquer des cercles dans l' espace dimension 2
1. public class Cercle5
2. {
3. private double centreX;
4. private double centreY;
5. private double rayon;
6. private static int nombreObjets;
7.
8. public Cercle5(double x, double y, double r)
9. {
10. centreX = x; centreY = y; rayon = r; nombreObjets++;
11. System.out.println("Nombre d' objets créés = " + nombreObjets);
12. }
?.
13. public void afficherCoord()
14. {
15. System.out.println("coordonnées du cercle : " + centreX + ", " + centreY + " et " + rayon);
16. }
17. }
|
| Les champs centreX, centreY et rayon, vous connaissez déjà. Mais le champ nombreObjet est déclaré avec le mot clé static. Pourquoi ? Parce que je l' utilise comme compteur du nombre d' objets créés. Regardez la ligne 10. La dernière instructions est : nombreObjets++. Cela veut dire que nombreObjets est incrémenté de 1. On ajout 1 à sa valeur actuelle. Puis la ligne 11 permet d' afficher ce nombre. |
EXEMPLE 5 :
1. public class ConstructeurCercle5
2. {
3. public static void main(String [] args)
4. {
5. Cercle5 A = new Cercle(1, 5, 2.5);
6. Cercle5 B = new Cercle(3.1, 2.2, 2.3);
7. Cercle5 C = new Cercle(0.75, 3.0, 3.1);
8. }
9. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Nombre d' objets créés = 1 Nombre d' objets créés = 2 Nombre d' objets créés = 3 Explications : Lorsqu' on écrit Cercle A = new Cercle(1, 5, 2.5); Vous le savez déjà, on instancie un nouvel objet Cercle. Mais en même temps, on initialise tous les champs à 0 pour les entiers et 0.0 pour les float et double. Voir exemple 2. Puis les instructions du constructeur sont exécutées. En regardant la définition du contruteur, on voit que cela permet d' affecter les champs centreX avec 1, centreY avec 5 et centreY avec 2.5. Mais l' instruction nombreObjets++; permet d' incrémenter nombreObjet. Car nombreObjets++ correpond à nombreObjets = nombreObjets + 1. Voilà pourquoi, à l' affichage, on a Nombre d' objets créés = 1. Pour l' objet B, même tope avec les corrdonées 3.1, 2.2 et 2.3. L' instruction nombreObjets++ permet d' ajouter 1 à la valeur initale de nombreObjets. Cette valeur était 1. Elle est maintenant 2. Puisque le champ nombreObjets est déclaré avec le mot static, cette variable existe en un seul exemplaire dans la mémoire. Lorsqu' on créé l' objet C, l' instruction nombreObjets++ permet de passer de 2 à 3. D' où l' affichage de Nombre d' objets créés = 2 et de Nombre d' objets créés = 3. Supprimez le mot static devant le mot nombreObjets dans la classe Cercle4. Recompilez puis exécutez le programme ConstructeurCercle4. Vous verrez à l 'affichage que le nombre d' objets sera toujours égal à 1. |
| Si vous voulez que le nombre d' objets créés s' affiche plutôt à la fin et pas à chaque fois, il est préférable de créer une méthode spécifique au décompte. |
Une classe qui sert à fabriquer des cercles dans l' espace dimension 2
1. public class Cercle6
2. {
3. private double centreX;
4. private double centreY;
5. private double rayon;
6. private static int nombreObjets;
7.
8. public Cercle6(double x, double y, double r)
9. {
10. centreX = x; centreY = y; rayon = r; nombreObjets++;
11.
12. }
?.
13. public void afficherCoord()
14. {
15. System.out.println("coordonnées du cercle : " + centreX + ", " + centreY + " et " + rayon);
16. }
17.
18. public static void compterObjets()
19. {
20. System.out.println("Nombre d' objets créés = " + nombreObjets);
21. }
22. }
|
| L' instruction qui était dans le constructeur est maintenant dans une nouvelle méthode : compterObjets. Cette méthode est déclarée en ligne 18 avec le mot static. Parce que dans la définition de cette méthode, l' instruction utilise un champs static (nombreObjets). Comme vous le savez déjà, tout ce qui est déclaré avec static ne dépend pas d' un objet. Forcément, la méthode non plus ne dépend pas d' un objet. Pas directement en tout cas. |
EXEMPLE 6 :
1. public class ConstructeurCercle6
2. {
3. public static void main(String [] args)
4. {
5. Cercle6 A = new Cercle(1, 5, 2.5);
6. Cercle6 B = new Cercle(3.1, 2.2, 2.3);
7. Cercle6 C = new Cercle(0.75, 3.0, 3.1);
8. Cercle6.compterObjets();
9. }
10. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Nombre d' objets créés = 3 Ligne 5 : je créé un objet. Ce qui veut aussi dire, initialisation des champs centreX, centreY et rayon. Pour le champ static nombreObjets, il s' agit d' une incrémentation. On augmente de 1 la valeur initiale qui était zéro. Même chose pour les lignes 6 et 7. Donc la valeur de nombreObjets est 3. Ligne 8, on fait appel à la méthode compterObjets. Cette méthode contient l' instruction permettant d' afficher Nombre d' objets créés = nombreObjets. nombreObjets étant égal à 3, d' où l' affichage de : Nombre d' objets créés = 3. |
|
De même qu' il est possible d' écrire la même méthode 2 fois ou plus, de même, une classe peut avoir plusieurs constructeurs. Souvenez-vous
toujours que le constructeur est une méthode. Une méthode particulière certes, mais une méthode quand même. |
Une classe qui sert à créer des comptes bancaires
1. public class CompteBancaire
2. {
3. private String nom;
4. private String prenom;
5. private String adresse;
6. private int montantInitial;
7. private String extraitKBis;
8. private String tel;
9.
10. public CompteBancaire(String nom, String prenom, String adresse, int montantInitial)
11. {
12. this.nom = nom;
13. this.prenom = prenom;
14. this.adresse = adresse;
15. this.montantInitial = montantInitial;
16. }
17.
18. public CompteBancaire(String nom, String prenom, String adresse, int montantInitial, String extraitKBis, String tel)
19. {
20. this(nom, prenom, adresse, montantInitial);
21. this.extraitKBis = extraitKBis;
22. this.tel = tel;
23. }
23.
24. public void afficherCoord()
25. {
26. System.out.println("nom = " + nom);
27. System.out.println("prenom = " + prenom);
28. System.out.println("adresse = " + adresse);
29. System.out.println("montant initial = " + montantInitial);
30. }
31.
32. public void afficherCoordSociete()
33. {
34. afficherCoord();
35. System.out.println("extrait K-Bis = " + extraitKBis);
36. System.out.println("téléphone = " + tel);
37. }
28. }
|
|
Voici une classe avec deux constreucteurs. Pourquoi ? ... Ne créez pas une classe avec plusieurs constructeurs juste pour le plaisir. Vous devez
avoir une raison pour cela. Ici, la classe permet de créer des objets comptes bancaires. Pour créer un compte bancaire, une banque a besoin de
plusieurs informations. Dans notre exemple, je ne me suis pas amusé à mettre toutes les caractéristiques d' un compte. J' ai simplifié les choses.
J' ai supposé deux types de comptes. Compte appartenant à un particulier. Puis compte appartenant à une entreprise. Pour un particulier, on a besoin de son nom, son prénom, son adresse et le montant initial. D' où le premier constructeur. Pour une entreprise, on a aussi besoin des mêmes informations que pour un particulier. Ce seront des informations du gérant de la société. En plus de ça, on a forcément besoin de l' extrait K-bis de l' entreprise. L' extrait K-Bis, c' est le numéro d' identification d' une entreprise. On a forcément besoin du numéro de tél de l' entreprise ou du gérant. Pour un particulier, en général, le numéro de tél n' est pas indispensable. Si la banque veut créer le compte d' un particulier, elle utilise le premier constructeur. Pour une entreprise, ce sera le deuxième constructeur. Comment ? ... Voyons l' exemple ci-dessous. |
EXEMPLE 7 :
1. public class ConstructeurCompteBancaire
2. {
3. public static void main(String [] args)
4. {
5. CompteBancaire Joseph = new CompteBancaire("DUPONT", "Joseph", "2 rue du lac 750001 Paris", 500);
6. CompteBancaire AFFNET = new CompteBancaire("BAK", "Ana", "2 rue Pax 10000 Troyes", 9500, "1125887", "0605040302");
7. System.out.println("\nclient Joseph : ");
8. Joseph.afficherCoord();
9. System.out.println("\nclient AFFNET :");
10. AFFNET.afficherCoordSociete();
11. }
12. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : client Joseph : nom = DUPONT prenom = Joseph adresse = 2 rue du lac 750001 Paris montant initial = 500 client AFFNET : nom = BAK prenom = Ana adresse = 2 rue Pax 10000 Troyes montant initial = 9500 extrait K-Bis = 1125887 téléphone = 0605040302 Dans l' exemple 6, la ligne 5 permet de créer le compte bancaire de Joseph. Pour celà, un constructeur est utilisé. Mais lequel ? Et bien, celui qui correspond à la qualité et à la quantité des paramètres. Regardez la classe CompteBancaire. Le premier contructeur requiert 4 arguments. Les 3 premiers étant de type String, le dernier étant de type int. On voit bien en ligne 5 de la classe ConstructeurCercle6, l' instruction permaettant de créer le compte de Joseph utilise un constructeur avec 4 arguments de type String, String, String et int. Dans ces conditions, c' est forcément le constructeur correspondant qui est utilisé. Donc le premier. Ligne 6 : On créé un compte bancaire de la société AFFNET. On utilise un constructeur avec 6 paramètres tous de type String. Sauf le 4ème. Dans ces conditions, le constructeur correpondant est utilisé. Donc, le 2ème constructeur. Regardons maintenant la définition des constructeurs. Constructeur 1 (ligne 10 à ligne 16 de la classe CompteBancaire). En ligne 12, on lit : this.nom = nom; Je vous l' ai déjà dit: this fait référence à l' objet courant. Autrement dit, à l' objet sur lequel on applique la méthode. Ici, la méthode est un constructeur. DOnc, c' est l' objet qu' on est entrain d' instancier. this.nom = nom veut dire que le champ nom de l' objet qu' on est entrain de créer a pour valeur le nom utilisé entre parenthèse. Concrètement, quand on crée l' objet Joseph en faisant : CompteBancaire Joseph = new CompteBancaire("DUPONT", "Joseph", "2 rue du lac 750001 Paris", 500); on dit que le champs nom de Joseph = "DUPONT". Même raisonnement avec les autres paramètres : Le champs prenom de Joseph = "Joseph". Le champ adresse de Joseph = "2 rue du lac 750001 Paris" et enfin le champ montant IOnitial de Joseph = 500. this.nom = nom; parce que le champ et l' argument du contructeur ont même nom. Si le champ s' appelait par exemple name, alors, l' expression this.nom = nom; serait name = nom; ou this.name = nom; Le champ name = valeur de nom entré en parenthèses dans création de l' objet. Le mot this n' aurait pas été indispensable. Dans le deuxième constructeur, le mot clé this prend un autre sens. J' aurais pu écrire les instructions du deuxième constructeur à l' image du premier contructeur en faisant : this.nom = nom; this.prenom = prenom; this.adresse = adresse; this.montantInitial = montantInitial; Puis ajouter this.extraitKBis = extraitKBis; et this.tel = tel; Mais pourquoi répéter les mêmes instructions qui sont déjà dans le premier constructeur ? Pour simplifier les choses, on fait appel au premier constructeur en utilisant le mot clé this, suivi des parenthèses dans lesquelles on trouve les mêmes paramètres que le constructeur appelé. Rappel : "\n" veut dire, aller à la ligne suivante. |
| De manière générale, lorsque dans une classe, il y a plusieurs contructeurs, et que l' un des constructeurs veut utiliser les instructions d' un autre, cela se fait par le biais de l' intruction this, suivi des parenthèses dans lesquelles se trouvent les mêmes paramètres que le constructeur appelé. Voyons un autree exemple : |
Une classe qui sert à créer des points colorés ou non dans l' espace dimension 2
1. public class Points2
2. {
3. private double x;
4. private double y;
5. private String couleur;
6.
7. public Points2(double x, double y)
8. {
9. this.x = x;
10. this.y = y;
11. }
12.
13. public Points2(double x, double y, String couleur)
14. {
15. this(x, y);
16. this.couleur = couleur;
17. }
18. }
|
|
Deux constructeurs : le premier contient les instructions : this.x = x; et this.y = y; Si je crée dans un programme un point en faisant : Points2 A = new Points2(1, 3); Je fais forcément appel au premier contructeur. Puisque j' utilise le même nombre de paramètres et la qualité des paramètres. 1 et 2 sont de type int mais sont implicitement convertis en double comme vous le savez déjà. this.x est le champs x de l' objet A. le x situé à droite de = est la valeur utilisée entre parenthèses. Ici, c' est 1. this.x = x; Le premier x est le champs et le deuxième x est l' argument entre la parenthèses du constructeur. Même raisonement pour y. Pour le deuxième constructeur, j' utilise le premier constructeur en faisant this(x, y); Le simple fait d' écrire this(x, y); signifie qu' il faut exécuter toutes les instructions qui se trouvent dans la définition du contruteur qui requiert 2 argument de même type que x et y ou d' un type compatible. Si vous écrivez this suivi de parenthèses à l' intérieur desquelles le nombre et/ou la qualité des paramètres ne correspond à aucun des constructeurs, le compilateur renvoie un message d ' erreur. La deuxième instruction permet de donner une couleur au point. Nous ne sommes pas encore en programmation graphique. Le résultat serait évident. Mais ici, on se contente de donner un nom à la couleur. Par exemple : this.couleur = "rouge"; Pourquoi utiliser plusiers constructeurs ? Tout dépend du programme. Parce que dans certaines situations, vous aurez envie de travailler avec certains champs des objets et pas avec d' autres. Donc vous aurez besoin de créer différent types d' objets de la même classe. La classe CompteBancaire est un bon exemple en ce sens. Autre chose : lorsqu' il y a plus d' un constructeur dans une classe, l' un des constructeurs ne fait pas forcément appel à un autre. On peut très bien créer un constructeur qui initialise une partie des champs. Puis u autre qui initialise d' autres champs qui n' ont rien à voir avec les premiers. Résumons aussi l' utilisation du mot clé this this, suivi d' un point et suivi du nom d' un champ veut dire qu"on parle du champ de l' objet courant. L' objet sur lequel on applique la méthode contenant ce mot this. Ou alors, l' objet qu' on est entrain de créer lorsque ce this, suivi du point et suivi du nom du champ se trouve dans le contructeur qu' on est entrain d' utiliser pour créer l' objet. Le mot this, suivi des parenthèses à l' intérieur desquelles ont trouve des paramètres, se trouve forcément dans un constructeur et nulle part ailleurs. Dans ce cas, this fait allusion à un autre constructeur dont le nombre et l' ordre des paramètres est le même que dans les parenthèses de this. |
Une classe qui sert à créer des objets Etudiant
1. public class Etudiant
2. {
3. private String nom;
4. private String prenom;
5. private String dateNaissance;
6. private String adresse;
7.
8. private Etudiant(String nom, String prenom, String dateNaissance)
9. {
10. this.nom = nom; this.prenom = prenom; this.dateNaissance = dateNaissance;
11. }
12. }
|
| Compilez cette classe. Il ne sera affiché aucun message d' erreur. Normal. Un constructeur peut être déclaré en private. Mais vous ne pourrez pas utiliser ce constructeur pour instancier des objets. |
EXEMPLE 8 :
1. public class ConstructeurCercle7
2. {
3. public static void main(String [] args)
4. {
5. Etudiant Jean = new Etudiant("DUPONT", "Jean", "12-04-1985");
6. }
7 }
|
|
Compilez ce programme. Il sera affiché le message d' erreur suivant : ConstructeurCercle7.java:5: Etudiant(java.lang.String,java.lang.String,java.lang.String) has private access in Etudiant Etudiant Jean = new Etudiant("DUPONT", "Jean", "12-04-1985"); ^ 1 error Ce qui veut dire que le constructeur Etudiant dont les arguments sont de type String, String et String (3 arguments donc), est déclaré private dans la classe Etudiant. On ne peut donc pas l' utiliser. Ce qui est Normal. Tout ce qui est privé ne peut être accessible en dehors de cette classe. Conséquence immédiate. Si vous déclarez un ou plusieurs constructeur en private, vous devez forcément en déclarer au moins un en public. Ce qui vous permettra alors d' instancier des objets. Dans cette classe qui permet d' instancier des objets Etudiants, il peut être indispensable de déclarer ce constructeur en private. Pourquoi ? Parce qu' une structure qui utilisera ce logiciel n' aura pas besoin de changer les noms, prénoms, et date de naissance d' un étudiant. Ce sont d' ailleurs des paramètres qui ne changent pas pour un étudiant donné. Ce qui n' est pas le cas d' une adresse. |
Une classe qui sert à créer des objets Etudiant
1. public class Etudiant2
2. {
3. private String nom;
4. private String prenom;
5. private String dateNaissance;
6. private String adresse;
7.
8. private Etudiant(String nom, String prenom, String dateNaissance)
9. {
10. this.nom = nom; this.prenom = prenom; this.dateNaissance = dateNaissance;
11. }
12.
13. public Etudiant(String nom, String prenom, String dateNaissance, String adresse)
14. {
15. this(nom, prenom, dateNaissance);
16. this.adresse = adresse;
17. }
18. }
|
| On peut faire appel à un constructeur private à l' intérieur d' un autre constructeur. Toujours, le mot clé this, suivi des parenthèses, est utilisé. |
| ← (précédent) C.1 La contruction d'une classe : la notion d'objet |
| C.3 La nature de l'objet → |
| Accueil ↔ S O M M A I R E |
C.2 Les constructeurs (d'objets) |