Vous êtes sur la page 1sur 19

Algorithmique orient objet

Table des matires


Chapitre 1 :Introduction aux objets et notions de bases.......................................................................3
1 -Prambule....................................................................................................................................3
2 -Concepts sous-jacents aux approches orients objets.................................................................5
3 -Objets et classes : une premire approche...................................................................................6
3.1Classes versus Objets.............................................................................................................6
3.2Caractristiques et implmentation dune classe...................................................................7
3.3Convention de nommage.......................................................................................................8
3.4Encapsulation des donnes : les droits d'accs.......................................................................9
Chapitre 2 :Les bases de l'algorithmique orient objet.........................................................................9
1 -Prambule....................................................................................................................................9
2 -Dclaration et instanciation d'une classe.....................................................................................9
2.1Dclarations des constructeurs et destructeurs.....................................................................10
2.2Dclaration des mthodes....................................................................................................10
2.3Instanciation des objets........................................................................................................11
3 -Dfinition d 'une classe..............................................................................................................11
4 -L'oprateur d'auto-rfrencement..............................................................................................12
5 -De l'encapsulation aux accesseurs.............................................................................................12
Chapitre 3 :L'hritage.........................................................................................................................12
1 -Prambule..................................................................................................................................12
2 -L'hritage simple.......................................................................................................................13
2.1Mise en uvre......................................................................................................................13
2.2Accs aux membres de la classe mre.................................................................................14
2.3Mcanisme d'appel des constructeurs et destructeurs..........................................................14
3 -L'hritage multiple.....................................................................................................................14
Chapitre 4 :La surcharge.....................................................................................................................15
1 -Prambule..................................................................................................................................15
2 -La surcharge de fonctions ou mthodes....................................................................................15
3 -La surcharge d'oprateur............................................................................................................15
Chapitre 5 :Le polymorphisme...........................................................................................................16
1 -Qu'est ce que le polymorphisme ?.............................................................................................16
2 -Mthodes virtuelles...................................................................................................................17
Chapitre 6 :Classes abstraites.............................................................................................................18
1 -Introduction...............................................................................................................................18
2 -Mise en uvre...........................................................................................................................19

Chapitre 1 : Introduction aux objets et notions de bases


1 - Prambule
Historiquement, on distingue trois grandes approches pour le dveloppement d'un logiciel.

Dans l'architecture imprative, un programme est dcoup en fonctions et en structures de


donnes. Le dveloppement se fait dans un langage procdural, type C, Pascal
Exemple :
struct{
char Prnom[255] ;
char Nom[255] ;
}Etudiant ;

char * Lire_Nom() ;
char * Lire_Prnom() ;

Historiquement, il s'agit de la premire approche appliqu en informatique, mais elle est


aujourd'hui la plus archaque. Elle a plusieurs inconvnients, dont notamment :
Elle conduit penser d'abord fonctions donc elle est potentiellement une source de
mauvaise analyse du projet.
Dcomposer en fonctions, c'est prendre le risque de faire un programme fourre tout ,
i.e., une succession de fonctions dont le lieu entre elles et compliqu comprendre.
Cela augmente donc le risque d'avoir des programmes difficilement maintenables (correctifs
et volutifs).
Dans l'architecture modulaire, un programme est dcoup en modules, chaque module
regroupant une ou plusieurs structures de donnes et un ensemble de fonctions manipulant les
donnes.
Ici on donne du sens un module ce qui est fondamental. Quand on conoit un programme

modulaire, on ne pense plus fonctions d'abord mais module d'abord , en raisonnant sur le
sens de ce que l'on veut faire.
Le dveloppement se fait dans un langage modulaire, type ADA.
Exemple :
Module M-Etudiant
{
char Nom[255] ;
char Prenom[255] ;

char * Lire_Nom() ;
char * Lire_Prenom() ;
}

Un module est un fichier du programme.


