COURS POO

LICENCE 2
Programmation Orienté Objet

INSITUT INTERNATIONAL 2I

0
Donald MBEMBA Support P.O.O 2023-2024
LA PROGRAMMATION ORIENTEE OBJET (POO) ............................................................................ 3
INTRODUCTION .................................................................................................................................... 3
HISTORIQUE ET NAISSANCE DE LA P.O.O. ..................................................................................... 3
Chapitre 1 : PRESENTATION DE LA NOTION OBJET ....................................................................... 4
1) Définitions d’un objet....................................................................................................................... 4
2) LES OBJETS, ATTRIBUTS ET METHODES ............................................................................... 6
a) La notion d’objet ............................................................................................................................. 6
b) La notion de classe ........................................................................................................................... 7
c) Attributs ou champs ........................................................................................................................ 7
d) Méthodes, actions ou comportements ............................................................................................. 7
e) Message ............................................................................................................................................ 7
3) Création d’un objet ........................................................................................................................... 7
4) Attribut d’instance, attribut de classe, méthode d’instance, méthode de classe ............................... 9
Chapitre 2 : LE PRINCIPE D’ENCAPSULATION ............................................................................... 10
Remarque ............................................................................................................................................ 11
Chapitre 3 : NOTION DE CLASSE ET D’INSTANCE......................................................................... 11
Introduction......................................................................................................................................... 11
1) La déclaration d’une classe ............................................................................................................ 11
Remarque : .......................................................................................................................................... 12
2) Déclaration et création d’une instance d’une classe ....................................................................... 12
a) La déclaration de l’instance ............................................................................................................ 12
b) La création effective de l’instance.................................................................................................. 13
3) Accès aux éléments de la classe ..................................................................................................... 13
4) Représentation algorithmique de la classe compte ......................................................................... 13
5) Constructeur et destructeur ............................................................................................................. 14
6) Les accesseurs et les mutateurs ...................................................................................................... 16
7) Attribut et méthode statique ........................................................................................................... 17
8) La référence sur l'objet courant : this ............................................................................................. 18
9) Surcharge des méthodes ................................................................................................................ 18
Chapitre 4 : HERITAGE ......................................................................................................................... 19
1) Définitions ...................................................................................................................................... 19
2) Graphe d’héritage .......................................................................................................................... 20
3) Ecriture déclarative......................................................................................................................... 21
4) Héritage multiple ............................................................................................................................ 22
5) Les méthodes virtuelles (redéfinition des méthodes) ..................................................................... 22
6) La référence à la classe mère : super .............................................................................................. 24
Chapitre 5 : LE POLYMORPHISME .................................................................................................... 24
1) Définition ....................................................................................................................................... 24
2) La puissance du polymorphisme .................................................................................................... 24
3) Une forme faible de polymorphisme : la surcharge ....................................................................... 25
Chapitre 6 : LES CLASSES ABSTRAITES........................................................................................... 25
1) Définition ....................................................................................................................................... 25
2) Le but des classes abstraites ........................................................................................................... 26
Chapitre 7 : LIEN ET AGREGATION ................................................................................................... 29
1) L'instanciation (Lien : 'instance de') ............................................................................................... 29
2) L'héritage (Lien : 'est-un')............................................................................................................... 29
3) Les objets complexes (Lien : 'référence-à' et 'composé-de')........................................................... 29
4) Agrégation et composition ............................................................................................................. 30
Chapitre 8 : LES TABLEAUX ............................................................................................................... 31
Syntaxe de déclaration ........................................................................................................................ 32
Un tableau est un objet........................................................................................................................ 32

1
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 Les vecteurs(collections) .................................................................................................................... 33

2
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
LA PROGRAMMATION ORIENTEE OBJET (POO)

INTRODUCTION
La programmation classique telle qu’étudiée au travers des langages procédurales comme le
C, le Pascal… définie un programme comme étant un ensemble de données sur lesquelles
agissent des procédures et des fonctions. Les données constituent la partie passive du
programme. Les procédures et les fonctions constituent la partie active.

Dans cette approche données et procédure sont traitées indépendamment les unes des autres
sans tenir compte des relations étroites qui les unissent.

Les langages objets sont nés pour améliorer la conception et le développement des logiciels.
Ils sont fondés sur la connaissance d’une seule catégorie d’entités informatiques : les objets.

Un objet incorpore des aspects statiques et dynamiques au sein d’une même notion. La
Programmation Orientée Objet (POO) est une méthode d’implémentation dans laquelle les
programmes sont organisés sous formes de collections coopératives d’objets, dont chacun
représente une instance d’une classe quelconque et dont toutes les classes sont membres d’une
hiérarchie de classes unis à travers des relations d’héritage.

Ainsi dans l’approche orienté objet un algorithme sera essentiellement vu comme un ensemble
d’objets auxquels l’utilisateur envoie des messages et qui s’en envoient pendant le
fonctionnement.

HISTORIQUE ET NAISSANCE DE LA P.O.O.

La programmation orientée objet (POO) débute en Norvège, à la fin des années 1960 avec le
langage Simula.

3
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Les années 1970 ont vu naître d’autres langages tels que Smalltalk (développé par Xérox, pour
le premier système multi fenêtrage avec écran bitmap et souris, repris plus tard par l’Apple
Macintosh, puis copié par Microsoft Windows.

Au cours des années 1980, avec l’arrivée des stations de travail et des ordinateurs personnels,
l’intérêt pour les interfaces graphiques s’est accru et on a vu apparaître des langages «
purement orienté objet » (Eiffel) et des extensions « orientées objet » de langage existants
(C++, étendant le C, et des versions « objet » de Pascal (Delphi), Prolog, Lisp,. . .).

Pendant les années 1990, de nouveaux langages orientés objet sont apparus. On citera, par
exemple : Java, Objective Caml, Python.

Chapitre 1 : PRESENTATION DE LA NOTION OBJET

Le monde dans lequel nous vivons est constitué d'objets. Les méthodes actuelles de
développement informatique permettent de manipuler le concept d'objets. La Programmation
Orientée Objet (POO) consiste à modéliser un ensemble d’éléments du monde réel en un
ensemble d’entités informatiques appelés objet. Cela est plus proche du monde réel, dans
lequel tous les objets disposent d’attributs auxquels sont associés des activités.

1) Définitions d’un objet

