'>

L'objet en C sharp: autre méthode Initialise + Constructeurs de la classe Personne

 2.1.8 Une autre méthode Initialise
Considérons toujours la classe Personne et rajoutons-lui la méthode suivante :
1. public void Initialise(Personne p) {
2. prenom = p.prenom;
3. nom = p.nom;
4. age = p.age;
5. }
On a maintenant deux méthodes portant le nom Initialise : c'est légal tant qu'elles admettent des paramètres différents. C'est le cas
ici. Le paramètre est maintenant une référence p à une personne. Les attributs de la personne p sont alors affectés à l'objet courant
(this). On remarquera que la méthode Initialise a un accès direct aux attributs de l'objet p bien que ceux-ci soient de type private. C'est
toujours vrai : un objet o1 d'une classe C a toujours accès aux attributs des objets de la même classe C.
Voici un test de la nouvelle classe Personne :
1. using System;
2.
3. namespace Chap2 {
4. class Program {
5. static void Main() {
6. Personne p1 = new Personne();
7. p1.Initialise("Jean", "Dupont", 30);
8. p1.Identifie();
9. Personne p2 = new Personne();
10. p2.Initialise(p1);
11. p2.Identifie();
12. }
13. }
14.}
et ses résultats :
1. [Jean, Dupont, 30]
2. [Jean, Dupont, 30]

 2.1.9 Constructeurs de la classe Personne
Un constructeur est une méthode qui porte le nom de la classe et qui est appelée lors de la création de l'objet. On s'en sert
généralement pour l'initialiser. C'est une méthode qui peut accepter des arguments mais qui ne rend aucun résultat. Son prototype
ou sa définition ne sont précédés d'aucun type (pas même void).
Si une classe C a un constructeur acceptant n arguments argi, la déclaration et l'initialisation d'un objet de cette classe pourra se faire
sous la forme :
C objet =new C(arg1,arg2, ... argn);
ou
C objet;

objet=new C(arg1,arg2, ... argn);
Lorsqu'une classe C a un ou plusieurs constructeurs, l'un de ces constructeurs doit être obligatoirement utilisé pour créer un objet
de cette classe. Si une classe C n'a aucun constructeur, elle en a un par défaut qui est le constructeur sans paramètres : public C(). Les
attributs de l'objet sont alors initialisés avec des valeurs par défaut. C'est ce qui s'est passé lorsque dans les programmes précédents,
où on avait écrit :
Personne p1;
p1=new Personne();
Créons deux constructeurs à notre classe Personne :
1. using System;
2.
3. namespace Chap2 {
4. public class Personne {
5. // attributs
6. private string prenom;
7. private string nom;
8. private int age;
9.
10. // constructeurs
11. public Personne(String p, String n, int age) {
12. Initialise(p, n, age);
13. }
14. public Personne(Personne P) {
15. Initialise(P);
16. }
17.
18. // méthode
19. public void Initialise(string p, string n, int age) {
20....
21. }
22.
23. public void Initialise(Personne p) {
24....
25. }
26.
27. // méthode
28. public void Identifie() {
29. Console.WriteLine("[{0}, {1}, {2}]", prenom, nom, age);
30. }
31. }
32.
33.}
Nos deux constructeurs se contentent de faire appel aux méthodes Initialise étudiées précédemment. On rappelle que lorsque dans
un constructeur, on trouve la notation Initialise(p) par exemple, le compilateur traduit par this.Initialise(p). Dans le constructeur, la
méthode Initialise est donc appelée pour travailler sur l'objet référencé par this, c'est à dire l'objet courant, celui qui est en cours de
construction.
Voici un court programme de test :
1. using System;
2.
3. namespace Chap2 {
4. class Program {
5. static void Main() {
6. Personne p1 = new Personne("Jean", "Dupont", 30);
7. p1.Identifie();
8. Personne p2 = new Personne(p1);
9. p2.Identifie();
10. }
11. }
12.}
13.
et les résultats obtenus :
[Jean, Dupont, 30]
[Jean, Dupont, 30]

Publié par Drupal french Study