Le document présente les concepts fondamentaux de la programmation orientée objet (POO), y compris les notions de classes, méthodes, héritage et encapsulation, en utilisant C# comme langue de référence. Il explique comment les classes sont des modèles pour créer des objets contenant des attributs et des méthodes, tout en mettant l'accent sur la modularité et la réutilisation du code. Des exemples pratiques illustrent la définition de classes, l'utilisation de constructeurs, de propriétés et de méthodes, ainsi que la gestion de l'accès aux données d'instance.

1. Licence professionnelle QCI Programmation orient´e objet
e
Universit´ Robert Schuman
e 2008/09
Programmation Objet - C#
c Benoˆ Caldairou, 2008
ıt
1 Introduction
1.1 Qu’est-ce que la programmation orient´e objet ?
e
Contrairement ` la programmation dite imp´rative, qui n’est qu’un simple
a e
traitement sur des donn´es, la programmation orient´e objet (ou POO) est une
e e
technique visant ` faire interagir des objets entre eux, permettant une meilleure
a
modularit´ et une plus grande souplesse de la programmation.
e
Ainsi, un objet va ˆtre constitu´ par l’association d’une quantit´ d’informa-
e e e
tion organis´e en champs (nom, pr´nom, age, notes pour un ´tudiant ; marque,
e e e
mod`le, cylindr´e, vitesse pour une voiture) et d’un ensemble de m´thodes (plus
e e e
ou moins ´quivalentes ` des fonctions) permettant d’interagir avec lui (calculer
e a
la moyenne d’un ´tudiant ou acc´l´rer pour une voiture).
e ee
Cette technique de programmation a principalement deux objectifs :
– Faciliter l’´criture des applications par une structuration en terme d’ob-
e
jets.
– Favoriser la r´utilisation de code, en composant des programmes ` partir
e a
d’objets existants (par exemple, la biblioth`que standart de C++, de Java,
e
. . . ).
Deux notions essentielles sont caract´ristiques de la POO :
e
– La notion de classe : sch´matiquement, une classe repr´sente le type d’un
e e
objet, tout comme int repr´sente un r´el. Elle peut ˆtre vu comme une
e e e
sorte de super-structure.
– La notion de m´thode : sch´matiquement, une m´thode est une fonction
e e e
appartenant ` une classe et permettant d’agir sur et avec l’objet.
a
1.2 Concepts clefs de la programmation orient´e objet
e
La POO a introduit des concepts permettant une bien meilleure souplesse
de programmation ainsi qu’une plus grande s´curit´.
e e
Dans un soucis de r´utilisation du code, une classe doit ˆtre sufisamment
e e
bien con¸u pour qu’un programmeur n’ait pas ` s’inqui´ter de l’´tat interne
c a e e
d’un objet, mais se contente de savoir de quelle mani`re il interagit avec son
e
environnement. Cette volont´ de masquer la repr´sentation de l’objet s’appelle
e e
l’encapsulation et am`ne aussi une s´curit´ du code dans la mesure ou l’´tat
e e e e
de l’objet ne peut ˆtre chang´ que de mani`re explicite. Cel` permet aussi de
e e e a
modifier la repr´sentation d’une classe sans forc´ment modifier les interactions
e e
et donc les programmes d´pendants de ces classes.
e
1