Un objet est une entité cohérente rassemblant des données et du code travaillant sur ses
données. Une classe peut être considérée comme un moule à partir duquel on peut créer des
objets. En fait, on considère plus souvent que les classes sont les descriptions des objets,
lesquels sont des instances de leur classe.

Une classe décrit la structure interne d'un objet : les données qu'il regroupe, les actions qu'il
est capable d'assurer sur ses données. Un objet est un état de sa classe. Considérons par
exemple la modélisation d'un véhicule telle que présentée par la figure suivante :

4
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Légende :
# : Protégé
- : Privé
+ : public Figure 1.1 Représentation de la classe Véhicule
La classe Vehicule possède les attributs NombreDeVehicules, Marque puissance fiscale,
vitesse maximale, vitessecourante et des methodes creerUnvehicule(), detriureUnVehicule(),
demarrer(), accelerer(), avancer() et reculer().

Implémentation du code en java

package [Link];

public class Véhicule {

protected int NombreDeVehicules;
protected String Marque;
protected int puissancefiscale;
protected int vitessemaximale;
protected int vitessecourante;

public void creerUnvehicule() {

public void detriureUnVehicule() {

public void demarrer() {

5
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 public int accelerer() {
return 0;
}

public void avancer() {

public void reculer() {

2) LES OBJETS, ATTRIBUTS ET METHODES

La principale difficulté d’un algorithme par objet sera dans la détermination des bons objets.
Ceci constitue l’objectif de l’étape d’analyse et conception qui précède la mise en place d’une
application informatique.

a) La notion d’objet
Un objet au sens informatique du terme permet de désigner une représentation "abstraite"
d'une chose concrète du monde réel ou virtuel. Un objet présente les 3 caractéristiques
suivantes :

Objet = État + Comportement + Identité

L'état d'un objet définit la valeur des données (ou attributs), par exemple dans le cas d'un
objet Moto, celui-ci pourrait être caractérisé par les attributs suivants : la marque, la couleur,
le poids, la puissance, la quantité d'essence... Ce que l'on représente graphiquement par :

L'état de l'objet peut être amené à changer durant son cycle de vie. Par exemple, la quantité
d'essence et le poids de la moto varient en permanence lorsque celle-ci roule.

• Le comportement d'un objet indique toutes les compétences de celui-ci et décrit les
actions et les réactions qu'il peut avoir. Chaque élément de base du comportement est appelé
opération. Les opérations d'un objet sont déclenchées suite à une stimulation externe de

6
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
l'utilisateur qui appuie sur un bouton ou du programmeur qui appelle une opération. Il existe
un lien très étroit entre le comportement d'un objet et son état.

• L'identité : En plus de son état et de son comportement, un objet possède une identité
qui caractérise son existence propre. L'identité permet de distinguer tout objet de façon non
ambiguë, et cela indépendamment de son état.

Ainsi une moto est identifiée par son numéro de série, un compte en banque par son numéro
de compte.

b) La notion de classe
On appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble des entités
qui composeront un objet.

Une classe est composée de deux parties:

Les attributs ou données membres: données représentant l'état de l'objet, Les
méthodes ou fonctions membres: opérations applicables aux objets.

c) Attributs ou champs
Les attributs d’un objet sont l’ensemble des informations se présentant sous forme de variable
et permettant de représenter l’état de l’objet.

d) Méthodes, actions ou comportements

Une méthode est une fonction ou procédure liée à un objet qui est déclenchée à la réception
d’un message particulier : la méthode déclenchée correspond strictement au message reçu. La
liste des méthodes définies au sein d’un objet constitue l’interface de l’objet pour l’utilisateur.

e) Message
Un message est une demande d’activation d’une méthode envoyé à un objet. Les messages
auquel l’objet peut répondre sont en fait les intitulés des méthodes qu’il peut déclencher : les
identificateurs et le type des paramètres nécessaires.

3) Création d’un objet

La figure suivante montre l'opération d'instanciation de la classe en 2 objets différents :

7
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Figure 1.2 Instanciation d’une classe en deux objets

Exemple : Instanciation d’un objet en JAVA

package [Link];

public class Driver {

public static void main(String[] args) {

Véhicule véhicule1 = new Véhicule();

protected vé[Link]="Lotus";
protected vé[Link] = 11;
protected vé[Link] = 230;
protected vé[Link] = 170;

Véhicule véhicule2 = new Véhicule();

Vé[Link]="Peugeaot";
Vé[Link] = 7;
Vé[Link] = 150;
Vé[Link] = 50;

8
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
}

4) Attribut d’instance, attribut de classe, méthode d’instance,

méthode de classe
Dans le modèle précédent, un véhicule est représenté par une chaîne de caractères (sa marque)
et trois entiers : la puissance fiscale, la vitesse maximale et la vitesse courante. Toutes ces
données sont représentatives d'un véhicule particulier, autrement dit, chaque objet véhicule
aura sa propre copie de ses données : on parle alors d'attribut d'instance. L'opération
d'instanciation qui permet de créer un objet à partir d'une classe consiste précisément à fournir
des valeurs particulières pour chacun des attributs d'instance.

En revanche, considérons l'attribut Nombre de véhicules chargé de compter le nombre de

