Vous êtes sur la page 1sur 25

PROGRAMMATION

ORIENTEE OBJET

Par ZOUBIR Hamza


1

Table des matires


1. Lobjet ...............................................................................................................................................4
2. Objet et classe ...............................................................................................................................5
3. Les trois fondamentaux de la POO ........................................................................................5

II-

3.1.

Encapsulation ........................................................................................................................5

3.2.

Hritage ...................................................................................................................................5

3.3.

Polymorphisme .....................................................................................................................7

Diffrents types de mthodes.....................................................................................................8


1. Constructeurs et destructeurs .................................................................................................8
1.1.
1.2.

Constructeurs ........................................................................................................................8
Destructeurs ...............................................................................................................................8

2. Pointeur interne ............................................................................................................................8


3. Visibilit ...........................................................................................................................................8
3.1.

Champs et mthodes publics ..........................................................................................9

3.2.

Champs et mthodes privs ............................................................................................9

3.3.

Champs et mthodes protgs ......................................................................................9

4. Surcharge et redfinition des mthodes d'une classe....................................................9


III-

Adapter pattern ......................................................................................................................... 10

1. But .................................................................................................................................................. 10
2. Structure ....................................................................................................................................... 10
3. Participants .................................................................................................................................. 10
4. Utilisations connues ................................................................................................................. 10
IV-

Exemples ...................................................................................................................................... 11

1. Class Point ................................................................................................................................... 11


2. Class Segment ............................................................................................................................ 13
3. Class pile....................................................................................................................................... 14
4. class Rationel .............................................................................................................................. 15
5. Classe matrice : .......................................................................................................................... 19
6. Classe forme : ............................................................................................................................. 20
2

7. Classearticle : .............................................................................................................................. 21
8. Gestion des Compitions ......................................................................................................... 22
Documentation des classes ............................................................................................................... 22
Rfrence de la classe Date ........................................................................................................... 22
Fonctions membres publiques ................................................................................................ 22
Rfrence de la classe Entraineur................................................................................................ 22
Fonctions membres publiques ................................................................................................ 22
Rfrence de la classe Equipe ...................................................................................................... 23
Fonctions membres publiques ................................................................................................ 23
Rfrence de la classe Joueur ....................................................................................................... 23
Fonctions membres publiques ................................................................................................ 23
Rfrence de la classe Matche ..................................................................................................... 23
Fonctions membres publiques ................................................................................................ 23
Fonctions membres publiques ................................................................................................ 24
Documentation des fichiers ............................................................................................................... 24
Rfrence du fichier Date.cpp ...................................................................................................... 24
Rfrence du fichier Date.h ........................................................................................................... 24
Classes .............................................................................................................................................. 24
Rfrence du fichier Entraineur.cpp ........................................................................................... 24
Rfrence du fichier Entraineur.h ................................................................................................ 24
Classes .............................................................................................................................................. 24
Classes .............................................................................................................................................. 25
Rfrence du fichier Gestioncompetition.cpp ........................................................................ 25
Macros .............................................................................................................................................. 25
Fonctions ......................................................................................................................................... 25

I-

Object-Oriented Programming

Ces termes sont devenus trs communs, dit-il. Malheureusement peu de gens
sont d'accord sur leur sens". On met souvent en parallle les notions de "type
abstrait" et d'objet (une classe dfinit un type pour toutes ses instances), tel point
que beaucoup confondent volontairement type et classe. Des langages comme ADA,
Clu, C++ donnent la possibilit de dfinir des types qui se manipulent plus ou moins
de la mme faon que des types de base. Cela donne lieu ce que l'on appelle
souvent "types abstraits de donnes .

1. Lobjet
Il est impossible de parler de Programmation Oriente Objet sans parler
d'objet, bien entendu. Tchons donc de donner une dfinition aussi complte que
possible d'un objet.
Un objet est avant tout une structure de donnes. Autrement, il s'agit d'une
entit charge de grer des donnes, de les classer, et de les stocker sous une
certaine forme. En cela, rien ne distingue un objet d'une quelconque autre structure
de donnes. La principale diffrence vient du fait que l'objetregroupe les donnes et
les moyens de traitement de ces donnes
Un objet rassemble de fait deux lments de la programmation procdurale.
Les champs :
Les champs sont l'objet ce que les variables sont un programme : ce sont
eux qui ont en charge les donnes grer. Tout comme n'importe quelle autre
variable, un champ peut possder un type quelconque dfini au pralable : nombre,
caractre... ou mme un type objet.
Les mthodes :
Les mthodes sont les lments d'un objet qui servent d'interface entre les
donnes et le programme. Sous ce nom obscur se cachent simplement des
procdures ou fonctions destines traiter les donnes.
Les champs et les mthodes d'un objet sont ses membres.
Si nous rsumons, un objet est donc un type servant stocker des donnes
dans des champs et les grer au travers des mthodes.