Un module a un sens vis--vis du problme trait. Cela est fondamental dans l'approche car
cela conduit architecturer et concevoir son programme d'une faon naturellement plus propre.
Cette approche date des annes 1990 et elles constitue un prmisse aux approches orients
objets.
Dans l'architecture objet, un programme est dcoup en classes/objets, chacun regroupant un
ensemble de donnes et un ensemble de fonctions/mthodes les manipulant. Il s'agit d'une extension
de l'approche modulaire et en comporte donc tous les avantages ainsi que la mme dmarche
conceptuelle. On travail l encore sur le sens des choses
Les approches orients objets ont trs largement supplants l'approche modulaire, mme si
d'un point de vue gnie logiciel, elles n'ont pas t une rvolution.
Le dveloppement se fait dans un langage orients objets, comme le C++, le JAVA
Dans ce cours, nous allons aborder les notions algorithmiques ncessaires la conception et
l'criture de programmes orients objets.
Ce cours, et les suivants, s'inscrivent dans une dmarche du gnie logiciel et donc suivent un
cycle de dveloppement.

2 - Concepts sous-jacents aux approches orients objets


Les approches orients objets sont conditionnes par le respect de trois principes
fondamentaux :
Principe d'abstraction : chaque unit d'un programme doit correspondre une
abstraction pr-existante et doit pouvoir tre dfinie de faon abstraite, indpendamment
de sa ralisation.
Principe d'encapsulation : la description logique d'une unit du programme doit
permettre de systmatiquement cacher sa complexit interne tout en fournissant les
informations suffisantes pour la comprendre et l'utiliser.
Principe de faible couplage : A chaque niveau d'analyse, les rapports entre les units du
programme qu'il est ncessaire de considrer doivent tre simples.
Notes : le second principe ainsi que le troisime sont surtout utiliss dans la phase de
conception du logiciel. On doit donc spcifier une solution logicielle en termes d'abstractions du
domaine d'application tout en minimisant les changent. A chacune d'elle on associe une
classe/objet.
Notes : la loi de Miller (rsultat de psychologie cognitive) prcise que le nombre de
concepts, lments sur lesquels un tre humain peut simultanment raisonner est gal sept plus ou
moins deux.
Cela implique, que pour un niveau de dcomposition d'une abstraction, il est fortement
conseill de ne crer, au plus, que sept plus ou moins deux sous-abstractions.

Exemple :
Vous devrez raliser un logiciel qui gre toute la scolarit dune cole
dingnieurs. Ce logiciel doit permettre de grer les annes dtudes, les emplois du temps,
les tudiants, les cours, les profs,
Question 1 :
Quelles sont les diffrentes units/ parties du programme peut-on
sattendre trouver ? (Principe dabstraction)
Modules : tudiants, annes dtudes, semestre , groupes,
Question 2 :
Quimplique le principe dencapsulation ?
notion de mode demploi : linterface doit permettre de savoir
comment utiliser une unit, quelles sont les fonctions appelable, ce quelles font,
Posture considrer : je suis utilisateur dun code, possiblement crit
par un autre .
Question 3 :
Quimplique le principe de faible couplage ?
le mode demploi doit tre simple : limiter le nombre de paramtres de
vos fonctions quitte dupliquer les fonctions.

3 - Objets et classes : une premire approche


3.1

Classes versus Objets

Avec lapproche objet, le logiciel est un ensemble dobjets possdant chacun une identit,
un tat, un comportement, et interagissent ensemble pour remplir les fonctions attendues.
Les donnes structurelles de lobjet (son tat) sont dfinis par ses attributs (ou proprits).
Ce sont des variables stockant des informations sur ltat de lobjet. Elles le caractrisent tout
instant t.
Ces donnes sont manipules par les mthodes de lobjet. Elles lui donnent un
comportement spcifique en ralisant des actions. Une classe dfinit la structure commune dun
ensemble dobjets du mme type , disons de la mme famille.
Dfinition : Une classe dfinit une structure de donnes particulire ainsi que les
mthodes (ou oprations) permettant de les manipuler. Cest un type abstrait de
donnes associs cette famille.

Exemple :
classe CListe
Attributs :
Nombre dlments (entier non signs)
Liste dlments (tableau)
Mthodes :
Afficher la liste
Ajouter un lment
Modifier un lment
Lire un lment
Supprimer un lment