véhicules présents à un moment donné dans la classe. Il est incrémenté par l'opération Créer
un véhicule et décrémenté par l'opération Détruire un véhicule. C'est un exemple typique
d'attribut partagé par l'ensemble des objets d'une même classe. Il est donc inutile et même
dangereux (penser aux opérations de mise à jour) que chaque objet possède sa copie propre de
cet attribut, il vaut mieux qu'ils partagent une copie unique située au niveau de la classe. On
parle donc d'attribut de classe.

Le même raisonnement s'applique directement aux méthodes. En effet, de la même manière

que nous avions établi une distinction entre attributs d'instance et attributs de classe, nous
allons différencier méthodes d'instances et méthodes de classe.

Prenons par exemple la méthode Démarrer. Il est clair qu'elle peut s'appliquer
individuellement à chaque véhicule pris comme entité séparée. En outre, cette méthode va
clairement utiliser les attributs d'instance de l'objet auquel elle va s'appliquer c'est donc une
méthode d'instance.

Considérons désormais le cas de la méthode Créer un véhicule. Son but est de créer un
nouveau véhicule, lequel aura, dans un second temps, le loisir de positionner des valeurs
initiales dans chacun de ces attributs d'instance. Si nous considérons en détail le processus
permettant de créer un objet, nous nous apercevons que la première étape consiste à allouer de
la mémoire pour le nouvel objet. Hors cette étape n'est clairement pas du ressort d'un objet :
seule la classe possède suffisamment d'informations pour la mener à bien : la création d'un
objet est donc en partie une méthode de classe. Notons également qu'au cours de cette étape,
l'objet recevra des indications additionnelles, telles que, par exemple, une information lui
indiquant à quelle classe il appartient. En revanche, considérons la phase d'initialisation des
attributs. Celle-ci s'applique à un objet bien précis : celui en cours de création. L'initialisation
des attributs est donc une méthode d'instance.
Nous aboutissons finalement au constat suivant : la création d'un nouvel objet est constituée
de deux phases :
Une phase du ressort de la classe : allouer de la mémoire pour le nouvel objet et lui fournir
un contexte d'exécution minimaliste.

9
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 Une phase du ressort de l'objet : initialiser ses attributs d'instance.

Si ces deux phases sont clairement séparées dans un langage tel que l'objective C, elles ne le
sont plus en C++ ou en Java qui agglomèrent toute l'opération dans une méthode spéciale, ni
vraiment méthode d'instance, ni méthode de classe : le constructeur.

Pour dire qu’un attribut ou une méthode appartient à la classe en java, il faut ajouter le mot clé
static devant la variable créée.
Exemple :
protected static int NombreDeVehicules;

Chapitre 2 : LE PRINCIPE D’ENCAPSULATION

Sans le savoir, nous avons sans doute déjà mis le doigt sur l'un des trois grands principes du
paradigme objet : l'encapsulation. Ce principe prône les idées suivantes :
• Un objet rassemble en lui-même ses données (les attributs) et le code capable d'agir
dessus (les méthodes),
• Abstraction de données : la structure d'un objet n'est pas visible à l'extérieur, son
interface est constituée de messages invocables par un utilisateur. La réception d'un
message déclenche l'exécution de méthodes.
• Abstraction procédurale : du point de vue de l’extérieur l’invocation d'un message est
une opération atomique. L'utilisateur n'a aucun élément d'information sur la mécanique
interne mise en œuvre. Par exemple, il ne sait pas si le traitement requis a demandé
l’intervention de plusieurs méthodes ou même la création d’objets temporaires ... Dans
les versions canoniques du paradigme objet, les services d'un objet ne sont invocables
qu’au travers de messages (méthode), lesquels sont individuellement composés de:
Un nom ;
Une liste de paramètres en entrée ;
Une liste de paramètres en sortie.

On précise trois modes d’accès aux attributs et méthodes d’un objet :

- Le mode public avec lequel les éléments seront accessibles directement par l’objet lui-
même ou par d’autres objets. Il s’agit du niveau le plus bas de protection.
- Le mode privé avec lequel les éléments de l’objet seront inaccessibles à partir d’autres
objets : seules les méthodes de l’objet pourront y accéder. Il s’agit du niveau le plus fort de
protection.
- Le mode protégé : avec lequel les attributs de l’objet seront accessibles par les
méthodes de l’objet et les classes filles (Héritage).

10
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 Remarque
La liste des messages auxquels est capable de répondre un objet constitue son interface : c'est
la partie publique d'un objet. Tout ce qui concerne son implémentation doit rester caché à
l'utilisateur final : c'est la partie privée de l'objet. Bien entendu, tous les objets d'une même
classe présentent la même interface.
En pratique, dans la plupart des langages orientés objet modernes, l'interface représente la liste
des méthodes accessibles à l'utilisateur.
Tous les langages orientés objet n'imposent pas de respecter le principe d'encapsulation. C'est
donc au programmeur de veiller personnellement à le respecter.

Chapitre 3 : NOTION DE CLASSE ET D’INSTANCE

Introduction
Une classe est un type de données abstrait caractérisé par des propriétés (attributs et
méthodes) communes à des objets et permettant de créer des objets possédant ces propriétés.

Les inscriptions précises qui permettent de créer les objets définis en deux temps :

La déclaration de l’objet,
La création effective et utilisable de l’objet comme instance au quelle on peut envoyer
des messages.

1) La déclaration d’une classe

La syntaxe de déclaration d’une classe est la suivante :

Classe « nomDeLaclasse »

Debut

Déclaration des attributs

Signature des methodes

Fin

Exemple de la classe Compte :

11
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
La déclaration de la classe compte revient à définir son numéro et son solde et à préciser
comment accéder à ces informations.

La classe compte possède les deux attributs numéro et solde et quatre méthodes :

• La méthode créer(chaine,réel), qui permet de donner des valeurs aux attributs,