Si on se rapproche du Pascal, un objet n'est donc qu'une extension volue


des enregistrements (type record) disposant de procdures et fonctions pour grer
les champs qu'il contient.

2. Objet et classe
Avec la notion d'objet, il convient d'amener la notion de classe. Cette notion
de classe n'est apparue dans le langage Pascal qu'avec l'avnement du langage
Delphi et de sa nouvelle approche de la Programmation Oriente Objet. Elle est
totalement absente du Pascal standard.
Ce que l'on a pu nommer jusqu' prsent objet est, pour Delphi, une classe
d'objet. Il s'agit donc du type proprement parler. L'objet en lui-mme est une
instance de classe, plus simplement un exemplaire d'une classe, sa reprsentation en
mmoire.

3. Les trois fondamentaux de la POO


La Programmation Oriente Objet est dirige par trois fondamentaux qu'il
convient de toujours garder l'esprit : encapsulation, hritage et polymorphisme.
Houl ! Inutile de fuir en voyant cela, car en fait, ils ne cachent que des choses
relativement simples. Nous allons tenter de les expliquer tout de suite.
3.1. Encapsulation
L'encapsulation introduit donc une nouvelle manire de grer des donnes. Il
ne s'agit plus de dclarer des donnes gnrales puis un ensemble de procdures et
fonctions destines les grer de manire spare, mais bien de runir le tout sous le
couvert d'une seule et mme entit.
Si l'encapsulation est dj une ralit dans les langages procduraux (comme
le Pascal non objet par exemple) au travers des units et autres librairies, il prend une
toute nouvelle dimension avec l'objet.
Pour conclure, l'encapsulation permet de garder une cohrence dans la
gestion de l'objet, tout en assurant l'intgrit des donnes qui ne pourront tre
accdes qu'au travers des mthodes visibles.
3.2. Hritage
Spcialiser et factoriser : important pour la "rutilisation".
Les connaissances les plus gnrales sont mises en commun dans des classes qui
sont ensuite spcialisespar dfinitions de sous-classes(connaissances spcifiques).
Une sous-classe est donc la spcialisation de la description d'une classe appele sa
superclasse.

Une sous-classe hrite de sa superclasse.


Conceptuellement tout se passe comme si les informations de la superclasse taient
recopies dans la sous-classe.
La spcialisation d'une classe peut tre ralise selon deux techniques :
-l'enrechissement: la sous-classe est dote de nouvelles variables d'instances
et/ou de mthodes.
- substitution: donner une nouvelle dfinition une mthode hrit, lorsque
celle-ci se rvle inadquate pour l'ensemble des objets de la sous-classe
(masquage).
Le graphe d'hritage
La relation d'hritage lie une classe sa superclasse.
Lorsqu'une classe n'a qu'une seule superclasse c'est l'hritage simple, le graphe
d'hritage constitue un arbre.
La structuration en classes et sous-classes entrane une modularit importante.
Les modifications dans une classe n'ont d'incidence que dans le sous-arbre de la
classe considre.

3.3. Polymorphisme
Le terme polymorphisme est certainement celui que l'on apprhende le plus.
Mais il ne faut pas s'arrter cela. Afin de mieux le cerner, il suffit d'analyser la
structure du mot : poly comme plusieurs et morphisme comme forme. Le
polymorphisme traite de la capacit de l'objet possder plusieurs formes.
Cette capacit drive directement du principe d'hritage vu prcdemment. En
effet, comme on le sait dj, un objet va hriter des champs et mthodes de ses
anctres. Mais un objet garde toujours la capacit de pouvoir redfinir une mthode
afin de la rcrire, ou de la complter.
On voit donc apparatre ici ce concept de polymorphisme : choisir en fonction
des besoins quelle mthode anctre appeler, et ce au cours mme de l'excution. Le
comportement de l'objet devient donc modifiable volont.

Le polymorphisme, en d'autres termes, est donc la capacit du systme


choisir dynamiquement la mthode qui correspond au type rel de l'objet en cours.
Ainsi, si l'on considre un objet Vhicule et ses descendants Bateau, Avion, Voiture
possdant tous une mthode Avancer, le systme appellera la fonction Avancer
spcifique suivant que le vhicule est un Bateau, un Avion ou bien une Voiture.

II-

Diffrents types de mthodes

1. Constructeurs et destructeurs
1.1. Constructeurs
Une fonction membre portant le mme nom que sa classe se nomme
constructeur. Ds qu'une classe comporte un constructeur, lors de la dclaration d'un
objet de cette classe, il faut fournir des valeurs pour les arguments requis par ce
constructeur. Le constructeur est appel aprs l'allocation de l'espace mmoire
destin l'objet.

1.2.

Destructeurs

