1 / 16

Les concepts de la
Contenu
1.

Introduction....................................................................................................................................................2
1.1.
1.2.
1.3.

2.

Notion dencapsulation...................................................................................................... 2
Notion dabstraction........................................................................................................... 3
Pourquoi abstraire/encapsuler ?......................................................................................... 3

Objet, classe et instance..................................................................................................................................3

2.1.
2.2.

3.

Dfinition dun objet.......................................................................................................... 3

Classe et instance.............................................................................................................. 3

Les proprits..................................................................................................................................................4
3.1.
3.2.
3.3.
3.4.

4.
5.

Dclaration des proprits................................................................................................. 4

Exercice :........................................................................................................................... 5
Protection des proprits................................................................................................... 5
Exercice............................................................................................................................. 6

Instanciation...................................................................................................................................................6
Les Constructeurs...........................................................................................................................................7

5.1.
5.2.
5.3.
5.4.
5.5.

Constructeur par dfaut..................................................................................................... 7

Constructeur avec paramtres........................................................................................... 7
Constructeur sans paramtres........................................................................................... 7
Constructeur de recopie..................................................................................................... 8
Exercices............................................................................................................................ 8

5.5.1.
5.5.2.

6.
7.
8.
9.

programmation oriente objet

Tp 1:............................................................................................................................ 8
TP1 :............................................................................................................................ 8

Les mthodes.................................................................................................................................................10
Les destructeurs............................................................................................................................................10
Accs aux proprits et aux mthodes.........................................................................................................11
8.1.

Exercices :........................................................................................................................ 11

Encapsulation protection et accs aux donnes membres..........................................................................11

9.1.
9.2.
9.3.

Protection des proprits................................................................................................. 11

Fonctions d'accs aux proprits..................................................................................... 12
Exercice :......................................................................................................................... 12

10.

Membres particuliers dune classe...........................................................................................................13

11.
12.
13.

Accs aux attributs de classe....................................................................................................................13

Accs aux attributs de classe par les proprites.......................................................................................14
Lhritage..................................................................................................................................................14

10.1.

13.1.
13.2.
13.3.
13.1.
13.2.
13.3.

Proprits de classe...................................................................................................... 13

L'hritage...................................................................................................................... 14
Protection des proprits et des mthodes...................................................................15
Compatibilit et affectation.......................................................................................... 17
Constructeur et hritage............................................................................................... 18
Appel aux mthodes de la classe de base....................................................................20
Insertion d'une nouvelle classe partir de Object........................................................20

13.3.1. Mthode Finalize........................................................................................................ 20

13.3.2. Mthode ToString....................................................................................................... 21
13.3.3. Mthode Equals......................................................................................................... 21

14.

Polymorphisme..........................................................................................................................................21

15.
16.

Classes abstraite (gnriques)..................................................................................................................22

Les collections...........................................................................................................................................23

14.1.

16.1.

Mthodes virtuelles....................................................................................................... 22

Dfinition...................................................................................................................... 23

2 / 16
16.2.
16.3.
16.4.
16.5.
16.1.
16.2.
16.3.

Les tableaux statiques.................................................................................................. 23

Classe ArrayList............................................................................................................ 23
La classe Hashtable...................................................................................................... 24
La classe SortedList...................................................................................................... 24
La classe List................................................................................................................. 25
La fonction Split............................................................................................................ 26
Exemple complet (utile pour lexam) :version 1...........................................................26

17.

La classe Regex.........................................................................................................................................28

18.

Les exceptions...........................................................................................................................................30

19.

La srialisation..........................................................................................................................................35

17.1.
17.2.
17.3.
17.4.
18.1.
18.2.
18.3.
18.4.
19.1.
19.2.

Utilisation...................................................................................................................... 28
Syntaxe......................................................................................................................... 28
Aide-mmoire des mta-caractres.............................................................................. 28
Exercice :...................................................................................................................... 30
Syntaxe......................................................................................................................... 30
Lever une exception...................................................................................................... 31
Crer une exception personnalise............................................................................... 33
Exemple complet (utile pour lexam) : version 2..........................................................34
Introduction.................................................................................................................. 35
Srialisation XML........................................................................................................... 35