• La méthode debiter (montant :réel), qui diminue le solde,
• La méthode crediter(montant :réel) qui augmente le solde,
• La méthode SoldeCourant() qui récupère le solde courant d’un compte.
Syntaxe de la classe Compte :

Classe Compte
DEBUT
Privé :
Numero :chaine de caracteres
Solde :réel
Public :
Procedure Créer(chaine,réel)
Procedure Debiter(montant :réel)
Procedure Crediter(montant :réel)
Fonction Solde_courant() :réel
FIN

Remarque :
La précision d’une méthode notamment le type de ses arguments et du type de données de
retour s’appelle sa signature.

2) Déclaration et création d’une instance d’une classe

Pour utiliser un objet d’une classe dans un programme on doit créer une instance de la classe
c’est à dire une variable du type de la classe. Les instances indique qu’un identifiant est un
objet de la classe et à ce titre se réfère à la classe et possède ses attributs et méthodes. La
création d’une instance de classe se fait en deux étapes :

• La déclaration de l’instance,
• La création effective de l’instance.

a) La déclaration de l’instance
nomInstance :nomClasse

Exemple :

Cpte :Compte

Exemple d’une déclaration en java :

12
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Véhicule véhicule1;

b) La création effective de l’instance

La création effective de l’instance est effectuée grâce à la méthode de construction appelée
Constructeur et à l’utilisation de new.

Dans l’exemple de la classe Compte c’est la méthode créer () qui remplace le constructeur.

Cpte=new Compte()

Exemple en java :

véhicule1 = new Véhicule() ;

3) Accès aux éléments de la classe

Une fois qu’un objet est créé on peut accéder aux éléments de la classe par

[Link]() pour une méthode [Link] pour un

attribut

Exemple :[Link](“0123123891“,175000)

[Link](50000)

4) Représentation algorithmique de la classe compte

La création de la classe constitue la déclaration de la classe et la rédaction des corps des
méthodes.

Exemple de la classe Compte :

• Déclaration de la classe
Classe Compte
DEBUT
Privé :
Numero :chaine de caracteres
Solde :réel
Public :
Procedure Créer(chaine,réel)
Procedure Debiter(montant :réel)
Procedure Crediter(montant :réel)
Fonction SoldeCourant() :réel
FIN
• Rédaction des corps des méthodes (définition des méthodes)

13
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 Procedure Compte ::Créer(num :chaine,sol :réel)
Début
Numero<-num
solde<-sol
Fin
Procedure Compte ::debiter(mtant :réel)
Début
solde<-solde-mtant
Fin

Procedure Compte ::crediter(mtant :réel)

Début
solde<-solde+mtant
Fin

Fonction Compte ::SoldeCourant() :réel

Début
Retourner solde
Fin

Exemple d’algorithme de manipulation

Algorithme manipCompte
Utilise Compte
Var cp :Compte
Debut
Cp=new Compte()
[Link](“12112121212A “,150000) ;
Afficher“ le solde initial du compte est“,[Link]()
[Link](40000)
Afficher“ le solde courant du compte est“,[Link]()
[Link](20000) ;
Afficher“ le solde courant du compte est“,[Link]() FIN

5) Constructeur et destructeur
Un constructeur est une méthode particulière d’une classe qui permet, lors de la création
effective d’un objet, instance de la classe, d’initialiser ces attributs. Cette méthode porte le
nom de la classe et ne retourne pas de valeur.

Exemple :

14
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Représentation de la classe Rectangle
Classe Rectangle
DEBUT
Privé
Longueur :réel
Largeur :réel
Public
Rectangle (réel, réel)
Fonction surface () : réel
Fonction périmètre () : réel
Procédure affiche ()
FIN

Rectangle :: Rectangle(lo :réel,lar :réel)

DEBUT
Longueur<-lo
Largeur<-lar
FIN

Fonction Rectangle :: Surface() :réel

DEBUT
Retourner(longueur*largeur)
FIN

Fonction Rectangle :: périmetre() :réel

DEBUT
Retourner(2*(longueur+largeur))
FIN

Procédure Rectangle ::affiche ()

DEBUT
Afficher(“rectangle de longueur : “,longueur,“ et de largeur “,largeur)
FIN
Algorithme testRectangle

15
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Var rect :rectangle
DEBUT
Rect=new Rectangle(12,5.6)
Afficher [Link]()
Afficher [Link]()
[Link]()
FIN

Inversement, dans la plupart des langages une méthode est exécutée automatiquement quand
l'instance devient hors de portée. Cette méthode qui est appelée avant la libération de l'espace
mémoire associé à l'objet est appelée destructeur.

Exemple de code en java : Classe Rectangle

package [Link];

public class Rectangle {

double longueur;
double largeur;

//Constructeur
public Rectangle(double long, double larg) {
longueur = long;
largeur = larg;
}

public double surface() {

return longueur*largeur;
}

public double perimetre() {

return 2*(longueur+largeur);
}
}

Pour représenter le constructeur en UML, on utilise le nom de la classe avec les paramètres
qu’il faut.

6) Les accesseurs et les mutateurs

La protection des données membres
Les données membres portant l'étiquette privé ne peuvent pas être manipulées directement par
les fonctions membres des autres classes. Ainsi, pour pouvoir manipuler ces données
membres, on doit prévoir des méthodes spéciales portant l'étiquette public, permettant de
manipuler ces données.