Une fonction membre portant le mme nom que sa classe, prcd du signe
(~), se nomme un destructeur. Le destructeur est appel avant la libration de
l'espace mmoire associ l'objet.
Constructeur et destructeur ne renvoie pas de valeur (aucune indication de
type, mme pas void !!).
Un destructeur ne peut pas comporter d'arguments .

2. Pointeur interne
Trs souvent, les objets sont utiliss de manire dynamique, et ne sont donc crs
que lors de l'excution. Si les mthodes sont toujours communes aux instances d'un
mme type objet, il n'en est pas de mme pour les donnes.
Il peut donc se rvler indispensable pour un objet de pouvoir se rfrencer
lui-mme. Pour cela, toute instance dispose d'un pointeur interne vers elle-mme.

3. Visibilit
De par le principe de l'encapsulation, afin de pouvoir garantir la protection des
donnes, il convient de pouvoir masquer certaines donnes et mthodes internes les
grant, et de pouvoir laisser visibles certaines autres devant servir la gestion
publique de l'objet. C'est le principe de la visibilit.

3.1.

Champs et mthodes publics


Comme leur nom l'indique, les champs et mthodes dits publics sont
accessibles depuis tous les descendants et dans tous les modules :
programme, unit...
On peut considrer que les lments publics n'ont pas de restriction
particulire.
Les mthodes publiques sont communment appeles accesseurs : elles
permettent d'accder aux champs d'ordre priv.
3.2.

Champs et mthodes privs


La visibilit prive restreint la porte d'un champ ou d'une mthode au
module o il ou elle est dclar(e). Ainsi, si un objet est dclar dans une unit
avec un champ priv, alors ce champ ne pourra tre accd qu' l'intrieur
mme de l'unit.
Cette visibilit est bien considrer. En effet, si un descendant doit
pouvoir accder un champ ou une mthode priv(e), alors ce descendant
doit ncessairement tre dclar dans le mme module que son anctre.
3.3.

Champs et mthodes protgs


La visibilit protg correspond la visibilit priv except que tout
champ ou mthode protg(e) est accessible dans tous les descendants, quel
que soit le module o ils se situent.

4. Surcharge et redfinition des mthodes d'une classe


Nous avons dj parl de la possibilit, lors de la cration d'une classe hritant
d'une autre classe, de surcharger certaines de ses mthodes. La surcharge, signale
par le mot-cl override suivant la dclaration d'une mthode dj existante dans la
classe parente, n'est possible que sous certaines conditions :
Vous devez avoir accs la mthode surcharge. Ainsi, si vous tes dans la
mme unit que la classe parente, vous pouvez ignorer cette restriction. Sinon, en
dehors de la mme unit, la mthode doit tre au minimum protge.
mthode de la classe parente doit tre soit virtuelle (dclare par la mot-cl
virtual) soit dj surcharge (override).

III-

Adapter pattern

1. But
Il permet de convertir l'interface d'une classe en une autre interface que le
client attend. L' Adaptateur fait fonctionner ensemble des classes qui n'auraient
pas pu fonctionner sans lui, cause d'une incompatibilit d'interfaces.

2. Structure

3. Participants
IAdaptateur : Dfinit l'interface mtier utilise par le Client.
Client : Travaille avec des objets utilisant l'interface IAdaptateur.
Adapt : Dfinit une interface existante devant tre adapte.
Adaptateur : Fait correspondre l'interface de Adapt l'interface IAdaptateur.

4. Utilisations connues
On peut galement utiliser un adaptateur lorsque l'on ne veut pas dvelopper
toutes les mthodes d'une certaine interface. Par exemple, si l'on doit dvelopper
l'interface MouseListener en Java, mais que l'on ne souhaite pas dvelopper de
comportement pour toutes les mthodes, on peut driver la classe MouseAdapter.
Celle-ci fournit en effet un comportement par dfaut (vide) pour toutes les
mthodes de MouseListener.
Exemple avec le MouseAdapter :
public class MouseBeeper extends MouseAdapter
{
public void mouseClicked(MouseEvent e) {
Toolkit.getDefaultToolkit().beep();
}
}

Exemple avec le MouseListener :


10

public class MouseBeeper implements MouseListener