2. Toujours dans un soucis d’efficacit´ et de modularit´, la POO a introduit la
e e
notion d’h´ritage entre les classes. Tr`s sch´matiquement, on peut d´finir grˆce
e e e e a
` l’h´ritage une classe dite « m`re » ` partir de laquelle on va d´finir plusieurs
a e e a e
classes dites « filles » ayant en commun les caract´ristiques de la classe m`re.
e e
Cela permet une ´conomie du code et favorise sa r´utilisation.
e e
La POO introduit enfin des concepts plus avanc´s tels que le polymorphisme
e
et la g´n´ricit´ qui seront abord´s ult´rieurement.
e e e e e
1.3 Principales notions de base
1.3.1 Classe
Sch´matiquement, une classe est la « description » d’une collection objets
e
homog`nes. La notion de classe peut ˆtre utilis´ de plusieurs fa¸ons :
e e e c
– pour d´finir un ensemble de sous-programmes (classes utilitaires) ;
e
– pour d´finir un nouveau type d’objet, par exemple un objet de type voi-
e
ture, de type personne ou de type ´l`ve.
ee
Une classe doit n´cessairement comporter les ´l´ments suivants :
e ee
– les champs : ce sont les « variables » permettant, en g´n´ral, de d´finir
e e e
l’´tat de l’objet.
e
– un ou plusieurs constructeurs : ce sont des fonctions indiquant de quelle
fa¸on l’objet doit ˆtre d´clar´ et initialis´.
c e e e e
– les m´thodes : ce sont les fonctions permettant d’agir sur les objets d’une
e
classe. Selon leur d´finition, elle peuvent s’appliquer sur un objet particu-
e
lier, ou sur l’ensemble des instances d’une classe.
1.3.2 Objet
Nous avons vu pr´c´demment qu’un objet est une « instance » de classe. Par
e e
analogie, on peut aussi consid´rer une classe comme le type d’une variable et
e
l’objet comme la valeur de cette mˆme variable.
e
A sa cr´ation, un objet est contruit et initialis´ grˆce a un constructeur et il
e e a `
va rester en m´moire jusqu’` la fin de la fonction qui l’emploie, de la mˆme fa¸on
e a e c
qu’une variable. Au moment de sa destruction, un fonction sp´ciale, appell´e un
e e
destructeur, est appel´e, qui est ici masqu´ par le language C# (ainsi qu’en
e e
Java) contrairement ` d’autre languages orient´s objets comme le C++ qui
a e
n´cessitent une d´finition formelle du destructeur au mˆme titre que la d´finition
e e e e
d’un constructeur.
2 Notion de classe
Dans la suite de ce cours, nous allons consid´rer ` titre illustratif une classe
e a
Personne dont on veut stocker les nom, pr´nom, ˆge et num´ro de t´l´phone
e a e ee
tout ´tant capable de modifier et d’afficher ces informations.
e
2.1 G´n´ralit´s
e e e
De mani`re formelle, une classe d´clare un ensemble d’injonctions communes
e e
` une famille d’objets (des attributs pour l’´tat de l’objet et des m´thodes
a e e
2

3. repr´sentant le comportement de l’objet). Un bon exemple de classe existante
e
est la classe string ou encore la classe list.
En C#, une classe sera toujours d´finie de la mani`re suivante :
e e
public class Personne
{
//D´claration des champs
e
...
//D´claration des contructeurs
e
...
//D´claration des m´thodes
e e
...
}
2.2 Champs
Comme dit plus haut, les champs repr´sentent les « variables » traduisant
e
l’´tat de l’objet (comme avec les champs des structures). Ces variables peuvent
e
ˆtre de toutes natures : des entiers, des chaˆ
e ınes de caract`res, des listes, d’autres
e
objets, etc. . . Par convention, leur nom commencent toujours par une minuscule.
Dans le cas de notre classe personne, nous allons d´clarer les champs sui-
e
vants : nom, pr´nom, age et num´ro de t´l´phone :
e e ee
public class Personne
{
private string nom;
private string prenom;
private int age;
private int telephone;
}
Le mot clef public devant le mot clef class indique que la classe Personne
est accessible depuis n’importe quelle partie du programme. Elle aura aussi son
importance au moment ou nous aborderons l’h´ritage.
e
Le mot clef private devant les champs indique ici que ces variables ne sont pas
accessibles en dehors de la classe personne. Un programmeur utilisant la classe
personne ne pourra donc pas utiliser ces variables directement dans d’autres
fonction sauf si private est remplac´ par le mot clef public. Si aucun mot clef
e
n’est pr´cis´, private sera ajout´ par d´faut ` la compilation.
e e e e a
2.3 Constructeurs
Un contructeur est une fonction appell´e au moment de la cr´ation d’un objet
e e
` partir d’une classe. Il permet d’initialiser correctement cet objet, ´ventuellement
a e
a
` partir de param`tres.
e
Plusieurs contructeurs peuvent ˆtre d´finis.
e e
public class Personne
{
3

4. //Champs
private string nom;
private string prenom;
private int age;
private int telephone;
//Constructeurs
public personne(){} //Constructeur par d´faut
e
public personne(string nom, string prenom,
int age, int telephone)
{
this.nom = nom;
this.prenom = prenom;
this.age = age;
this.telephone = telephone;
}
public personne(personne p)
{
this.nom = p.nom;
this.prenom = p.prenom;
this.age = p.age;
this.telephone = p.telephone;
}
}
Le mot clef this est une r´f´rence sur l’instance courante. Elle permet d’acc´der
ee e
` l’objet appelant depuis la m´thode et aussi d´viter les confusions lorsque deux
a e e
variables ont le mˆme nom. Par exemple, dans le deuxi`me constructeur, le fait
e e
d’´crire this.nom permet de ne pas confondre le champ nom de l’objet personne
e
avec la variable nom pass´e en param`tre pour l’initialisation. Le troisi`me
e e e
constructeur est un constructeur particulier dans le sens ou il cr´e un objet per-
e
sonne en copiant les informations contenues dans un autre objet personne. On
appelle cela un constructeur par copie.
Le premier constructeur est aussi un peu particulier vu qu’il ne prend aucun
param`tre en entr´e. Il est cependant essentiel de le d´finir afin d’´viter les
e e e e
surprises au moment de l’ex´cution et il est aussi utile si on d´finit une classe-
e e
fille comme nous le verrons ult´rieurement.
e
2.4 Propri´t´s
e e
Nous avons vu qu’en rendant les champs priv´s, un programmeur utilisateur
e
de la classe personne ne pourra pas lire, ni ´crire de valeur dans ces variables. Le
e
comportement de l’objet devient alors ´quivalent ` celui d’une boite noire dont
e a
on ne peut pas connaitre l’´tat interne. Cependant, il se peut que le program-
e
meur ait besoin de connaitre ces informations et ait aussi besoin de les mettre ` a
jour. Pour ´viter de violer le principe d’encapsulation, nous allons donc d´finir
e e
des moyens d’acc´der ` ces variables ` travers des propri´t´s. Une propri´t´
e a a ee ee
permet de d´finir des acc`s en consultation (get ) et en modification (set ). Un
e e
4

5. acc`s en consultation ou en modification est possible uniquement si le get ou set
e
correspondant est d´finie.
e
La syntaxe d’une propri´t´ se d´finit de la mani`re suivante :
ee e e
public int Age
{
get
{
return this.age;
}
set
{
this.age = value;
}
}
Le mot clef public indique bien que la propri´t´ peut ˆtre utilis´e dans n’im-
ee e e
porte quelle partie du code et que le mot clef int indique bien que get renvoie
une valeur de type int et que set attend une valeur de type int.
Un autre exemple avec le champ nom :
public string Nom
{
get
{
return this.nom;
}
set
{
if (value == null || value.Trim().Length == 0)
{
Console.WriteLine("Nom Invalide");
nom = null;
}
else
{
nom = value;
}
}
}
Ici, pour ´viter qu’une erreur ne survienne au moment de l’execution, il vaut
e
mieux v´rifier que la param`tre pass´ ` set soit effectivement initialis´ et qu’il
e e ea e
ait une longueur sup´rieure ` 0.
e a
2.5 M´thodes
e
Les m´thodes sont des « sous-porgrammes » propres ` agir sur les objets
e a
d’une classe. Elles sont assimilables ` des fonctions sauf qu’elles sont g´n´ralement
a e e
5