16
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 • Les fonctions membres permettant d'accéder aux données membres sont appelées
accesseurs, parfois getter (appellation d'origine anglophone).
• Les fonctions membres permettant de modifier les données membres sont appelées
mutateurs, parfois setter (appellation d'origine anglophone).
•
La notion d'accesseur
Un accesseur est une fonction membre permettant de récupérer le contenu d'une donnée
membre. Un accesseur, pour accomplir sa fonction :
• doit avoir comme type de retour le type de la variable à renvoyer,
• ne doit pas nécessairement posséder d'arguments.
Une convention de nommage veut que l'on fasse commencer de façon préférentielle le
nom de l'accesseur par le préfixe Get :
Exemple :
Fonction Rectangle ::getLongueur() :réel
DEBUT
Retourner longueur
FIN
Fonction Rectangle ::getLargeur() :réel
DEBUT
Retourner largeur
FIN

La notion de mutateur
Un mutateur est une méthode (procédure membre) permettant de modifier le contenu d'une
donnée membre. Un mutateur, pour accomplir sa fonction :
• doit avoir comme paramètre la valeur à assigner à la donnée membre. Le paramètre
doit donc être du type de la donnée membre,
• ne doit pas nécessairement renvoyer de valeur (procédure).
Une convention de nommage veut que l'on fasse commencer de façon préférentielle le nom du
mutateur par le préfixe Set.
Exemple
Procédure Rectangle ::setLongeur(l :réel)
DEBUT
Longueur<-l
FIN
Procédure Rectangle ::setLargeur(l :réel)
DEBUT
Largeur<-l FIN

7) Attribut et méthode statique

Le mot clé static, utilisé pour un attribut(ou une méthode), permet d'indiquer que cet attribut
(ou méthode) est commun à tous les objets de la classe concernée : il s'agit d'un attribut de la
classe elle-même, et si on modifie cet attribut pour un objet donné, il sera modifié pour tous
les objets de la classe (puisque c'est le même).

17
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 classe Voiture
Debut
prive
static nombre = 0:entier ; id:entier
;
public Voiture(id:entier)
Static fonction getNombre():entire

Fin

Un attribut de classe peut être accédé par n'importe quel nom de référence associé à un objet
de cette classe, ou par le nom de la classe elle-même.

8) La référence sur l'objet courant : this

Ce mot désigne l’adresse de l’objet invoqué. Il est utilisable uniquement au sein d’une
méthode. Le mot clé this permet de désigner l'objet dans lequel on se trouve, c'est-à-dire que
lorsque l'on désire faire référence dans une méthode à l'objet dans lequel elle se trouve, on
utilise this. C’est une référence sur l'objet courant.
L'objet courant this est en réalité une variable système qui permet de désigner l'objet courant.
this peut être utile :

Lorsqu'une variable locale (ou un paramètre) "cache", en portant le même nom, un

attribut de la classe.
Pour déclencher un constructeur depuis un autre constructeur.
Procédure Rectangle ::setLargeur(largeur :réel)
DEBUT
[Link]<-largeur
FIN

9) Surcharge des méthodes

La surcharge ou surdéfinition des méthodes consiste à définir des méthodes différentes
portant le même nom. Dans ce cas, il faut les différencier par le type et/ou le nombre des
arguments.
La surcharge permet de définir des méthodes portant le même nom, mais acceptant des
paramètres de type différents et/ou en nombre différent. En fonction du type et du nombre des
paramètres passés lors de l'appel, c'est une version ou une autre de la méthode qui sera
effectivement appelée.

Attention : Le type de retour d'une méthode ne permet pas de différencier deux méthodes
portant le même nom (si c'est la seule différence).

18
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Classe Rectangle
DEBUT
Privé
Longueur :réel
Largeur :réel
Public
Rectangle (réel, réel)
Rectangle ()
Fonction surface () : réel
Fonction périmètre () : réel
Procédure affiche () : vide
FIN

Rectangle :: Rectangle(lo :réel,lar :réel)

DEBUT
Longueur<-lo
Largeur<-lar
FIN
Rectangle :: Rectangle()
DEBUT
Longueur<-0
Largeur<-0
FIN

Chapitre 4 : HERITAGE
1) Définitions
L'héritage est le second des trois principes fondamentaux du paradigme orienté objet
(encapsulation, héritage, polymorphisme). Il est chargé de traduire le principe naturel de
Généralisation / Spécialisation.
En effet, la plupart des systèmes réels se prêtent à merveille à une classification hiérarchique
des éléments qui les composent. Le principe d'héritage est basé sur l'idée qu'un objet
spécialisé bénéficie ou hérite des caractéristiques de l'objet le plus général auquel il rajoute ses
éléments propres.
En termes de concepts objets cela se traduit de la manière suivante :
On associe une classe au concept le plus général, nous l'appellerons classe de base ou classe
mère ou super - classe.
Pour chaque concept spécialisé, on dérive une classe du concept de base. La nouvelle classe
est dite classe dérivée ou classe fille ou sous-classe
On parle également de relation est-un pour traduire le principe de l’héritage.

19
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution.
Grâce à l'héritage, les objets d'une classe ont accès aux données et aux méthodes de la classe
parente et peuvent les étendre.

2) Graphe d’héritage
Le graphe d’héritage d’un ensemble de classes est la structure représentant la manière dont ces
classes sont liées les unes aux autres par héritage. Ce graphe constitue une hiérarchie.

20
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 3) Ecriture déclarative
Classe Personne
Debut
Privé
Nom :chaine
Age :entier
Sexe :caractere
Public
Personne(chaine,entier,caractere)
Procedure Afficher()
Procedure grandir() Fin

Classe Etudiant hérite de Personne

Début
Privé
Niveau :entier
Filiere :chaine
Public
Procedure reussir()

21
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 Procedure setNiveau()

Procedure setFiliere()
Fonction getNiveau() :entier
Fonction getFiliere() :chaine
Fin
4) Héritage multiple
Certains langages comme le C++ permettent d’utiliser l’héritage multiple.
Il permet de créer des classes dérivées à partir de plusieurs classes de base.

5) Les méthodes virtuelles (redéfinition des méthodes)