Les valeurs des donnes et le rsultat des mthodes sont propres chaque objet issu de la
casse. Les objets sont appels des instances de la classe. Les objets naissent et meurent. Les classes
sont des abstractions (type).

3.2

Caractristiques et implmentation dune classe

Une classe suit le principe dencapsulation en : OO (Orient Objet), on a pas damis


principe de la paranoa maximum.
Dfinition : Une classe possde une interface (=partie visible au reste du programme)
et un corps (= partie invisible au reste du programme).
La classe doit tre crite de sorte ce que lutilisateur nait pas besoin daller lire le corps :
linterface sert de manuel dutilisateur.
Linterface est la partie visible de la classe. Elle contient lensemble des types, mthodes et
sous-classes accessibles aux autres classes. Il faut dfinir avec soin ce qui doit tre visible ou non.
Tout ce qui est dclar dans linterface est visible et/ou manipulable par le reste du
programme.
Le corps est la partie cache de la classe, o sont dcrites les mthodes, types et sous-classes
caches. On y trouve galement la dfinition des mthodes.
Dfinition : Une classe possde des attribut qui sont des variables qui lui sont propres.

3.3

Convention de nommage

Nous nommerons tous les types en commenant par la lettre T en majuscule, suivi du type :
Exemple : T_liste

Pour les classes, on utilisera la lettre C la place de T.


Exemple : CListe

Pour les noms de mthodes nous utiliserons les trigrammes : trois lettres qui sont
gnralement les 3 premires du nom de la classe dappartenance.
Exemple : Si dans la classe Cliste il y a une mthode qui permet de lire un lment :
LISLire-Element

Dans le cas des fonctions (donc qui nappartiennent aucune classe) nous nutilisons pas les
trigrammes.
Le cas des variables est un peu plus complexe. Chaque nom de variable sera prcd dune
ou plusieurs lettres selon le cas de figure.
Si cette variable est un pointeur (ou un tableau) alors son nom commencer a par la lettre p.
Pour toutes les variables, on trouve ensuite des lettres qui prcisent son type.

Exemple :

Lettre

Type

Caractre

Entier

Naturel

Rel

Boolen

Chane

nBoucle : variable de type naturel


peListe : pointeur sur un tableau d'entiers

Si la variable est un attribut d'une classe, on lui rajoute le trigramme :


Exemple : Cliste Nom(chane) => sLISNom

3.4

Encapsulation des donnes : les droits d'accs

Le principe d'encapsulation implique pour les donnes qu'elles sont sujettes un droit
d'accs.
Pour dfinir l'accessibilit d'un attribut, nous allons utiliser les contrles d'accs. Ce sont des
mots-clefs du langage qui permettent de dfinir comment un attribut (ou une mthode) est
visible pour le reste du programme.
Les
lments
(attributs
ou
mthodes)
tant
d'accs
publiques
sont
manipulables/rfrenables par n'importe quelle partie du programme.
Les lments (attributs ou mthodes) tant d'accs privs ou protgs ne sont pas
manipulables/rfrenables : ils sont uniquement manipulables par les autres mthodes de la classe.
Rgle d'or (induite par le principe d'encapsulation) :
Les attributs d'une classe seront dfinis privs (voir protgs).
Les mthodes d'une classe seront dfinies, la plupart du temps, publiques.

Chapitre 2 : Les bases de l'algorithmique orient objet


1 - Prambule
2 - Dclaration et instanciation d'une classe
Pour dclarer une classe ou utiliser le mot-clef : classe
Exemple :
classe CListe
Dbut
//Attributs :
dclaration des attributs
//Constructeurs et destructeurs :
dclaration constructeurs et destructeurs
//Mthodes :
dclaration des mthodes
Fin