6. appel´s par des objets et agissent potentiellement sur eux.
e
2.5.1 M´thodes d’instance
e
Ces m´thodes d´crivent des op´rations effectu´es sur une instance parti-
e e e e
culi`re de la classe (c’est-`-dire sur un seul objet).
e a
Un bon exemple est la m´thode de la classe string (chaˆ
e ınes de caract`res)
e
ToLower() qui permet de passer toutes les lettres d’une chaˆ en minuscules
ıne
de la fa¸on suivante :
c
string s = new string("Une souris Verte
qui Courait dans l’herBe");
s = s.ToLower();
Cette op´ration va transformer le contenu de s en : une souris verte qui
e
courait dans le pr´.
e
2.5.2 Champs, m´thodes et propri´t´s de classe
e e e
Les champs de classe sont des champs que les objets d’une mˆme classe vont
e
partager. De mˆme, les m´thodes et les propri´t´s de classe sont des m´thodes
e e ee e
qui vont affecter l’ensemble des objets d’une classe.
Reprenons notre classe Personne. Nous aimerions disposer d’un compteur
permettant de connaitre en permanence combien d’instances de Personne il
existe. Il suffit alors de d´clarer un champ d’instance de la mani`re suivante :
e e
private static int nbPersonne;
Remarquez au passage le mot clef static qui indique que ce champ est un
champ de classe.
Il faut alors red´finir les constructeur de la mani`re suivante :
e e
public class Personne
{
//Constructeurs
public personne(){nbPersonne++;} //Constructeur par d´fault
e
public personne(string nom, string prenom,
int age, int telephone)
{
this.nom = nom;
this.prenom = prenom;
this.age = age;
this.telephone = telephone;
nbPersonne++;
}
public personne(personne p)
{
this.nom = p.nom;
this.prenom = p.prenom;
this.age = p.age;
6

7. this.telephone = p.telephone;
nbPersonne++;
}
}
De mani`re ` acc´der ` la variable nbPersonne, on d´finit une propri´t´ de
e a e a e ee
classe permettant un acc`s en lecture seule. En effet, il est pr´f´rable de ne pas
e ee
laisser de possibilit´ au programmeur de modifier cette variable autrement qu’en
e
cr´ant diff´rentes personnes.
e e
public static long NbPersonne
{
get { return nbPersonne; }
}
Pour les m´thodes, cela fonctionne de la mˆme fa¸on. Il suffit d’ajouter le
e e c
mot clef static pour la d´clarer comme ´tant de classe. Elle s’appliquera alors
e e
sur l’ensemble des instances d’une classe.
2.5.3 Surcharge de m´thodes
e
Nous avons vu pr´cedemment que nous pouvions donner plusieurs formes
e
de constructeur qui ayant pour objectifs d’initialiser un objet, mais avec des
comportements diff´rents.
e
Le C# autorise le mˆme genre de comportement pour les m´thodes. On
e e
peut appeller plusieurs m´thodes par le mˆme nom (la logique veut que ces
e e
m´thodes aient un comportement similaire) tout en leur donnant des param`tres
e e
diff´rents. On appelle cel` la surcharge de m´thode. Cela s’applique aussi bien
e a e
aux m´thodes d’instance qu’aux m´thodes de classes. Un exemple concret se
e e
trouve dans la classe string avec l’ensemble des m´thodes IndexOf(. . . ), per-
e
mettant de chercher l’index (ou la position dans la chaˆıne) d’un caract`re ou
e
d’une sous-chaˆ de caract`res.
ıne e
//m´thodes
e surcharg´es
e
public int IndexOf(char value)...
public int IndexOf(string value)...
public int IndexOf(char value, int startIndex)...
public int IndexOf(string value, int startIndex)...
La diff´rence entre ces m´thodes se fait par le nombre de param`tres, leur
e e e
type et leur ordre.
2.6 Op´rateurs
e
Les op´rateurs d´finis pour une classe sont identifi´s par des symboles tels
e e e
que =, +, -, ==, ¡=, . . . Cependant, d’un point de vue logique, ces op´rateurs
e
ne sont pas diff´rents des fonctions. Ils doivent ˆtre d´finis de la mˆme mani`re,
e e e e e
cependant leur utilisation est plus intuitive.
Voici un exemple d’op´rateur permettant de savoir si deux personnes sont
e
identiques :
7

8. public static bool operator ==(Personne a, Personne b)
{
if(a.nom == b.nom && a.prenom == b.prenom &&
a.age == b.age && a.telephone == b.telephone)
return 1;
else
return 0;
}
Remarquez l’utilisation du mot clef static car il s’agit d’une « m´thode » de
e
classe, ´tant donn´ que cet op´rateur doit pouvoir s’appliquer indiff´remment `
e e e e a
n’importe quelles instances de la classe.
Dans le programme principale, il sera utilis´ de la fa¸on suivante :
e c
//On suppose que deux instances de Personnes p1 et p2
//ont d´j` ´t´ initialis´e
e a e e e
if(p1 == p2)
Console.WriteLine("p1 et p2 sont la m^me personne");
e
else
Console.WriteLine("p1 et p2 sont deux personnes diff´rentes");
e
2.7 Notions de mutabilit´
e
Ce terme d´signe le fait qu’une instance de classe puisse ˆtre modifi´e ou
e e e
pas au cours de l’ex´cution du programme (c’est-`-dire modifier ses champs).
e a
Par exemple dans le cas de notre classe Personne, le fait d’autoriser l’acc`s en
e
´criture sur les champs rend la classe mutable. Il suffirait de supprimer cette
e
possibilit´ pour rendre cette classe non mutable.
e
2.8 En exemple complet : la classe Personne
Voici l’impl´mentation compl`te de la classe personne d´finie tout au long
e e e
de cette section :
public class Personne
{
//Champ et propri´t´ de classe
e e
private static int nbPersonne;
public static long NbPersonne
{
get { return nbPersonne; }
}
//Champs d’instance
private string nom;
private string prenom;
private int age;
private int telephone;
//Constructeurs
8

9. public personne(){nbPersonne++;} //Constructeur par d´fault
e
public personne(string nom, string prenom, int age, int telephone)
{
this.nom = nom;
this.prenom = prenom;
this.age = age;
this.telephone = telephone;
nbPersonne++;
}
public personne(personne p)
{
this.nom = p.nom;
this.prenom = p.prenom;
this.age = p.age;
this.telephone = p.telephone;
nbPersonne++;
}
//Propri´t´
e e
public string Nom
{
get
{
return this.nom;
}
set
{
if (value == null || value.Trim().Length == 0)
{
Console.WriteLine("Nom Invalide");
nom = null;
}
else
{
nom = value;
}
}
}
public string Prenom
{
get
{
return this.prenom;
}
set
9

10. {
if (value == null || value.Trim().Length == 0)
{
Console.WriteLine("Pr´nom Invalide");
e
prenom = null;
}
else
{
prenom = value;
}
}
}
public int Age
{
get
{
return this.age;
}
set
{
this.age = value;
}
}
public int Telephone
{
get
{
return this.telephone;
}
set
{
this.telephone = value;
}
}
//Op´rateur
e
public static bool operator ==(Personne a, Personne b)
{
if(a.nom == b.nom && a.prenom == b.prenom && a.age == b.age && a.telephone == b.tele
return 1;
else
return 0;
}
//M´thode
e
public string Identifie()
10

11. {
string s = "p=(" + this.prenom + "," + this.nom + "," + p.age + "," + p.telephone ")
return s;
}
}
3 Notion d’objet
Par d´finition, un objet est une instance d’une classe. Tandis qu’une classe est
e
une repr´sentation abstraite, l’objet repr´sente quelque chose de tr`s concret vu
e e e
qu’il est stock´ en m´moire et qu’on peut agir sur lui par le biais des m´thodes,
e e e
propri´t´s et op´rateurs. Un exemple pour illustrer ce propos : la plan d’une
ee e
maison repr´sente la classe et on peut contruire une multitude de maison sur ce
e
mod`le.
e
3.1 Cr´ation
e
La cr´ation d’un objet ob´it ` des r`gles logiques et syntaxiques particuli`re.
e e a e e
En effet, si vous vous contentez de d´clarer :
e
Personne p1;
rien ne va se passer. Il faut comprendre que vous vous ˆtes content´ de d´clarer
e e e
une variable de type Personne. Mais cette variable n’est rien de plus qu’une
coquille vide. Les champs ne sont pas remplit et il est impossible d’utiliser les
m´thodes pour la simple et bonne raison que la Personne p1 n’existe pas encore.
e
Pour pouvoir utiliser cette variable ` notre convenance, il va falloir contruire
a
la Personne. Pour ce faire, nous utilisons la syntaxe suivante :
p1 = new Personne("Dupond", "Jacques", 24, 0601020304);
On pourrait contracter l’ensemble de la fa¸on suivante :
c
Personne p1 = new Personne("Dupond", "Jacques", 24, 0601020304);
`
A partir de ce moment, l’objet est construit et on peut l’utiliser normalle-
ment.
Nous avions aussi d´fini une constructeur dit « par copie ». Voici la fa¸on de
e c
l’utiliser :
Personne p2 = new Personne(p1);
On cr´e une Personne p2 en copiant toute les informations contenues dans
e
p1.
11

12. 3.2 R´f´rence
ee
3.2.1 Retour sur les variables
Dans un programme informatique, la manipulation de donn´es se fait par
e
l’interm´diaire de variables. Ces variables r´sident en m´moire centrale sur la
e e e
pile d’ex´cution. Une variable de type primitif (char, int, bool, . . . ) contient
e
directement sa valeur. Par contre, une variable d’un type plus complexe (tableau,
string, list, objet) contient une r´f´rence qui va pointer sur des donn´es pr´sentes
ee e e
sur le tas.
3.2.2 R´f´rences particuli`res
ee e
Le mot clef this est utilis´ exclusivement dans la d´finition d’une classe
e e
comme r´f´rence ` l’objet courant. Ainsi, il ne peut ˆtre utilis´ que dans des
ee a e e
m´thodes et des propri´t´s d’instance. L’utiliser dans des m´thodes de classe
e ee e
serait un non-sens.
Le mot clef null repr´sente quant ` lui une absence de r´f´rence. C’est une
e a ee
mani`re d’expliciter qu’une variable est une coquille vide. Il peut ˆtre affect´ `
e e ea
toute variable.
3.2.3 Retour sur new
Le mot clef new n’est utilis´ que lors de la construction d’un nouvel objet.
e
Il permet l’allocation dynamique de la m´moire n´c´ssaire ` cette nouvelle ins-
e e e a
tance dans le tas. Il renvoie ainsi une r´f´rence vers la nouvelle instance cr´e.
ee e
Cette r´f´rence sera alors stock´e dans la pile. Ce proc´d´ rend chaque instance
ee e e e
unique et toute modification d’une propri´t´ sur une instance n’aura aucune
ee
cons´quence sur une autre (` part si il s’agit de champs de classes).
e a
3.2.4 R´f´rence et affectation
ee
Imaginons que nous d´clarons deux variable Personne p1 et p2 :
e
Personne p1 = new Personne("Dupond", "Jean", 44, 0601020304);
Personne p2;
p2 = p1;
La question est de savoir ce qu’il va se passer au moment de p2 = p1.
Premi`re remarque, nous n’avons pas utilis´ le mot clef new pour p2. Je n’ai
e e
donc pas construit de nouvel objet. Ainsi, les variables p2 et p1 « pointent »
sur le mˆme objet. Elles ont donc la mˆme r´f´rence et on peut ` ce moment
e e ee a
utiliser indiff´remment p1 ou p2 pour agir sur l’objet consid´r´. Retenez donc
e e e
que affectation et construction ne sont pas la mˆme chose.
e
3.2.5 Comparaison de r´f´rence
ee
Dans le cas ou le programmeur n’aurait pas surcharg´ les op´rateurs ==
e e
et != d’une classe, ces deux op´rateurs comparent deux r´f´rences. Ainsi, dans
e ee
l’exemple pr´c´dent, p1 == p2 retournera un r´sultat positif. Il faut cependant
e e e
faire attention ` ne pas confondre comparer les r´f´rences avec comparer les
a ee
valeurs des objets.
12

13. 3.3 Utilisation
La syntaxe pour manipuler les champs et m´thodes d’un objet suit le proto-
e
type suivant : [nom de l’objet].[nom de la m´thode ou du champ]. Par exemple,
e
dans le cas de l’objet p1 de type Personne : p1.nom.
3.3.1 Utilisation des champs
Nous avions d´clar´ tous les champs comme private. Ce qui fait qu’` la
e e a
compilation, la moindre occurence du type p1.nom, p2.telephone, . . . se traduira
par une erreur de compilation pour violation du principe d’encapsulation. Une
solution serait de d´clarer ces champs comme public. Cepedant, nous avions
e
utiliser le terme private pour des raisons de s´curit´ et pour rendre le code
e e
plus fonctionnel. Pour acc´der aux champs, nous allons donc devoir utiliser les
e
propri´t´s qui ont pour m´rite d’expliciter la lecture et l’´criture des champs.
ee e e
Personne p = new Personne("Jean", "Michelin", 34, 0601020304);
Console.Out.WriteLine("p=(" + p.Prenom + "," +
p.Nom + "," + p.Age + ")");
p.Age = 56;
Console.Out.WriteLine("p=(" + p.Prenom + "," +
p.Nom + "," + p.Age + ")");
La d´finition de m´thodes get au sein de ces propri´t´s permet de lire les
e e ee
champs et la d´finition de m´thodes set permet tout simplement de modifier la
e e
valeur de ces champs. Dans l’exemple pr´c´dent, l’absence de set aurait entrain´
e e e
une erreur de compilation pour p.Age = 56 et l’absence de methode get aurait
empˆch´ l’affichage sur la console.
e e
3.3.2 Utilisation des m´thodes et des op´rateurs
e e
Les op´rateurs d´finis ou surcharg´s dans des classes s’utilisent exactement
e e e
de la mˆme fa¸on que des op´rateurs normaux. Il suffit de faire bien attention `
e c e a
leur d´finition et ` leur fonctionnement et de les rendre le plus intuitifs possible.
e a
Par exemple, d´finir un op´rateur ¿ dans la cas de la classe Personne n’aurait
e e
aucun sens, alors qu’il en aurait un pour une classe Fraction.
Concernant les m´thodes, elles s’utilisent de la mˆme fa¸on qu’une fonc-
e e c
tion normale avec passage de param`tres et un type de sortie. Par exemple, la
e
m´thode identifie sera utiliser de la fa¸on suivante :
e c
Personne p = new Personne("Jean", "Michelin", 34, 0601020304);
Console.WriteLine(p.Identifie());
La fonction WriteLine demande un param`tre string, fournit par la sortie de
e
la m´thode Identifie.
e
N´anmoins, il faut garder en m´moire que les m´thodes sont « appel´es »
e e e e
par un objet et font donc partie d’un ´cosyst`me particulier.
e e
3.4 Exemple
Voici un exemple d’utilisation de la classe Personne :
13

14. Personne p1 = new Personne("Jean", "Michelin", 34, 0601020304);
Personne p2 = new Personne("Jean", "Micheline", 34, 0601020305);
Personne p3 = new Personne(p1);
Personne p4 = p2;
Console.WriteLine(p1.Identifie());
Console.WriteLine(p3.Identifie());
p3.Age = 44;
Console.WriteLine(p1.Identifie());
Console.WriteLine(p3.Identifie());
Console.WriteLine(p2.Identifie());
Console.WriteLine(p4.Identifie());
p2.Age = 44;
Console.WriteLine(p2.Identifie());
Console.WriteLine(p4.Identifie());
Exercice : essayer de pr´voir ce que le programme va afficher dans la console.
e
4 H´ritage
e
4.1 Concepts
L’h´ritage est une technique permettant de d´finir une classe ` partir d’une
e e a
classe existente. Par exemple, ` partir de la classe Personne apportant d´j` les
a ea
champs nom, prenom, age, telephone ainsi que quelques propri´t´s et m´thodes,
ee e
nous allons pouvoir d´finir d’autres classes dite classes-filles. Par exemple, si
e
l’on veut mod´liser le fonctionnement d’une universit´, nous pourrons cr´er les
e e e
classes ´tudiants, professeurs, personnels techniques,. . . ou pour mod´liser un
e e
avion de ligne, nous pourrons creer les classes pilotes, hˆtesses et passagers. Ce
o
m´canisme est une sp´cialisation, ou une g´n´ralisation selon les cas, ` partir
e e e e a
d’une classe m`re regroupant leurs propri´t´s communes.
e ee
L’h´ritage est donc un m´canisme de r´utilisation du code ou seul les diff´rences
e e e e
entre les classes sont explicit´es. On parle alors de classe m`re et de classe fille.
e e
Une chose ` retenir en C#, l’h´ritage est dit : h´ritage simple car une classe
a e e
fille ne peut peut avoir qu’une seule classe m`re (comme en Java) ` la diff´rence
e a e
d’autres languages comme le C++.
Une derni`re chose permise par l’h´ritage est la red´finition de m´thodes
e e e e
n’ayant pas le fonctionnement souhait´ dans la classse fille. La m´thode est
e e
alors red´finie pour adapter son comportement.
e
Voici la syntaxe pour d´clarer qu’une classe h´rite de la classe m`re Per-
e e e
sonne :
public class Passager : Personne
{
14

15. ...
}
C’est le symbole : qui permet d’expliciter que la classe Passager et l’h´riti`re
e e
de la classe Personne.
4.2 Champs
Une classe fille conserve l’ensemble des champs de la classe m`re mais peut
e
n´anmoins ajouter d’autres champs. Par exemple, dans le cas d’un passager, on
e
pourrait rajouter son num´ro de si`ge et le prix de son billet.
e e
public class Passager : Personne
{
//Champs
private int siege;
private double prix_billet;
}
Dans la cas d’un pilote, on pourra rajouter son nombre d’heures de vol ainsi
que son salaire.
public class Pilote : Personne
{
//Champs
private int heures_vol;
private double salaire;
}
Cependant, il faut faire attention ` l’application du principe d’encapsulation.
a
Mˆme si les classes Passager et Pilote sont tr`s proches de la classe Personne,
e e
le fait que les champs d´finis dans Personne le soit avec le mot clef private
e
les oblige ` utiliser les propri´t´s pour y acc´der. Ce mode de fonctionnement
a ee e
n’´tant pas tr`s pratique, il existe un autre mot clef permettant l’acc`s des
e e e
champs d’une classe ` ses classes filles : protected. Cela reviendrait ` d´finir la
a a e
classe Personne de la mani`re suivante :
e
public class Personne
{
//Champs
protected string nom;
protected string prenom;
protected int age;
protected int telephone;
}
De cette mani`re, les classes Passager et Pilote peuvent utiliser ces champs
e
directement, facilitant la programmation.
Retenez surtout que protected permet l’acc`s au champs uniquement aux
e
classes-filles de Personne, tandis que public autorise cet acc`s ` l’ensemble du
e a
programme et que private restraint cet acc`s aux m´thodes des objets de types
e e
Personne.
15

16. 4.3 Constructeur
Contrairement aux m´thodes, champs et propri´t´s, une classe fille n’h´rite
e ee e
pas des constructeur de sa classe m`re. Les constructeurs doivent donc ˆtre
e e
red´finis. On peut cependant faire appel aux constructeurs de la classe m`re
e e
dans un soucis de r´utilisation du code.
e
public Passager(string nom, string prenom, int age, int telephone,
int siege, double prix_billet) :
base(nom, prenom, age, telephone)
{
this.siege = siege;
this.prix_billet = prix_billet;
}
Le mot clef base appelle le constructeur correspondant de la classe Personne.
Si l’appel par le mot clef base est absent, alors le compilateur va se tourner
vers un constructeur sans param`tre de Personne, (qui doit ˆtre pr´alablement
e e e
d´finis) et renverra une erreur si ce contructeur n’existe pas.
e
Retenez bien qu’un objet Passager est aussi une Personne et doit donc ˆtre
e
instanci´ comme une Personne avant de pouvoir ˆtre d´clarer comme un Passa-
e e e
ger.
4.4 M´thodes
e
Certaines m´thodes d’une classe m`re peuvent ne plus ˆtre adapt´e ` sa/ses
e e e e a
classe(s) fille(s). Il faut alors red´finir la m´thode en question.
e e
Par exemple, la m´thode Identifie() de la classe Personne ne permet pas de
e
rendre compte de l’ensemble des informations pr´sentes dans la classe Passager.
e
Il nous faut donc la compl´ter de la mani`re suivante :
e e
public string Identifie()
{
string s = base.Identifie() + "," + this.siege + "," +
this.prix_billet + ")";
return s;
}
Encore une fois, notez l’utilisation du mot clef base de mani`re ` r´utiliser
e a e
la m´thode de la classe m`re. on pourrait tr`s bien se passer de l’utilisation de
e e e
ce mot clef, l’essentiel ´tant que la m´thode Identifie soit adapt´e ` la classe On
e e e a
aurait tout aussi bien ´crire cette m´thode de la fa¸on suivante :
e e c
public string Identifie()
{
string s = "p=(" + this.prenom + "," + this.nom + ","
+ this.age + "," + this.telephone + "," +
this.siege + "," + this.prix_billet + ")";
return s;
}
Il faudra aussi penser ` red´finir les op´rateurs si n´cessaire.
a e e e
16

17. 4.5 Remarques compl´mentaires
e
La relation induite par l’h´ritage simple permet de constituer un arbre
e
d’h´ritage. Cet outil doit ˆtre consid´r´ comme une aide ` la conception d’un
e e e e a
programme permettant de hi´rarchiser ses classes et de voir si certaines peuvent
e
faire l’objet d’une classe m`re commune permettant un gain de temps certain
e
au niveau de la programmation.
Une derni`re pr´cision concernant le vocabulaire : une classe fille est aussi
e e
appell´e une sous-classe et une classe m`re, une superclasse.
e e
4.6 Exemple
Pour la classe m`re, reportez au code de la classe Personne d´finis ` la
e e a
deuxi`me section. Seul les champs d’instance sont d´clar´s comme protected
e e e
plutˆt que private.
o
public class Passager : Personne
{
//Champs
private int siege;
private double prix_billet;
//Constructeur
public Passager(string nom, string prenom, int age,
int telephone, int siege, double prix_billet) :
base(nom, prenom, age, telephone)
{
this.siege = siege;
this.prix_billet = prix_billet;
}
//Propri´t´s
e e
public int Siege
{
get
{
return this.siege;
}
set
{
this.siege = value;
}
}
public double Prix_Billet
{
get
{
return this.prix_billet;
}
17

18. set
{
this.prix_billet = value;
}
}
//Op´rateur
e
public static bool operator ==(Passager a, Passager b)
{
if(a.nom == b.nom && a.prenom == b.prenom &&
a.age == b.age && a.telephone == b.telephone &&
a.siege == b.siege && a.prix_billet == b.prix_billet)
{
return 1;
}
else
return 0;
}
//M´thode
e
public string Identifie()
{
string s = base.Identifie() + "," + this.siege + "," +
this.prix_billet + ")";
return s;
}
}
Litt´rature
e
– http ://www.csharp-station.com
– http ://csharp.net-tutorials.com
– Serge Tah´. Apprentissage du langage C# 2008 et du Framework .NET
e
3.5 (2008). (http ://tahe.developpez.com/dotnet/csharp/)
18