Il existe des cas ou le type de l’instance qui appelle une méthode n’est pas connu des la
compilation. Il ne sera déterminé qu’à l’exécution du programme. On peut souhaiter alors
redéfinir les méthodes à différents niveau de la hiérarchie de la classe pour que la méthode
effectivement mise en œuvre soit celle du type réel de l’instance au moment de l’exécution.
Dans ce cas on dit que les méthodes sont virtuelles. On parle aussi de la redéfinition des
méthodes dans les classes filles.

Il est donc possible de redéfinir dans une classe fille une méthode déjà définie dans la classe
mère.

22
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Classe Personne
Debut
Privé
Nom :chaine
Age :entier
Sexe :caractere
Public
Personne(chaine,entier,caractere)
Procedure Afficher()
Procedure grandir() Fin

Classe Etudiant hérite de Personne

Début
Privé :
Niveau :entier
Filiere :chaine
Public:
Etudiant(chaine,entire,caractere,entier,chaine)
Procedure afficher()
Procedure reussir()
Procedure setNiveau()
Procedure setFiliere()
Fonction getNiveu() :entier
Fonction getFiliere() :chaine
Fin
Etudiant ::Etudiant(n :chaine,a :entier,s :caractere,ni :entier,f chaine) :Personne(n,a,s)
DEBUT
Niveau<-ni
Filiere<-f
FIN
Procedure Etudiant ::afficher()
DEBUT
[Link]()
Afficher “est un etudiant de niveau“,niveau,“ et de la filiere“,filiere
FIN
Procedure Etudiant ::reussir()
DEBUT
Si niveau<5 alors niveau<-niveau+1
Finsi
FIN
Procedure Etudiant ::setNiveau(n :entier)
DEBUT
niveau<-n
FIN
Procedure Etudiant ::setFiliere(f:chaine)

23
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 DEBUT
filiere<-f
FIN
Fonction Etudiant ::getNiveau() : entier
DEBUT
Retourner niveau
FIN
Fonction Etudiant ::getFiliere() : chaine
DEBUT
Retourner filiere
FIN

6) La référence à la classe mère : super

Le mot clé super permet d'accéder à la version non redéfinie des attributs et méthodes de la
super-classe. Il permet aussi d'appeler un des constructeurs de la classe mère, avec ou sans
paramètres.

Etudiant ::Etudiant(n :chaine,a :entier,s :caractere,ni :entier,f chaine) :

DEBUT
super(n,a,s)
Niveau<-ni
Filiere<-f
FIN
Procedure Etudiant ::afficher()
DEBUT
[Link]()
Afficher “est un etudiant de niveau“,niveau,“ et de la filiere“,filiere
FIN

Chapitre 5 : LE POLYMORPHISME
1) Définition
Le polymorphisme est le troisième des trois grands principes sur lequel repose le paradigme
objet. Comme son nom l'indique le polymorphisme permet à une méthode d'adopter plusieurs
formes sur des classes différentes. Selon les langages, le polymorphisme pourra s'exprimer sur
l'ensemble des classes d'un système alors que d'autres le confinent aux classes appartenant à
une même hiérarchie.

2) La puissance du polymorphisme
Nous allons démontrer la puissance du polymorphisme au travers de l'exemple classique des
classes d'objets graphiques. Un document dessin peut être vu comme une collection d'objets
graphiques qui va contenir des cercles, des rectangles, des lignes, ou toute autre sorte d'objet

24
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
graphique qui pourrait dériver de la classe ObjetGraphique. En effet, une référence sur un
objet d'une classe spécialisée peut toujours être affectée à une référence sur un objet d'une
classe généraliste.
Si nous voulons dessiner un dessin tout entier, il nous faudra appeler la méthode Afficher pour
chacun des objets contenus dans le dessin. Hors, nous avons pris soin de conserver la même
signature pour les différentes méthodes Afficher de tous les objets appartenant à la hiérarchie
d'ObjetGraphique : c'est la condition Sine Qua Non de l'utilisation du polymorphisme.
Le polymorphisme de la méthode Afficher garantit que la bonne méthode sera appelée sur
chaque objet.

3) Une forme faible de polymorphisme : la surcharge

La surcharge est un mécanisme fréquemment proposé par les langages de programmation
orientés objet et qui permet d’associer au même nom de méthode / fonction / procédure
différentes signatures.
Par exemple, on pourrait proposer deux signatures différentes pour la méthode
Afficher :
Pas d’argument si l’on désire utiliser le périphérique d’affichage par défaut Spécification
d’un périphérique en argument.

Chapitre 6 : LES CLASSES ABSTRAITES

1) Définition
Une classe est dite abstraite si elle ne fournit pas d'implémentation pour certaines de ces
méthodes qui sont dites méthodes abstraites. Bien entendu, étant incomplète, une classe
abstraite ne peut avoir d'instance. Il appartient donc à ces classes dérivées de définir du code
pour chacune des méthodes abstraites. On parlera alors de classes concrètes ; les classes
concrètes étant les seules à même d’être instanciées.

Une méthode est dite abstraite lorsqu’on connaît son entête mais pas la manière dont elle peut
être réalisée (c’est à dire on connaît sa déclaration mais pas sa définition).

On ne peut instancier une classe abstraite : elle est vouée à se spécialiser. Une classe abstraite
peut très bien contenir des méthodes concrètes.

25
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Une classe abstraite pure ne comporte que des méthodes abstraites. En programmation
orientée objet, une telle classe est appelée une interface.

Pour indiquer qu’une classe est abstraite, il faut ajouter le mot-clef abstrait à son nom.

Il est possible de ne pas définir une méthode virtuelle dans une classe : elle devra alors
obligatoirement être définie dans les classes dérivées. On dit qu'une telle méthode est une
méthode virtuelle pure(ou une méthode abstraite).

2) Le but des classes abstraites