{
public void mouseClicked(MouseEvent e) {
Toolkit.getDefaultToolkit().beep();
}
public
public
public
public

void
void
void
void

mousePressed(MouseEvent e) {}
mouseReleased(MouseEvent e) {}
mouseEntered(MouseEvent e) {}
mouseExited(MouseEvent e) {}

IV-

Exemples

1. Class Point
Un point est dfini par 2 valeurs abscisse et ordonn.
Jai ajout sur la mme classe certaine Mthode, surtout la surcharge des oprateurs.

Mthode pour dplacer un point


Mthode pour multiplier deux points
Mthode de surcharge de loprateur affectation (+=)
Mthode de surcharge de loprateur de test dgalit (==)
Jai ajout aussi une mthode qui nous permet de savoir le nombre des
points crer

11

12

2. Class Segment
On utilisant la classe prcdemment crer (la classe point) on a cr une autre classe
segment, le segment est compose de deux points origine et extrmit.
Jai implment dans cette classe les mthodes suivantes :

Mthode qui calcul la longueur du segment


Mthode qui renvoi lorigine du segment
Mthode qui renvoi extrmit du segment
Mthode qui calcul le point milieu du segment

13

3. Class pile
Dans ce programme on a cr une classe pile laide dune liste chaine.
Jai dcid de refaire le mme projet mais cette fois laide dun tableau dynamique,
en ajoutant a a la notion Template.
Et jai ajout une mthode qui nous permet de nombrer les lments dans notre pile.

14

4. class Rationel
Sur lexemple suivant jai cr une classe rationnel qui va nous permettre de
manipuler les nombre rationnel, rappelons que un nombre rationnel est constituer
dun numrateur et un dnominateur.
Jai implment dans cette classe plusieurs mthodes :

Constructeur par dfaut


Constructeur avec paramtres
Destructeur
Mthode qui renvoi la partie entire
Mthode qui renvoi la partie relle
Mthode qui fait la somme de 2 rationnels
Mthode daffichage
Mthode pour inverser un rationnel
Mthode pour calculer le pgcd
Et finalement jai surcharg les oprateurs +, -, *, / pour la classe rationnel

15

16

Exercice dematrice :
Il nous faut dabord une classErreur qui genre les erreurs de la classe matrice
Classe erreur :

17

18

5. Classe matrice :

19

6. Classe forme :
On utilisant la classe prcdemment crer la classe point on a cr une autre classe
forme

20

7. Classearticle :

21

8. Gestion des Compitions

Documentation des classes


Rfrence de la classe Date
#include <Date.h>
Fonctions membres publiques

Date (int, int, int)


~Date ()
void print ()

La documentation de cette classe a t gnre partir des fichiers suivants :

Date.h
Date.cpp

Rfrence de la classe Entraineur


#include <Entraineur.h>
Graphe d'hritage de Entraineur:

Fonctions membres publiques

Entraineur (string, string, string, int)


int trainthiseqp (int)
~Entraineur ()

La documentation de cette classe a t gnre partir des fichiers suivants :

Entraineur.h
Entraineur.cpp
22

Rfrence de la classe Equipe


#include <Equipe.h>
Fonctions membres publiques

Equipe (int, string)


void print ()
int recherche (int)
~Equipe ()

La documentation de cette classe a t gnre partir des fichiers suivants :

Equipe.h
Equipe.cpp

Rfrence de la classe Joueur


#include <Joueur.h>
Graphe d'hritage de Joueur:

Fonctions membres publiques

Joueur (string, string, string, int, int)


int InEquip (int)
~Joueur ()

La documentation de cette classe a t gnre partir des fichiers suivants :

Joueur.h
Joueur.cpp

Rfrence de la classe Matche


#include <Matche.h>
Fonctions membres publiques

Matche (int e1, int e2, int b1, int b2, int jo, int mo, int an)
void print ()
int equip1 ()
23

int equip2 ()
~Matche ()

#include <Personne.h>
Graphe d'hritage de Personne:

Fonctions membres publiques

Personne (string, string, string)


~Personne ()
void print ()

La documentation de cette classe a t gnre partir des fichiers suivants :

Personne.h
Personne.cpp

Documentation des fichiers


Rfrence du fichier Date.cpp
#include "stdafx.h"
#include "Date.h"

Rfrence du fichier Date.h


#include <iostream>

Classes

class Date

Rfrence du fichier Entraineur.cpp


#include "stdafx.h"
#include "Entraineur.h"

Rfrence du fichier Entraineur.h


#include "Personne.h"

Classes

class Entraineur

24

Classes

class Equipe

Rfrence du fichier Gestioncompetition.cpp


#include
#include
#include
#include
#include

"stdafx.h"
<conio.h>
"Matche.h"
"Joueur.h"
"Entraineur.h"

Macros

#define nbmx 30
#define nbj 100

Fonctions

void AddTeam (Equipe **eq, int *i)


void AddPlayer (Joueur **js, int *i)
void AddTrainer (Entraineur **ens, int *i)
void OragMatch (Matche **mts, int *im)
void show (Matche **m, int im, Equipe **eq, int ieq, Joueur **js, int ijo, Entraineur **ens, int ient)
void fre (Equipe **eqp, Entraineur **ens, Joueur **js, Matche **mts, int ie, int im, int ij, int ient)
void menu (Equipe **eqp, Entraineur **ens, Joueur **js, Matche **mts, int *ie, int *im, int *ij, int
*ient)
int _tmain (int argc, _TCHAR *argv[])

25