Chapitre 2 Principes de la programmation par objets

Chapitre 2
Principes de la programmation par
objets
2.1 Objectifs
Ce chapitre pr´esente de mani`ere assez concise les grands principes relatifs `a la program-
mation par objets : instanciation, envoi de messages, encapsulation et polymorphisme. Il
met essentiellement l’accent sur les concepts n´ecessaires dans la suite de cet ouvrage. La
pr´esentation se veut dans un premier temps relativement g´en´erale (sections d´efinition) et
dans un second temps pratique en illustrant les concepts avec le langage Python (sections
mise en œuvre). Cependant, ce chapitre n’est pas un cours complet de Python et le lecteur
peut trouver un compl´ement d’information dans l’annexe A (R´ef´erence rapide Python).
2.2 Objets, classes et instances
Les objets informatiques visent `a repr´esenter directement et le plus fid`element possible
les objets (ou entit´es) du monde r´eel. Tout comme les objets du monde r´eel sont en in-
teraction, les objets informatiques interagissent. Un ensemble d’objets interagissant d´efinit
un syst`eme.
2.2.1 D´efinitions
Un objet est une entit´e informatique ´etant capable de recevoir des messages. Un message
est une demande d’ex´ecution de traitement : il contient l’identification du traitement et
les param`etres. Envoyer un message `a un objet est ´equivalent `a poser une question `a une
personne. Un objet est d´efini par une (et une seule) classe. La relation entre un objet et sa
classe est une relation d’instanciation : Un objet est instance d’une classe. Cette relation est
aussi une relation de typage : la classe d´efinit le type de ses instances. La classe Compteur
permet de cr´eer des objets compteurs.
21

22 Principes de la programmation par objets
La classe est une forme de moule pour ses instances. Elle d´efinit la structure de celles-
ci. Cette structure est d´efinie par des donn´ees repr´esentant l’´etat d’un objet particulier,
ainsi que les traitements s’appliquant sur cet ´etat. Ici, et contrairement `a la programmation
proc´edurale, donn´ees et traitements sont fortement li´es. Dans le cadre de la programmation
par objets, une donn´ee associ´ee `a un objet est appel´ee attribut. Un traitement associ´ee `a
un objet est, en g´en´eral, appel´e m´ethode. Les m´ethodes repr´esentent le moyen d’interagir
avec un objet et donc de pouvoir manipuler ses attributs. La classe Compteur poss`ede
un attribut qui repr´esente son ´etat courant, sa valeur, une m´ethode pour incr´ementer le
compteur (agir sur son ´etat) et une m´ethode pour avoir acc`es `a son ´etat.
Une classe d´efinit ainsi le comportement de ses instances qui est d´efini par les messages
(les demandes de traitement) qu’une instance peut recevoir. Toute les instances d’une classe
ont un comportement similaire (mˆeme traitements). Par exemple, tous les compteurs auront
le mˆeme comportement qui est d’incr´ementer leur valeur. Toutefois, les objets, mˆeme issus
d’une mˆeme classe, sont des entit´es individuelles et distingables. Un objet a une identit´e
propre, et son ´etat peut varier ind´ependamment des autres instance de sa classe. Lorsque
l’on utilise deux compteurs, il est possible d’incr´ementer l’un des deux sans modifier l’´etat
de l’autre. Ainsi, les objets sont caract´eris´es par leur ´etat et l’ensemble des m´ethodes
associ´ees.
L’instanciation d’un objet se fait en deux temps. Premi`erement, un espace m´emoire de
la taille requise par la d´efinition de la classe est allou´e afin de mat´erialiser l’objet. Ensuite,
l’´etat de l’objet est initialis´e. Cette initialisation est r´ealis´ee par le constructeur de la classe.
Le constructeur est une sorte de m´ethode particuli`ere qui est appel´ee lors de la cr´eation
d’un objet. Elle r´ealise les traitements n´ecessaires `a l’initialisation de toute instance d’une
classe. Cet appel est r´ealis´e par l’environnement de l’instanciation. Le constructeur ´etant
offert par la classe, il fait de celle-ci une usine `a objets.
Lorsqu’un objet n’est plus utilis´e, il est d´etruit. La destruction d’un objet ne se li-
mite pas `a rendre la m´emoire qu’il utilisait. Un objet peut utiliser un fichier ou bien
une connexion r´eseau. Il faut alors que l’objet ferme proprement cette connexion afin de
ne pas laisser l’application dans un ´etat incoh´erent. Le destructeur d’une classe pr´ecise
comment les objets doivent ˆetre d´etruits. Il peut ˆetre appel´e implicitement par l’environ-
nement (comme en Java ou Python) ou bien explicitement par le d´eveloppeur (comme en
C++ pour les instances cr´e´ees dynamiquement). Un destructeur par d´efaut est en g´en´eral
pr´esent dans toute classe. Ce destructeur ne g`ere que le cas basique o`u aucun attribut ne
repr´esente une ressource syst`eme (fichier, connexion r´eseau ou base de donn´ees, etc) qui
doit ˆetre ferm´ee proprement.
2.2.2 Constructions du langage
La figure 2.1 illustre la d´efinition d’une classe en Python. Le constructeur porte toujours
le nom __init__. Comme la classe Hello ne d´efinit pas d’´etat pour ses instances, le
constructeur ne fait rien1.Le destructeur d’une classe porte toujours le nom __del__ et il
1Le mot cl´e pass du langage Python explicite le fait de ne rien faire.
c
2003-2005, Rapha¨el Marvie

2.2 Objets, classes et instances 23
ne prend pas de param`etre. Dans le cas o`u le constructeur ou le destructeur ne fait rien
il peut ˆetre omis. La classe d´efinit une unique m´ethode afficher2. Cette m´ethode affiche
la chaˆıne hello world sur la sortie standard. Bien que ces trois m´ethodes ne prennent
pas de param`etre, elles sont d´efinies avec un param`etre dont le nom est libre mais en
g´en´eral appel´e self. Ce premier param`etre repr´esente l’instance sur laquelle s’applique les
traitements3. Elle permet par exemple d’acc´eder `a l’´etat de l’objet comme nous le verrons
dans la prochaine section.
class Hello:
def __init__ (self):
pass
def __del__ (self):
pass
def afficher (self):
print ’hello world’
Fig. 2.1 – D´efinition d’une classe en Python
La figure 2.2 illustre l’utilisation d’une classe en Python. La premi`ere ligne repr´esente
l’instanciation, c’est-`a-dire la cr´eation d’un objet de type Hello. Ici, aucun param`etre n’est
fourni `a l’instanciation pour initialiser l’objet (qui n’a pas d’´etat). La seconde ligne pr´esente
l’utilisation de cette instance. L’envoie de message est exprim´e avec la notation point´ee en
Python (comme en Java ou Eiffel). Cette seconde ligne signifie que l’on envoie le message
afficher `a l’instance cr´e´ee par la premi`ere ligne. La m´ethode display est alors invoqu´ee
sur l’instance r´ef´erenc´ee par h. Le traitement associ´e est ex´ecut´e, la chaˆıne hello world est
donc affich´ee.
>> > h = Hello ()
>> > h. afficher ()
hello world
Fig. 2.2 – Utilisation d’une classe en Python
2.2.2.1 Documenter les classes
Il n’est jamais de trop de rappeler que documenter le code est vital pour sa compr´ehension,
son utilisation et sa maintenance. Dans le cadre d’une ´equipe de d´eveloppement, chacun
doit pouvoir rapidement comprendre ce que fait une classe en lisant sa documentation.
2Les m´ethodes repr´esentant des actions, leur donner des noms de verbe est courant.
3La pr´esence de ce premier param`etre peut paraˆıtre surprenante. Toutefois, mˆeme si ce premier pa-
ram`etre est cach´e dans la majorit´e des langages objet, sa d´efinition est implicite et se traduit, par exemple,
par l’utilisation de la variable this en Java et C++.
c
2003-2005, Rapha¨el Marvie

24 Principes de la programmation par objets
Il n’est pas toujours possible ni souhaitable de devoir lire le code d’une classe pour com-
prendre ce qu’elle fait. Nous ne parlons pas ici de «comment»une classe fait les choses,
mais qu’est ce qu’elle fait, le «quoi». Toute classe et toute m´ethode doit ˆetre document´ee,
mˆeme succinctement. Cette documentation doit permettre de savoir comment utiliser la
classe4.
La figure 2.3 pr´esente la gestion de la documentation en python. Un commentaire suit
directement la d´efinition d’une fonction, d’une classe ou d’une m´ethode. Ce commentaire
est d´efinit comme une chaˆıne multi-ligne5, mˆeme si le commentaire ne fait qu’une ligne. Le
respect de cette r`egle permet d’utiliser l’outil pydoc pour g´en´erer la documentation d’un
fichier6.
class Hello:
’’’
La version objet en python du tra d i tionnel hello world
’’’
def afficher (self):
’’’
Affiche ’hello world’ sur la sortie standard
’’’
print ’hello world’
Fig. 2.3 – Documentation d’une classe en Python
A cˆot´e de la documentation, destin´ee principalement aux utilisateurs de la classe, il est
aussi important de commenter le code. Cette fois ci nous ne parlons plus du «quoi»mais du
«comment». Bien que le code doit ˆetre lisible per se de par le choix de nom de m´ethodes,
d’attributs, et de variables et par un style clair, certains algorithmes m´erite d’ˆetre annot´es.
Qui ne s’est jamais demand´e comment marche une fonction qu’il (elle) a ´ecrit plusieurs
mois plus tˆot ? Les commentaires sont donc `a utiliser abondamment avec parcimonie. Non,
cette phrase n’est pas si contradictoire. Il faut commenter, mais il faut commenter judi-
cieusement, sans ˆetre redondant avec le code. La pertinence des commentaires et bien plus
importante que leur quantit´e. Dans le cas de python, les commentaires sont d´efinis avec le
caract`ere #. Le commentaire commence au signe #et se termine avec la fin de la ligne.
4Dans la suite de cet ouvrage les extraits de code pr´esent´es ne seront pas document´es pour des raisons
de place. Le code associ´e `a cet ouvrage et disponible en ligne est par contre document´e.
5Une chaˆıne multi-ligne commence et se termine par trois guillemets (simples ou doubles).
6Cette technique a ´et´e reprise et ´etendue par le langage Java avec l’outil javadoc.
c
2003-2005, Rapha¨el Marvie

2.3 Principes de base 25
2.3 Principes de base
2.3.1 Encapsulation
2.3.1.1 D´efinition
Un premier principe (en plus de l’instanciation et de l’envoi de messages) de la pro-
grammation par objets est l’encapsulation. L’objectif de ce principe est de masquer la
structuration d’un objet et de ne pr´esenter que les m´ethodes de celui-ci. De cette mani`ere,
les modifications apport´ees `a l’´etat d’un objet sont contrˆol´ees par les m´ethodes. Un attri-
but ne doit pas ˆetre manipul´e directement, ce qui r´eduit le risque de mauvaise utilisation
`a une mauvaise mise en œuvre des m´ethodes.
Le principe d’encapsulation peut ˆetre mis en œuvre de plusieurs mani`eres. La ques-
tion principale est «fait on confiance ou non `a l’utilisateur de la classe». La majorit´e des
langages (comme C++, Eiffel, Java) ne font pas confiance `a l’usager. Les attributs et les
m´ethodes sont donc d´efinis avec une certaine visibilit´e. Les attributs sont d´eclar´es priv´es et
les m´ethodes d’acc`es (lecture et ou ´ecriture) publiques. Ainsi, `a l’utilisation d’une classe,
le compilateur v´erifie que les attributs ne sont pas acc´ed´es directement (et il refuse pure-
ment et simplement d’y donner acc`es). Il est aussi possible de d´efinir des m´ethodes priv´ees
pour un usage interne `a la classe, ou prot´eg´ees pour un usage interne `a la classe et `a ses
sous-classes. Pour ce qui est des attributs publiques7:vade retro.
2.3.1.2 Mise en œuvre
Dans le cas de python, la notion de priv´e / publique repose sur l’utilisation de deux ’_’
devant les attributs ou m´ethodes que l’on ne souhaite pas rendre visible `a l’ext´erieur de
la classe (ce qui correspond `a la notion de priv´e). Toutefois, une simple r`egle de nommage
peut suffire (il faut alors faire confiance aux usagers). Dans la suite de cet ouvrage, les
noms des attributs «priv´ees»et des m´ethodes `a usage interne `a une classe commencent
par un ’_’8. A chaque attribut (que les utilisateurs peuvent lire) est associ´e un accesseur
(m´ethode d’acc`es) en lecture portant le nom de l’attribut pr´efix´e de get_. Dans le cas d’un
attribut modifiable (avec contrˆole) un second accesseur sera d´efini avec le nom de l’attribut
pr´efix´e de set_ et prenant un param`etre. Dans le cas d’attributs accessibles en lecture et
´ecriture sans n´ecessit´e de contrˆole (simple affectation), l’attribut est d´efinit directement
sans pr´efixe ’_’ et consid´er´e comme public.
La figure 2.4 d´efinit un porte monnaie. Il a un ´etat (la valeur courante), un accesseur
pour lire sa valeur (reflet de son contenu) et deux m´ethodes pour ajouter et retirer de l’ar-
gent. Le constructeur de la classe d´efinit et intialise l’attribut repr´esentant l’´etat du porte
monnaie. Le param`etre val est affect´e d’une valeur par d´efaut. Le langage Python permet
de d´efinir un seul constructeur, mais avec des valeurs par d´efaut pour permettre plusieurs
utilisation (voir le paragraphe suivant). La m´ethode get_valeur repr´esente l’accesseur en
7A quelques exceptions pr`es
8Voir le PEP-008 pour les r`egles de nommage en Python, http ://www.python.org/peps/pep-0008.html
c
2003-2005, Rapha¨el Marvie