Le but des classes abstraites est de définir un cadre de travail pour les classes dérivées en
proposant un ensemble de méthodes que l'on retrouvera tout au long de l'arborescence. Ce
mécanisme est fondamental pour la mise en place du polymorphisme. En outre, si l'on
considère la classe Véhicule, il est tout à fait naturel qu'elle ne puisse avoir d'instance : un
véhicule ne correspond à aucun objet concret mais plutôt au concept d'un objet capable de
démarrer, ralentir, accélérer ou s'arrêter, que ce soit une voiture, un camion ou un avion.

Prenons l’exemple des formes géométriques. C’est un bon exemple, on peut imaginer un
programme où on veut calculer la somme des surfaces de plusieurs pièces de formes diverses.
Le parcours de cet ensemble peut se faire à l’aide d’une référence sur une classe Forme, à la
condition que toutes les classes décrivant des objets susceptibles d’apparaitre dans la collection
soient dérivées de Forme. Pour que le calcul de surface puisse être fait par l’intermédiaire d’une
référence sur Forme, il faut que cette classe dispose d’une méthode surface(). Toutefois le calcul
de la surface d’une forme n’a pas de sens: On sait calculer par exemple la surface d’un rectangle
ou d’un disque en fonction de leurs dimensions, mais la notion de forme est trop abstraite pour
permettre la définition du corps de la méthode surface. On peut donc définir la classe de base
ainsi :
classe abstraite Forme
DEBUT public
:
fonction abstraite surface() :réel ;{une méthode abstraite}
FIN
Bien que la classe Forme ne comporte qu’une seule méthode abstraite, elle n’est pas inutile
puisqu’elle va permettre de mettre en œuvre le polymorphisme.
On peut avoir des classes filles suivantes :
La classe Cercle,

26
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
classe Cercle hérite de Forme
Debut
protégé :
rayon :reel
public :
Cercle( r :reel)
Fonction surface():réel
Fin
Cercle ::Cercle(r :reel)
Debut
Rayon r
Fin
Fonction Cercle ::surface() :reel
Var surf :reel
Debut
surf 3.14*rayon*rayon
retourner surf
Fin

La classe rectangle
classe Rectangle hérite de Forme
Début
Protégé :
Largeur :reel
Longueur :reel
public:
Rectangle( lg :reel, larg :reel)
Fonction surface():réel
Fin

Rectangle ::Rectangle( lg :reel, larg :reel)

Début
Longueur lg;
Largeur larg;
Fin
Fonction Rectangle :: surface() :reel
Debut
retourner longueur*largeur Fin
Dans un programme principal on pourra manipuler les objets de ces classes :

Programme test
Var tableau F(2) :Forme
C :Cercle
R :Rectangle
Surf :reel
Debut

27
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 C=new Cercle(4.5)
R=new Rectangle(4,5)
Surf 0;
F(0) C
F(1) R
Pour i de 1 à 2 faire Surf surf+F(i).surface() finPour
afficher"la somme des surfaces est ",surf
Fin

Ainsi le rapport entre ces deux classes Rectangle et Cercle est qu’elle dispose chacune de la
méthode surface avec la même signature. Elles sont toutes deux des redéfinitions de la
méthode abstraite déclarée dans la classe Forme dont héritent Cercle et Rectangle. La seule
raison d’être de la classe Forme est de permettre d’établir ce rapport syntaxique qui va par la
suite nous permettre d’appeler ces deux méthodes très différentes comme une seule et unique
méthode.
Le fait que forme est une classe abstraite à deux avantages :
• il résout le problème du corps de la méthode Forme::surface() ,
• et indique clairement que forme n’existe que pour permettre l’utilisation du
polymorphisme.

28
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
 Chapitre 7 : LIEN ET AGREGATION
On regroupe sous cette notion les différents liens pouvant exister entre les objets au cours
d'une application: l'instanciation, l'héritage, la référence et la composition.

1) L'instanciation (Lien : 'instance de')

Dans le monde réel, les objets sont classés en catégories suivant leurs caractéristiques
(propriétés). Par exemple toutes les 'tasses de café' peuvent être caractérisée par une couleur,
une quantité de boisson et une température, de même que toutes les tasses peuvent être
remplies, vidées et lavées.

Ainsi avant de commencer à créer des objets, il est nécessaire de définir d'abord leurs classes
d'appartenances. La définition d'une classe consiste à lui donner un nom unique et à définir les
attributs et méthodes formant ses propriétés.

2) L'héritage (Lien : 'est-un')

Lorsqu'on déclare une nouvelle classe C, on a la possibilité de spécifier que cette nouvelle
classe doit hériter des propriétés d'une ou de plusieurs classes mères. Ainsi les nouvelles
propriétés définies, seront rajoutées à celles héritées pour former un nouveau concept plus
spécifique que ceux déjà définis dans les classes mères. La classe C est alors une
spécialisation de ses classes mères. Ces dernières sont appelées les super-classes de C.

3) Les objets complexes (Lien : 'référence-à' et 'composé-de')

Quand on veut représenter un objet du monde réel, on est souvent confronté au problème de la
complexité du concept réel, car beaucoup d'objets courants, sont inter-dépendants et/ou
composés les uns par rapport aux autres. Par exemple un objet voiture est composé d'un grand
nombre d'objets d'autres types comme un moteur, des roues, une carrosserie, un système de
freinage, une boite à vitesse, etc ... Chacun de ces objets (par exemple le moteur) est lui-même
composé d'une multitude d'autres sous-objets (des pistons, des soupapes, des joints, des
boulons, ...). Ce type d'objet aussi complexe soit-il est manipulé de la même manière qu'un
objet simple (comme un entier ou une chaîne de caractères).Pour pouvoir modéliser des objets
complexes, on a la possibilité, lors de la déclaration d'une classe, de définir des attributs ayant
comme type une classe déjà définie. Cette manière de procéder permet d'établir des
associations (liens de référence ou de composition) entre plusieurs classes.