Les contrles d'accs : ils prcisent l'accs des membres de la classe vis--vis de l'extrieur :
Les membres publiques : le dbut d'une zone o les dclarations sont publiques et
signals par l'oprateur Public suivi de : (Public:). Les dclarations de variables
(d'attributions ou de mthodes) qui suivent seront accessibles avec la notation pointe
. (ou flche) des structures par n'importe quelle fonction ou mthodes du
programme.
=>On a un accs interne et concerne un accs externe.
Les membres privs : le dbut d'une zone o les dclarations sont privs est signals par
Private . Les dclarations qui suivent cet oprateur ne seront pas accessibles avec la
notation pointe (ou flche) par n'importe quelle fonction ou mthode se trouvant en
dehors de la classe.
=>On a un accs interne mais pas d'accs externe.
Les membres protgs : On utilise l'oprateur Protected: presque pareil que Private

Pas d'accs externe mais interne. La diffrence avec le statut priv apparat lors de
l'hritage.

2.1

Dclarations des constructeurs et destructeurs

Un constructeur est une mthode spcifique de la classe. Il porte le mme nom que la classe
et ne retourne aucune valeur.
Un constructeur est appel automatiquement lors de l'initialisation d'un objet pour le
construire, i.e. initialiser ses attributs.
On peut dclarer autant de constructeurs que l'on veut : ils doivent tous se diffrencier par la
liste des paramtres qu'ils prennent. On distingue deux constructeurs particuliers : le constructeur
par dfaut et le constructeur de recopie.
Le constructeur par dfaut est un constructeur qui ne prend aucun paramtre. Il est appel
ds lors qu' l'instanciation de l'objet aucun paramtre n'est spcifi. Il existe une version par dfaut,
qui ne fait rien, et qui s'appelle le constructeur par dfaut par dfaut.
Le constructeur de recopie est un constructeur qui prend en paramtre un objet de la mme
classe. Il a pour objectif d'initialiser le nouvel objet par duplication de l'objet pass en paramtre. Il
existe galement une version par dfaut.
Exemple :
classe CEtudiant
Dbut
//Attributs :
Private :
sETUPrenom : chane
sETUNom : chane
//Constructeurs et destructeurs :
Public :
CEtudiant() // constructeur par dfaut
CEtudiant(Param : CEtudiant) // constructeur de recopie
CEtudiant(sNom : chane, sPrenom : chane)
Fin

Le destructeur d'une classe est une mthode qui porte le mme nom que la classe mais
prcd de ~ et qui a en charge la dsallocation de certains attributs, ou la ralisation de certains
traitements ncessaires, avant la dsallocation/destruction de l'objet. Cette mthode est appele
automatiquement et ne prend aucun paramtre. Elle ne retourne rien. Il existe une version par dfaut
qui est appele destructeur par dfaut qui ne fait rien.
Exemple : ~Cetudiant()

Note : Cela n'a aucun intrt de dclarer les constructeurs et le destructeur autrement qu'en publique.

2.2

Dclaration des mthodes

Une mthode est une fonction dclare dans la classe.

Exemple :
classe CEtudiant
Dbut
//Attributs :
Private :
sETUPrenom : chane
sETUNom : chane
//Constructeurs et destructeurs :
Public :

//Mthodes :
chaine ETULire_Nom()
chaine ETULire_Prenom()

Fin

2.3

Instanciation des objets

Lorsqu'un objet est dclar, il va tre automatiquement allou en mmoire puis initialis
pour appeler un constructeur. Ces objets sont automatiquement dtruits lorsqu'on arrive en fin de
porte.
Exemple :
E1 : CEtudiant //initialisation par le constructeur par dfaut
E2 : CEtudiant( Neimar , Jean ) //initialisation par le constructeur deux
arguments
E3 : CEtudiant(E2) //initialisation par appel au constructeur de recopie

Il est galement possible d'allouer et dsallouer dynamiquement des objets. On utilise new pour
l'allocation et delete pour la dsallocation.
Exemple :
E1, E2, E3 : *CEtudiant
E1 new CEtudiant()
E2 new CEtudiant( Cule , Jean )
E3 new CEtudiant(E2)
delete E1
delete E2
delete E3

3 - Dfinition d 'une classe


Cela ce fait dans le corps de la classe (.cpp en C++). Pour dfinir une classe il faut crire le
code des constructeurs et des mthodes.
On a deux faons de faire : (1) on crit la dfinition (le code) de la mthode dans la
dclaration de la classe (SALE!), (2) on crit la dfinition dans le corps de la classe (en dehors de sa
dclaration).

Cas 1 :
classe CEtudiant
Dbut
//Attributs :
Private :

//Constructeurs et destructeurs
Public :
CEtudiant(Param : CEtudiant)
Dbut
sETUPrenom Param.sETUPrenom
sETUNom Param.sETUNom
Fin

Fin
Cas 2 : dans le corps de la classe
classe CEtudiant comporte mthode CEtudiant(Param : CEtudiant)
Dbut
sETUPrenom Param.sETUPrenom
sETUNom Param.sETUNom
Fin

4 - L'oprateur d'auto-rfrencement
Dans tout langage orient objet, il existe un oprateur d'auto-rfrencement not this.
Exemple :
classe CEtudiant comporte mthode Cetudiant(Param:CEtudiant)
Dbut
this.sETUPrenom Param.sETUPrenom
<=>
sETUPrenom Param.sETUPrenom

5 - De l'encapsulation aux accesseurs


Le principe d'encapsulation de donnes => les attributs sont privs. Comment peut-on accder ces
attributs de l'extrieur de la classe ?
=> on crer des accesseurs : un accesseur en lecture pour consulter la valeur de l'attribut et
un accesseur en criture pour modifier la valeur de l'attribut.
!! Pour chaque attribut priv ou protg qui doit tre manipul de l'extrieur de la classe il
faut prvoir au moins un accesseurs en lecture et un accesseur en criture.
=> On distingue les accesseurs directs des accesseurs indirect.

Chapitre 3 : L'hritage
1 - Prambule
L'hritage (galement appel drivation) et un mcanisme de base qui permet de prciser des
relations particulires entre classes. Ainsi, il est possible de spcifier qu'une classe Cfille hrite
d'une classe Cmre, c'est--dire que la premire constitue une extension de la seconde. La classe

Cfille hrite de tout ce que possde la classe Cmre (attributs et mthodes).


Exemple : Vous devez crire un logiciel qui permet de grer le personnel d'une entreprise.
Lors des phases de spcification et de conception, vous avez identifi une classe CPersonne
dont hritent les classes : CComptable, CSecrtaire, , Ici c'est un hritage de sens.

Il existe deux formes d'hritage : l'hritage simple et l'hritage multiple. Dans l'hritage
multiple, une classe fille possde plusieurs mres.

2 - L'hritage simple
2.1

Mise en uvre

Il se met en uvre trs facilement lors de la dclaration de la classe fille :


classe Nom_fille spcialise classe Nom_Mre
Exemple :
classe CEtudiantPolytech spcialise classe CEtudiant
Dbut

Fin

Une classe fille hrite de tous les attributs et mthodes de la classe mre, quelque soit leur
contrle d'accs.

Rgle d'or :
L o la mre va, la fille va.
L o la fille passe, la mre trpasse.

Exemple :
objet Mre objet Fille
objet Fille objet Mre
f(objet Mre)
//f(Param : Cfille)
f(objet Fille)
//f(Param : Cmre)

2.2

OK
KO
OK
KO

Accs aux membres de la classe mre

Tout attribut ou mthode priv dans la classe mre et inaccessible dans la classe fille. Une classe
fille ne peut accder qu'aux attributs et mthodes publiques et protgs venant de la classe mre.
Tableau rcapitulatif
Statut dans la Statut dans la Accs interne Accs externe
classe mre
classe fille
(fille)
(fille)
Classe mre

Classe fille

Oui

Oui

Public

Public

Oui

Oui

Protg

Protg

Oui

Non

Priv

Priv

Non

Non

Dans les mthodes de la classe fille on peut appeler les mthodes de la classe mre comme si
elles avaient t dclares dans la classe fille.
Il est galement possible d'utiliser l'oprateur super pour faire rfrence un membre de
la classe mre.
Exemple : //Dans une classe fille de CEtudiant
super.ETULire_Nom()
<=> ETULire_Nom()

Cela peut-tre ncessaire si dans la classe fille et dans la classe mre il y a des membres
homonymes.

2.3

Mcanisme d'appel des constructeurs et destructeurs

Lorsqu'on initialise un objet de la classe fille, il faut avoir prcis quel est le constructeur de
la classe mre qui va tre utilis.
Cela est rendu ncessaire par le principe d'encapsulation des donnes. Il est donc ncessaire
lors de la dfinition d'un constructeur de la classe fille de prciser quel est le constructeur de la
classe mre qui va tre appel. On utilise l'oprateur super.
super() : appel au constructeur par dfaut de la classe mre
super(arg 1, arg 2 ) : appel au constructeur de la classe mre qui accepte ces
arguments
super(this) : appel au constructeur de recopie de la classe mre
Pour le destructeur, cela se fait tout seul.

3 - L'hritage multiple
On peut dfinir qu'une classe fille hrite de plusieurs classes mres. Ce mcanisme est
implment de diffrentes faon selon les langages. Pas trs Gnie Logiciel.
en Algorithmique Orient Objet on suppose que l'hritage multiple n'est pas utilisable.

Chapitre 4 : La surcharge
1 - Prambule
Il existe deux types de surcharges dans un Algorithmique Orient Objet : la surcharge de
mthode/ fonction et la surcharge oprateur.

2 - La surcharge de fonctions ou mthodes


Ce type de surcharge consiste dfinir plusieurs comportements possible pour une mme
fonction ou mthode. On dispose ainsi de plusieurs versions qui se distingue entre elles pour les
arguments qu'elles prennent.
Note : deux versions surcharge seront diffrentes si et seulement si elles ne disposent pas des mmes
arguments (le type de retour ne compte pas).

Exemple :
classe Cexemple
dbut

Public :
EXEMafonction()
entier EXEMafonction(arg1 : entier)
entier EXEMafonction(arg1 : rel, arg2 : chane )
entier EXEMafonction(arg1 : rel, arg2 : entier )

//v1
//v2
//v3

fin

En Algorithmique Orient Objet on se dplace uniquement dans le cadre de la


correspondance exacte des arguments.
Exemple :
EXEObjet : Cexemple
ev1 : entier
rv2 : rel
EXEObjet.EXEMafonction(ev1)
EXEObjet.EXEMafonction(ev1,rv2)

//compile v2
//ne compile pas

3 - La surcharge d'oprateur
Ce type de surcharge permet de prciser le comportement d'oprateur lorsqu'une ou
plusieurs oprandes doivent tre des objets d'une classe.

Exemple : Cfraction + 3.7

Comment faire ?
Il suffit de surcharger au sein de la classe concerne l'oprateur l'aide du mot clef
oprateur suivi du nom de l'oprateur.

Exemple :
Classe Cfraction
dbut
Priv :
eFRCNumrateur : entier
eFRCDenomiteur : entier

Public :
rel oprateur+ (FRCarg : Cfraction)
fin
Classe Cfraction comporte mthode reel oprateur+(CFraction FRCarg)
dbut
retourner((eFRCNumrateur
*
FRCarg.eFRCDnominateur
eFRCDnominateur * FRCarg.eFRCNumrateur)
/ (eFRCDnominateur * FRCarg.eFRCDnominateur))
fin

permet de faire FRCObjet1 + FRCObjet2.


Note : on va supposer dans le cours d'AOO que la surcharge oprateur avec un type de base est commutative.

Exemple :
Classe Cfraction
dbut :

Public :
rel oprateur+(arg1 : rel)
fin

FRCObjet1 + 5.7 et 5.7 + FRCObjet1


On ne peut pas surcharger n'importe quel oprateur : on doit se limiter aux oprateurs
existants.

Chapitre 5 : Le polymorphisme
1 - Qu'est ce que le polymorphisme ?
Polymorphisme est un terme qui dsigne la capacit d'un objet prendre plusieurs
formes au cours de sa vie. Un objet peut donc faire rfrence un moment donn une classe X
puis quelques lignes de code plus loin une classe Y. Un lment important du polymorphisme est
que ces classes X et Y sont ncessairement lies par un relation d'hritage.
L'implmentation du polymorphisme dpend fortement du langage de programmation qui
sera utilis : en Java il diffre du C++ car la notion de pointeur n'existe pas. Dans ce cours nous
allons prsenter une mise en uvre du polymorphisme qui se rapproche de ce qu'est fait en C++.
Nous supposons donc que, en ralit, ce n'est pas un objet mais un pointeur sur un objet qui peut
changer de forme .

Exemple :
Classe CMere
dbut
Public :
Texte()
Dbut
Afficher( Objet de la classe mre )
fin
fin
classe CFille spcialise classe CMere
dbut
Public :
Texte() :
dbut
Afficher( Objet de la classe fille )
fin
fin

Principal()
dbut
pMERv1 : *CMere
MERv2 : CMere
FILv3 : CFille
pMERv1 <- &MERv2
pMERv1 -> Texte()
pMERv1 <- &FILv3
pMERv1 -> Texte()
fin
Affichage :
Objet de la classe mre
Objet de la classe mre
Le pointeur tant dclarer comme un pointeur sur un CMere, cette ligne provoque l'appel la mthode
de la mre.

Comment faire pour que, lors du deuxime appel de Texte() ce soit la mthode de la classe
fille qui soit appele ?
Pour faire cela, il va falloir dclarer les mthodes virtuelles.

2 - Mthodes virtuelles
Pour dclarer qu'une mthode d'une classe est virtuelle, il suffit, lors de sa dclaration, de
faire figurer le mot-clef virtuelle .

Exemple :
Classe CMere
dbut
Public:
virtuelle Texte()
dbut
Afficher( Objet de la classe mre )
fin
fin
Classe CFille
dbut
Public
virtuelle Texte()
dbut
Afficher( Objet de la classe fille )
fin
fin
Du coup l'affichage devient :
Objet de la classe mre
Objet de la classe fille

Et voil, on a mis en place du polymorphisme !


Quelques rgles garder en tte :
1- La prsence des mots-clefs virtuelle est ncessaire lors de la dclaration de la
mthode. Il est interdit lors de sa dfinition.
2- La prsence du mot virtuelle est facultative dans les classes filles. Nanmoins, pour
des raisons de Gnie Logiciel on le mettra tout le temps.
3- Une mthode virtuelle doit tre dclare et dfinie avec les mmes paramtres dans toutes
les classes de la hirarchie.
L'objet de retour peut tre diffrent.

Chapitre 6 : Classes abstraites


1 - Introduction
La notion de classe abstraite est base sur le polymorphisme et l'hritage. Une classe
abstraite est une classe dont l'implmentation n'est pas complte et qui n'est pas instanciable.
Supposons que vous dveloppiez au jeu vido dans lequel des joueurs humains et
l'ordinateur (joueur machine) doivent s'affronter. Lors de la conception du jeu vous avez identifi
deux classes : CJoueurHumain et CJoueurMachine. Chacune de ces classes possdent un attribut
nom et Rle . Pour des raisions structurelles (architecture du jeu) vous dcidez dans ce cas de
crer une classe abstraite CJoueur (avec les attributs Nom et Rle) dont hriteront les classes
CJoueurHumain etCjoueurMachine.

On ne pourra crer d'objets de la classe CJoueur . Certaines mthodes de la Classe CJoueur


(ex:JOEJouer()) ne doivent pas tre dfini dans la classe CJoueur.

2 - Mise en uvre
Deux tapes :
1- Lors de la dclaration de la classe prciser si celle-ci est abstraite.
2- Lors de la dclaration des mthodes, dfinies au niveau des classes filles, prciser qu'elles
sont virtuelles pures.

Exemple :
Classe abstraite CJoueur
dbut
Protg :
sJOENom : chane
sJOERle : chane
Public :
virtuelle CJoueur()=0
virtuelle JOEJouer()=0
fin
Les mthodes virtuelles pures ne sont pas dfinies dans la classe abstraite mais le sont aussi dans
chacune des classes filles.