19.2.1.
19.2.2.
19.2.3.
19.2.4.
19.2.5.
19.3.
19.1.

La classe XmlSerializer.............................................................................................. 35
Un exemple simple.................................................................................................... 36
Srialisation d'une collection..................................................................................... 36
D-srialiser un objet................................................................................................. 37
Exercice :................................................................................................................... 37

La srialisation binaire.................................................................................................. 38
Srialisation textuelle // ne figure pas dans le guide pdagogique...............................38

19.1.1. Srialisation :............................................................................................................. 38

19.1.2. d-srialisation.......................................................................................................... 39
19.2.

20.
21.

Exemple complet (utile pour lexam) :version 3...........................................................39

Les interfaces............................................................................................................................................41
Linterface IEnumerable..........................................................................................................................43

1.Introduction
1.1.

Notion dencapsulation

Dans les programmes tels quon les a crits jusqu`a maintenant, les types de donnes et les fonctions
permettant de traiter ces donnes taient spares :

Le principe dencapsulation consiste regrouper dans le mme objet informatique des structures de
donnes particulires et les fonctions qui leur sont spcifiques :
Les structures de donnes dfinies dans un objet seront appeles les attributs de cet objet.
Les traitements dfinis dans un objet seront appeles les mthodes de cet objet.

3 / 16
Relation fondamentale :

1.2.

OBJET
=
Attributs
+
Mthodes

Notion dabstraction

Pour tre vritablement intressant, un objet doit permettre un certain degr dabstraction.
Le processus dabstraction consiste identifier :
des caractristiques communes tous les lments : ce sont les attributs
des mcanismes communs tous les lments : ce sont les mthodes
Ces lments communs forment une description gnrique de lobjet
Exemple : Rectangles
Lobjet rectangle possde des caractristiques gnrales: la largeur et la hauteur. Ce sont les attributs
de lobjet rectangle.
Lobjet rectangle possde un mcanisme permettant de calculer la surface dun rectangle (surface =
largeur hauteur) .cest une mthode de lobjet rectangle.

1.3.

Pourquoi abstraire/encapsuler ?

Lintret de regrouper les traitements et les donnes conceptuellement relies est de permettre une
meilleure visibilit et une meilleure cohrence au programme, doffrir une plus grande modularit.
Lintret de sparer les niveaux interne et externe est de donner un
cadre plus rigoureux `a lutilisation des objets utiliss dans un
programme Les objets ne peuvent etre utiliss quau travers de leur interfaces
(niveau externe) et donc les ventuelles modifications de la structure interne restent invisibles `a
lextrieur

2.Objet, classe et instance

2.1.

Dfinition dun objet

Un objet reprsente une entit du monde rel, ou du monde virtuel dans le cas dobjets immatriels, qui
se caractrisent par une identit, des tats significatifs et par un comportement.
Lidentit dun objet permet de distinguer les objets les uns par rapport aux autres. Son tat correspond
aux valeurs de tous ses attributs un instant donn. Ces proprits sont dfinies dans la classe
dappartenance de lobjet. Enfin, le comportement dun objet se dfini par lensemble des oprations
quil peut excuter en raction aux messages envoys (un message = demande dexcution dune
opration) par les autres objets. Ces oprations sont dfinies dans la classe dappartenance de lobjet.
Exemple :
Dans une entreprise, un employ Mohammed (son numro de scu 1 05 73 123 456 permet son
identification unique dans lentreprise), est employ sur un poste de technicien dans la socit X situe
Agadir.
Son tat est caractris par lensemble de ces valeurs (ses attributs)
num scu : 1 05 73 123 456
nom : Mohammed
qualification : Technicien
Lieu de travail : Agadir
Son comportement est caractris par les oprations quil peut raliser :
entrer/sortir de la socit
changer de qualification
changer de lieu de travail
Bref, lensemble des oprations pouvant affecter ses attributs.

4 / 16

2.2.

Classe et instance

Une classe est labstraction dun ensemble dobjets qui possdent une structure identique (liste des
attributs) et un mme comportement (liste des oprations). Cest un modle dcrivant le contenu et le
comportement des futurs objets de la classe. Un objet est une instance dune classe.
Si lon reprend lexemple prcdent, la classe est lemploy, linstance de classe (lobjet) est lemploy
Mohammed
Par rapport une approche classique que lon peut observer dans la programmation procdurale,
lapproche objet se caractrise par le regroupement dans une mme classe de la description des
attributs et des oprations (mthodes). Ce regroupement sappelle lencapsulation. On masque
linformation au monde extrieur.
Ce principe dencapsulation amliore lautonomie et lindpendance de chaque classe et augmente le
potentiel de rutilisation de chacune delles.
La visibilit des attributs et des oprations dune classe vis vis dautres porte le nom dinterface.
Un objet est donc compos de donnes et doprations (appeles mthodes) sur ces donnes.
Une classe se compose de deux parties :
Une liste dattributs ou de proprits (ce sont des variables): ces attributs ne sont pas visibles par
les utilisateurs de lobjet ; on dit quils sont privs.
Une liste de mthodes (un ensemble de fonctions et/ou de procdures) :cest cette partie qui est
visible par les utilisateurs de lobjet. On lappelle linterface de la classe.

Rcapitulatif :

Une classe dclare les proprits et les mthodes communes un ensemble dobjets. Un objet est une
instance dune classe.
Exemple :
La classe Voiture
Elle possde les proprits suivantes(les attribues) :
Couleur
Puissance
vitesse
Elle possde aussi ces mthodes :
acclrer(Entier v)
Arrter()
Exemple de 2 dinstances de la classe voiture (des objets) :
Renault Clio
Couleur : verte
Puissance : 70
Vitesse : 80
Logan
Couleur : bleu
Puissance : 80
Vitesse : 90
Une classe, en C# se dclare par le mot cl class suivi d'un identificateur de classe choisi par le
programmeur de la faon suivante :
public class NomDeLaClasse
{
// Dclaration des proprits et
// des mthodes de l'objet

5 / 16
}
Le fichier contenant le code source portera le nom NomdeLaClasse.cs.
Les identifiants de classe obissent aux mmes rgles que les identifiants de variables et de fonctions.
Par convention, ils commencent par une Majuscule (C# considre les majuscules comme des caractres
diffrents des minuscules).
Les proprits et les mthodes de l'objet seront dclares et implmentes dans le bloc { } contrl par
le mot cl class. Cela constitue l'implmentation du concept d'encapsulation en C#.

3.Les proprits
3.1.

Dclaration des proprits

Les proprits d'un objet sont dclares, comme des variables, l'intrieur du bloc { } contrl par le
mot cl class.

public class NomDeLaClasse

{
TypeDeLaPropriet NomDeLaPropriete;
.
.
.
}

Les proprits peuvent tre dclares tout moment l'intrieur du corps de la classe.
Une proprit peut tre initialise lors de sa dclaration :
TypePropriet NomPropriete = valeurInitiale;
Les identifiants de proprit par convention commencent par une majuscule. Comme toutes les
instructions du langage C#, chaque dclaration de proprit DOIT absolument tre termine par
un point-virgule ; Le point-virgule ne constitue pas un sparateur, mais un terminateur
d'instructions.

Exemple 1 :
public class Voiture
{
//les attributs ou les proprits
String couleur;
Double puissance ;
Double vitesse ;
//fin de la dclaration de la classe
}
Exemple 2 :
public class Salarie
{
string nom;
string prenom;
DateTime dateNaiss;
int age;
}

3.2.

Exercice :

a. Crer la classe stagiaire. Cette classe a 2 proprits :

nom : String
age : int
b. Crer la classe employe. Cette classe aura 5 proprits:
matricule : Matricule int

6 / 16

3.3.

catgorie :
service :
nom
:
salaire
:

Categorie int
Service int
Nom String
Salaire double

Protection des proprits

En Programmation Oriente Objet, on vite d'accder directement aux proprits par loprateur. En
effet, cette possibilit ne correspond pas au concept d'encapsulation. Certains langages l'interdisent
carrment. En C#, c'est le programmeur qui choisit si une donne membre ou une fonction membre est
accessible directement ou pas.
Par dfaut, en C#, toutes les proprits et mthodes sont accessibles directement. Il faut donc prciser
explicitement les conditions d'accs pour chaque proprit et chaque mthode. Pour cela, il existe trois
mots-cls :
public - Aprs ce mot cl, toutes les donnes ou fonctions membres sont accessibles.
private - Aprs ce mot cl, toutes les donnes ou fonctions membres sont verrouilles et ne seront
pas accessibles dans les classes drives.
protected - Aprs ce mot cl, toutes les donnes ou fonctions membres sont verrouilles mais sont
nanmoins accessibles dans les classes drives.
Ce concept des classes drives sera abord ultrieurement dans ce cours.
Afin dimplanter correctement le concept d'encapsulation, il convient de verrouiller l'accs aux
proprits et de les dclarer private, tout en maintenant l'accs aux mthodes en les dclarant public.
Exemple :

public class Client

{
private int numeroClient; // numro client
private String nomClient; // nom du client
private double caClient; // chiffre d'affaire client
public void AugmenterCA(double montant) // ceci est une mthode de la classe Client
{
caClient = montant;
}
}

3.4.

Exercice

Partie 1 :
Reprendre le rsultat du TAF prcdant :
Dans la classe voiture :
Couleur : priv
Puissance : public
Dans

la classe clsSalarie.
Matricule : protected
Categorie : public
Service int : priv
Nom String : priv
Salaire : priv

Protger toutes les proprits de la classe voiture et de la classe clsSalarie et en interdire l'accs de
l'extrieur de la classe ( cela revient les dclarer privs)
Partie 2 :
1. Crer la classe Fraction. Ses proprits sont : Numerateur et denominateur .
Elle a galement une mthode Afficher qui afficher ses proprits.
Ses proprits sont toutes publics.

7 / 16
2. Dans un programme principal :
a. Instancier la classe Fraction
b. Affecter son numrateur la valeur 12
c. Affecter son dnominateur la valeur 14
d. Ajouter la valeur 5 la valeur de son numrateur
e. Ajouter la valeur 7 la valeur de son dnominateur
f. Dclarer une variable. Affecter cette variable la valeur du numrateur
g. Dclarer une variable. Affecter cette variable la valeur du dnominateur
h. Afficher le numrateur et le dnominateur de votre instance.
3. Maintenant, dclarer les proprits prives. Modifier en suite votre programme principal.
Partie 3
Implmenter une classe appele Cercle qui contient :
2 variables dinstance publiques : rayon (de type double) et couleur (de type string), ayant les
valeurs par dfaut 1.0 et "rouge" respectivement;
2 mthodes publiques getRayon() et getSurface().
Rappel : Surface dun disque = x rayon.

4.Instanciation

Considrons linstruction suivante :

Salarie sl;

Pour que lobjet sl ait une existence, il faut qu'il soit instanci. Linstanciation se fait via l'instruction
new. Linstruction new fait appel une fonction particulire. Cette fonction s'appelle le constructeur.
Elle permet, entre autre, d'initialiser chaque instance pour que ses proprits aient un contenu cohrent.
Une cration d'instance peut se faire en deux temps :
Dclaration d'une variable du type de la classe de l'objet,
Instanciation de cette variable par l'instruction new.
Exemple 1 :
Linstanciation de la classe String se passerait de la faon suivante :

static void Main(string[] args)

{
string s;
s = new string("Bonjour");
//Ces deux tapes peuvent tre rduites une seule instruction :

string s = new string("Bonjour");

}

Exemple 2 :

static void Main(string[] args)

{

Salarie sl1;
sl1 = new Salarie();//appel du constructeur de la classe salari
//Ces deux tapes peuvent tre rduites une seule instruction :
Salarie sl2 = new Salarie();//appel du constructeur de la classe salari

8 / 16

5. Les Constructeurs
5.1.

Constructeur par dfaut

Un constructeur par dfaut existe dj pour chaque classe si aucun autre constructeur n'est dclar. A
partir du moment o le constructeur d'initialisation de la classe Client existe, il devient impossible de
dclarer une instance comme on l'a fait dans le T.P. prcdent :
Salarie sal = new Salarie();

Pour qu'une telle dclaration, sans paramtre d'initialisation, soit encore possible, il faut crer un
constructeur par dfaut. En fait ce n'est rellement indispensable que si une instanciation de l'objet,
avec des valeurs par dfaut pour ses proprits, a un sens.
Pour la classe Client, on peut s'interroger sur le sens des valeurs par dfaut des proprits. A titre
d'exemple, ce constructeur serait dclar comme ceci :
public Client()
{
numeroClient = 0;
nomClient = "Dupont";
caClient = 0.00;
}

5.2.

Constructeur avec paramtres

public Salarie(string mat, string nm, float sal)

{
matricule = mat;
nom = nm;
salaire = sal;
}

5.3.

Constructeur sans paramtres

// dans la classe
public Salarie()
{
matricule = "0";
}

// dans le main
Salarie sl1 = new Salarie();// la valeur de matricule est "0"

5.4.

Constructeur de recopie.

Le constructeur de recopie permet de recopier les proprits d'un objet existant vers une nouvelle
instance de mme type.
Exemple 1 :
public static void Main (String[] args)
{
Client client1 = new Client(); // 1
Client client2 = new Client (client1); // 2
Client cli = new Client(2,"Toto",17500.00); // 3
// ...
}
En 1, oClient1 est un objet crer via le constructeur d'initialisation. La proprit nomClient" est initialise
par "AAA".
En 2, oClient2 est un objet diffrent de oClient1 mais les proprits des deux objets ont les mmes
valeurs. Pour cela, le dveloppeur doit crire un constructeur de recopie.
En 3, salarie3 est instanci via le constructeur d'initialisation
public Client (Client unClient)
{

9 / 16
numeroClient = unClient. numeroClient;
nomClient = unClient.nomClient ;
caClient = unClient. caClient;
}
Exemple 2:
// dans le main
// appel du constructeur sans paramtre
Salarie s1 = new Salarie();
// appel du constructeur de recopie
Salarie s2 = new Salarie(s1);

5.5.

Exercices

5.5.1.

Tp 1:

A partir du travail ralis au T.P. N 1, modifier la classe clsSalarie pour :

1. protger les proprits de l'objet (l'accs aux fonctions membres doit toujours tre
possible)
2. crer les mthodes d'accs aux attributs Get et Set.
3. Ajouter un constructeur sans paramtres.
4. Ajouter un constructeur de recopie.
5. Ajouter un constructeur avec paramtres.
6. Modifier la fonction Main de la classe Application pour tester.

5.5.2.

TP1 :

1. Ecrire une classe voiture. Une voiture a une couleur, une puissance et une vitesse.
a. Ajouter un constructeur avec paramtres.
b. Ajouter un constructeur sans paramtres.
c. Ajouter un constructeur de recopie.
d. Ajouter une mthode Afficher().
2. Ecrire un programme principale qui :
a. Cre une instance vt1 en utilisant le constructeur avec paramtres.
b. Cre une instance vt2 en utilisant le constructeur sans paramtres.
c. Cre une instance vt3 en utilisant le constructeur de recopie.
d. Afficher la couleur, la puissance et la vitesse de vt1, vt2 et vt3.

10 / 16

6.Les mthodes

Les mthodes d'une classe sont implmentes, l'intrieur du bloc { } contrl par le mot cl class.
Quand on considre une mthode par rapport l'objet laquelle elle est applique, il faut voir l'objet
comme tant sollicit de l'extrieur par un message. Ce message peut comporter des paramtres.
L'objet doit alors ragir ce message en excutant cette fonction ou mthode.

public class NomDeLaClasse

{
// Dclaration des proprits de l'objet
int Vitesse = 30 ;
//dclaration d'une mthode
TypeResultat NomDeMethode(Type1 par1, Type2 par2)
{
// Instructions de la mthode return expression ;
}
}

Les identifiants de mthodes commencent par une majuscule.

Comme toutes les instructions du langage C#, les instructions dfinissant le fonctionnement de la
mthode DOIVENT absolument tre termines par un point-virgule ; Le point-virgule ne constitue pas
un sparateur, mais plutt un terminateur d'instructions.
Si aucun paramtre n'est dsign explicitement entre les parenthses, le compilateur considre la
mthode comme tant sans paramtre. Dans ce cas, les parenthses sont nanmoins
obligatoires.
Sauf si le rsultat de la mthode est de type void, l'une des instructions doit tre return suivi d'une
expression dont le rsultat est de mme type. Ce rsultat constitue le retour de la mthode et peut
tre exploit par le programme envoyant le message.

7.Les destructeurs
En C# on ne peut pas dclencher explicitement la destruction d'un objet. Les instances sont
automatiquement dtruites lorsqu'elles ne sont plus rfrences. Le programme qui se charge de cette
tche s'appelle le Garbage Collector ou, en franais, le ramasse-miettes. Le Garbage Collector est
un systme capable de surveiller les objets crs par une application, de dterminer quand ces objets
ne sont plus utiles, dinformer sur ces objets et de dtruire les objets pour rcuprer leurs ressources.
Or si l'on veut que le compteur d'instances soit jour, il est ncessaire de connatre le moment ou les
instances sont dtruites pour dcrmenter la variable compteur.
C'est pour cela que le ramasse miettes envoie un message chaque instance avant qu'elle soit
dtruite, et ceci quelle que soit la classe. Il suffit d'crire la mthode de rponse ce message, c'est la
mthode Finalize(). Cette mthode s'appelle destructeur. Cest, bien sr, une mthode de la classe
que l'on est en train de dvelopper. Dans la classe Client par exemple, elle se dclare
OBLIGATOIREMENT de la faon suivante :

public class Fraction

{
private long numerateur;
private long denominateur;
private static uint compteur;
// destructeur

~Voiture()
{

compteur--; // dcrmentation du compteur

11 / 16
protected void Finalize()
{
compteur--; // dcrmentation du compteur
}
public
{

Boolean Equals(Fraction fr)

return numerateur * fr. denominateur == denominateur * fr . numerateur;

}
}
Overrides est indiqu pour spcifier que lon souhaite que ce soit cette procdure Finalize qui soit
excute plutt que celle de la classe de base. On part ici de substitution.

8.Accs aux proprits et aux mthodes

Bien qu'un accs direct aux proprits d'un objet ne corresponde pas exactement au concept
d'encapsulation de la programmation oriente objet, il est possible de le faire en C#. On verra, au
chapitre suivant, comment protger les donnes membres en en interdisant l'accs.
L'accs aux proprits et aux mthodes d'une classe se fait par loprateur..

class Fraction
{
public int Numerateur { get; set; }
public int Denominateur { get; set; }
}
static void Main(string[] args)
{
Fraction fr1 = new Fraction();
fr1.Numerateur = 3;
fr1.Denominateur = 4;
}

8.1.

Exercices :

1. Crer la classe clsSalarie. Cette classe aura 5 proprits de type public:

matricule Matricule int
catgorie Categorie int
service Service int
nom Nom String
salaire Salaire double
2. Crer une mthode public CalculerSalaire pour afficher la mention "Le salaire de " suivie du nom du
salari, suivi de " est de ", suivi de la valeur du salaire.
3. Implanter une classe application, avec une mthode Main dans laquelle la classe Salarie sera
instancie pour en tester les proprits et les mthodes.

9. Encapsulation protection et accs aux donnes

membres
9.1.

Protection des proprits

En Programmation Oriente Objet, on vite d'accder directement aux proprits par loprateur. En
effet, cette possibilit ne correspond pas au concept d'encapsulation. Certains langages l'interdisent

12 / 16
carrment. En C#, c'est le programmeur qui choisit si une donne membre ou une fonction membre est
accessible directement ou pas.
Par dfaut, en C#, toutes les proprits et mthodes sont accessibles directement. Il faut donc prciser
explicitement les conditions d'accs pour chaque proprit et chaque mthode. Pour cela, il existe trois
mots-cls :
public - Aprs ce mot cl, toutes les donnes ou fonctions membres sont accessibles.
private - Aprs ce mot cl, toutes les donnes ou fonctions membres sont verrouilles et ne seront pas
accessibles dans les classes drives.
protected - Aprs ce mot cl, toutes les donnes ou fonctions membres sont verrouilles mais sont
nanmoins accessibles dans les classes drives.
La distinction entre private et protected n'est visible que dans le cas de la dclaration de nouvelles
classes par hritage. Ce concept sera abord ultrieurement dans ce cours.
Afin dimplanter correctement le concept d'encapsulation, il convient de verrouiller l'accs aux
proprits et de les dclarer private, tout en maintenant l'accs aux mthodes en les dclarant public.
Exemple :

public class Client

{
private int numeroClient;
private String nomClient;
private double caClient;

// numro client
// nom du client
// chiffre d'affaire client

public void AugmenterCA(double montant)

{
caClient = montant;
}
}

9.2.

Fonctions d'accs aux proprits

Si les proprits sont verrouilles, on ne peut plus y avoir accs de l'extrieur de la classe. Il faut donc
crer des mthodes ddies l'accs aux proprits pour chacune d'elles. Ces mthodes doivent
permettre un accs dans les deux sens :

pour connatre la valeur de la proprit. Ces mthodes sont appeles mthodes de type Get.?".
La rponse de l'objet, donc la valeur retourne par la mthode Get, doit tre cette valeur.
Par exemple, pour la proprit numeroClient, dclare int, la fonction Get serait dclare de la faon
suivante :
public int Numero() ou public GetNumero()
{
return numeroClient;
}
Cette fonction pourra tre utilise dans la fonction Main, par exemple :
Client cli = new Client();
int numero = cli.numeroClient;
int numero = cli. Numero ();
//ou cli.GetNumero();

pour modifier la valeur d'une proprit. Ces mthodes sont appeles mthodes Set. Cette
mthode ne retourne aucune rponse. Par contre, un paramtre de mme nature que la proprit
doit lui tre indique.
Par exemple, pour la proprit numeroClient, dclare int, la fonction Set sera dclare de la faon
suivante :
public void Numero(int numero) ou SetNumero(int numero)
{
numeroClient = numero;

13 / 16
}
Cette fonction pourra tre utilise dans la fonction main, par exemple :
Client sal = new Client();
cli.numeroClient = 5;
cli.Numero(5);
L'intrt de passer par des fonctions Set est de pouvoir y localiser des contrles de validit des
paramtres passs pour assurer la cohrence de l'objet, en y dclenchant des exceptions par exemple.
La scurisation des classes sera aborde ultrieurement dans ce cours.

9.3.
1)
2)
3)
4)
5)
6)

Exercice :

Ecrire la classe Salarie. Un salari a un numro, un nom, un prnom et une date de naissance.
Ajouter tous les constructeurs.
Ajouter la classe mthodes d'accs aux attributs.
Ajouter la fonction Equals.
Ajouter la fonction Afficher qui retourne tous les attributs de la classe.
Ecrire un programme principal pour tester.

10.

Membres particuliers dune classe

10.1. Proprits de classe

Jusqu' prsent, les proprits dclares taient des proprits d'instance. C'est dire que
les proprits de chaque objet, instanci partir de la mme classe, peuvent avoir des valeurs
diffrentes ( numero, nom, etc ).
Supposons donc maintenant, que dans la classe Client, il soit ncessaire de disposer d'un
compteur d'instance, dont la valeur serait le nombre d'instances en cours un instant donn.
En VB.NET il est possible de crer des proprits de classe. Leur valeur est la mme pour
toutes les instances d'une mme classe. Pour dclarer une telle proprit, on utilise le mot-cl
Shared. Dans dautres langages comme C#, ces proprits sont dclares Static. Par exemple,
dans la classe Client, le compteur d'instance pourrait tre dclar :
Private static int compteur = 0
La proprit de classe compteur, initialise 0 lors de sa dclaration, sera incrmente de 1 dans tous
les constructeurs dvelopps pour la classe Client. Sa valeur sera le nombre d'instances valides un
instant donn.

11.

Accs aux attributs de classe

Si les proprits sont verrouilles, on ne peut plus y avoir accs de l'extrieur de la classe. Il faut donc
crer des mthodes ddies l'accs aux proprits pour chacune d'elles. Ces mthodes doivent
permettre un accs dans les deux sens :
pour connatre la valeur de la proprit(Ces mthodes sont appeles mthodes de type Get) :
Par exemple, pour la proprit numeroClient, dclare int, la fonction Get serait dclare de la faon
suivante :

public int Numero() // ou public GetNumero()

{
return numeroClient;
}

Cette fonction pourra tre utilise dans la fonction Main, par exemple :

Client c1 = new Client();

int num = c1.Numero();

pour modifier la valeur d'une proprit ( Ces mthodes sont appeles mthodes Set) :

14 / 16
Par exemple, pour la proprit numeroClient, dclare int, la fonction Set sera dclare de la faon
suivante :

public void Numero(int numero) //ou SetNumero(int numero)

{
numeroClient = numero;
}
Cette fonction pourra tre utilise dans la fonction Main, par exemple :

Client c1 = new Client();

c1.Numero(25) ;
Exemple complet : classe Client :

public class Client

{
private int numeroClient;
private String nomClient;

// numro client
// chiffre d'affaire client

public int Numero() // ou public GetNumero()

{
return numeroClient;
}
public void Numero(int numero) //ou SetNumero(int numero)
{
numeroClient = numero;
}
}// fin de la classe Client
static void Main(string[] args)
{
Client c1 = new Client();
c1.Numero(25) ;
int num =c1.Numero() ;
Console.WriteLine("le numro du client est :" + num);
}

12. Accs aux attributs de classe par les

proprites
public class Client
{
private int numeroClient;
private String nomClient;

// numro client
// chiffre d'affaire client

public int NumeroClient

{
get { return numeroClient; }
set { numeroClient = value; }
}
public String NomClient
{

15 / 16
get { return nomClient; }
set { nomClient = value; }
}
}

static void Main(string[] args)

{
Client c1 = new Client();
c1.NumeroClient = 27;
c1.NomClient = "Sadik";
}

13.

Lhritage

13.1. L'hritage
Le concept d'hritage est l'un des trois principaux fondements de la Programmation Oriente Objet, le
premier tant l'encapsulation vu prcdemment dans les T.P. 1 3 et le dernier tant le polymorphisme
qui sera abord plus loin dans ce document.
L'hritage consiste en la cration d'une nouvelle classe dite classe drive partir d'une classe
existante dite classe de base ou classe parente.
L'hritage permet de :
rcuprer le comportement standard d'une classe d'objet (classe parente) partir de proprits
et des mthodes dfinies dans celles-ci,
ajouter des fonctionnalits supplmentaires en crant de nouvelles proprits et mthodes dans
la classe drive,
modifier le comportement standard d'une classe d'objet (classe parente) en surchargeant
certaines mthodes de la classe parente dans la classe drive.
Exemple :

class ClasseA
{
// Proprits de la classe A
public int dataA;
// Mthodes de la classe A
public int FonctionA1()
{
// Code de la mthode fonctionA1
}
public virtual int FonctionA2() //surchargeable
{
// Code de la mthode fonction A2
}
}
class ClasseB : ClasseA
{
// Proprits de la classe B
public int dataB;
// Mthodes de la classe B
public override int FonctionA2() // surcharge
{
// Code de la mthode fonctionA2
}
public int FonctionB1()
{
// Code de la mthode fonctionB2

16 / 16
}
}
Dans

cet exemple :
ClasseA est la classe parente.
ClasseB est une classe drive de la classe ClasseA.
dataA est une proprit de la classe ClasseA. Par hritage, dataA est aussi une proprit de
la classe ClasseB.
dataB est une proprit de la classe ClasseB (mais pas de ClasseA).
FonctionA1 est une mthode de la classe ClasseA. Par hritage, c'est aussi une mthode de
la classe ClasseB.
FonctionB1 est une mthode de la classe ClasseB (mais pas de ClasseA).
FonctionA2 est une mthode des classes ClasseA et ClasseB.
dans la classe A, FonctionA2() est dclare virtual car elle est surchargeable dans la classe B
dans la classe B, FonctionA2 est dclare override car elle remplace la mthode de la classe A