Un lien de composition peut exister par exemple entre la classe voiture et la classe moteur.
Alors qu'entre cette même classe voiture et la classe personne il y a un lien de référence, pour
indiquer qu'une voiture est conduite par une personne (voir figure IV-3).

29
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Un lien de composition est un lien de référence sémantiquement plus riche. Par exemple si v
est un objet de la classe voiture, composé du moteur m et conduite par la personne p.
L'existence de l'objet m dépend de l'objet v, car c'est un sous-objet ou encore un objet
composant. Par contre l'objet p ne fait pas partie de l'objet v, il ne fait pas partie de ses objets
composants. Donc si on décide de détruire l'objet v (par exemple la voiture en question ne fait
plus partie du parc automobile de l'entreprise) tous ses composants doivent aussi être détruits
(son moteur m) de la base de données, par contre son conducteur p reste non affecté par cette
opération (il conduira un autre véhicule par exemple).

4) Agrégation et composition
Agrégation : A a B quand : A contient un objet de type B en attribut et au moins

un envoi de message.

Agrégation c’est comme une association, au niveau du code. C’est un cas particulier en fait,
ou conceptuellement B est agrégé à A, il y a une relation contenu / contenant, aggrégé /
aggrégeant, une idée de possession. La seule différence entre les deux c'est la sémantique du
lien. Un homme est associé à sa femme (association) et il possède un compte en banque
(aggrégation).

Il y a donc aussi une référence vers l’objet, car c’est une association, et toujours envois de
message.

Exemple : soient les classes Voiture et Roue, une voiture a besoin dans sa définition de
roues, mais ses roues peuvent être changées, et donc les roues ont une existence en dehors de
la voiture. La voiture possède des roues, si la voiture va à la casse on peut en récupérer les
roues pour les mettre sur une autre voiture.

30
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Différence association / aggrégation : Un homme est associé à sa femme (association) et il
possède un compte en banque (aggrégation).

Composition(Agrégation forte)

quand : A contient un objet de type B en attribut et crée éventuellement un emplacement

mémoire pour cet objet (par un new).

Ce qui est important pour la composition ce n’est pas tellement qu’il créé l’objet, mais c’est
surtout que si l’objet de type A disparaît, celui de B disparaît aussi. L’objet B n’a plus
d’existence sans celui de A.

Donc, au niveau du code, il y aura en effet souvent (presque toujours même) A qui créera
l’objet de type B (mais ça peut également arriver pour une aggrégation, il faut bien créer les
objets à un moment ou un autre, par exemple lorsqu’on créé une voiture on va lui créer des
roues, mais c’est une aggrégation faible car on peut les changer par la suite, et les roues
peuvent exister sans la voiture). Ce qui est important donc, c’est que l’objet de type A est le
seul à posséder ce référent vers l’objet de type B, de telle sorte que s’il meurt, l’objet de type
B qui le compose meurt aussi.

Exemple : soient les classes Arbre et Feuille. Quand on créé un arbre, on en créé les feuilles,
l’arbre est composé d’un tronc, de racines,… et de feuilles. Si l’arbre meurt, on ne sait pas en
récupérer les feuilles pour les mettre sur un autre arbre -> elles meurent aussi.

Chapitre 8 : LES TABLEAUX

Un tableau est un objet ayant un nombre d'éléments fixe et pouvant contenir des objets ou des
types primitifs. Dans certains langages comme Java, un tableau est lui-même un objet.

Un tableau peut contenir des primitifs tous du même type : {1,2,3} ou {'a','b','c'}.

31
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Un tableau peut également contenir des objets de mêmes types.

Déclaration simple de tableau d’objet

Dans certains langages orienté objet comme le C++ les tableaux d’objet sont definis comme
les tableaux de types primitifs.

lesPièces[1..100] : tableau de PièceNonAgréée ou

lesPièces[100] : tableau de PièceNonAgréée ou

tableau F[10] :Forme et pour accéder aux

éléments du tableau :

F[1].surface() ;

Tableau comme Objet

Dans certains langages Orienté Objet comme Java le tableau est un objet :

Syntaxe de déclaration
Tableau de 5 entiers primitifs :

entier[] monTableau=new entier[5];

ou entier monTableau[]=new

entier[5];

La première notation est de loin la meilleure car de cette façon, nous visualisons bien que
monTableau est de type tableau d'entiers primitifs. Dans la seconde notation, les crochets sont
mis à la fin de la référence pour assurer une continuité avec les normes du C mais il faut
absolument éviter de l'utiliser.

Un tableau est un objet

Un tableau Java peut contenir des primitifs ( tel un int ) ou des objets ( tel l'objet Voiture ).

Voiture[] mesvoit=new Voiture[10] ; un tableau de 10 voitures

mesvoit[1]=new Voiture() ;//objet voiture appartenant au tableau

Attention! Il faut bien comprendre qu'un tableau en Java est un objet à part entière. Ainsi, un
tableau possède la propriété length: [Link] vaut 5.

Autre conséquence:

32
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE
Object[] monTableau; ne réserve pas d'espace mémoire mais spécifie simplement que la
variable monTableau est un tableau. Faire monTableau[0]=1 entrainera une erreur

On peut accéder à la taille par le champ

Length(longueur)

Les vecteurs(collections)
Lorsque l'on crée un tableau, il faut spécifier sa taille qui est fixe. Certaines langages
fournissent des objets très utilisé comme le vecteur (classe [Link] ) ou collection.
L'utilisation d'un vecteur (collection) plutôt qu'un tableau est souvent avantageux lorsque la
taille finale du tableau n'est pas connue à l'avance. Un vecteur est un tableau dynamique. La
première cellule d'un vecteur est à l'index zéro.

33
PROGRAMMATION ORIENTEE OBJET INSTITUT INTERNATIONAL 2I GENIE INFORMATIQUE