Notes de cours INFO803, M1-IDESSE et M1-MATH-IM

Notes de cours INFO803, M1-IDESSE et
M1-MATH-IM
Conception et Programmation orient´ee objet en
Python
Jacques-Olivier Lachaud
LAMA, Universit´e de Savoie
version du 9 f´evrier 2010
Table des mati`eres
1 Introduction `a l’approche objet 1
1.1 Vision fonctionnelle et vision objet . . . . . . . . . . . . . . . . . 1
1.2 La pertinence de l’approche objet pour l’abstraction . . . . . . . 2
1.3 De l’analyse `a l’int´egration . . . . . . . . . . . . . . . . . . . . . 5
1.4 Langage adapt´ee `a l’analyse/conception : UML . . . . . . . . . . 6
1.5 Langage de programmation objet : Python . . . . . . . . . . . . 6
2 G´en´eralit´es sur le paradigme objet 7
2.1 Objets................................. 7
2.2 Vues : conceptuelle, sp´ecification, impl´ementation . . . . . . . . . 8
2.3 Messages ............................... 8
2.4 Classes ; instance . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Attributs d’une classe . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6 M´ethodes ; Op´erations . . . . . . . . . . . . . . . . . . . . . . . . 9
2.7 Relations entre objets et entre classes . . . . . . . . . . . . . . . 10
2.8 Liens entre objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.9 Associations entre classes . . . . . . . . . . . . . . . . . . . . . . 11
2.10 Multiplicit´es d’une association . . . . . . . . . . . . . . . . . . . . 12
2.11 G´en´eralisation, polymorphisme . . . . . . . . . . . . . . . . . . . 13
1

3 Concepts avanc´es sur les associations 17
3.1 Agr´egation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Association qualifi´ee . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4 Classe association . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.5 Contraintes sur les associations . . . . . . . . . . . . . . . . . . . 21
4 Introduction au langage Python 22
4.1 Collections en Python . . . . . . . . . . . . . . . . . . . . . . . . 22
4.2 TODO................................. 29
5 Introduction au langage JAVA 29
5.1 Compilation et ex´ecution d’un programme JAVA . . . . . . . . . 30
5.2 D´ecoupage d’un programme JAVA . . . . . . . . . . . . . . . . . 30
5.3 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.4 Autres types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.5 Tableau d’´el´ements du mˆeme type primitif . . . . . . . . . . . . . 32
5.6 Regroupements `a l’aide d’une Classe . . . . . . . . . . . . . . . . 32
5.7 Objets et variables objet . . . . . . . . . . . . . . . . . . . . . . . 34
5.8 Constructeurs d’une classe . . . . . . . . . . . . . . . . . . . . . . 35
5.9 Associations en JAVA . . . . . . . . . . . . . . . . . . . . . . . . 35
5.10 Interfaces, classes abstraites . . . . . . . . . . . . . . . . . . . . . 37
5.11 G´en´eralisation, sp´ecialisation, h´eritage . . . . . . . . . . . . . . . 38
5.12 Polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
6 Aper¸cu de la biblioth`eque JAVA 38
2

Introduction
Ce document trace les grandes lignes d’un cours de niveau interm´ediaire por-
tant sur la conception par objets et la programmation orient´ee objet. Le langage
objet choisi est le Python. Le langage de mod´elisation objet est UML. Ce cours
s’adresse `a des ´etudiants ayant des comp´etences en programmation imp´erative,
mais d´ebutant en programmation objet. L’objectif est de connaˆıtre les principes
g´en´eraux de l’approche objet (classes, h´eritage, associations, polymorphisme) et
de savoir les mettre en œuvre.
Pour la notation UML, on se r´ef´erera au site uml.free.fr. Il existe un
nombre impressionnant de livres sur la programmation objet en Python. On
pourra ainsi regarder le site de (www.python.org) qui contient des tutoriels
Python int´eressants.
La lecture de ce document n’est pas forc´ement lin´eaire. Notamment, il peut
ˆetre utile de lire en parall`ele l’introduction au langage Python.
1 Introduction `a l’approche objet
1.1 Vision fonctionnelle et vision objet
Dans la vision fonctionnelle, on s´epare les donn´ees des op´erations que l’on
effectue dessus. Le processus de conception naturel est donc d’identifier les
donn´ees manipul´ees, pr´evoir des structures de donn´ees adapt´ees, puis ´ecrire
des fonctions qui vont prendre une partie de ces donn´ees en entr´ees et fabriquer
des nouvelles donn´ees en sortie. On parle d’approche syst´emique. Cette vision
est bien adapt´ee `a certaines situations. Les bases de donn´ees classiques et la
m´ethode MERISE fonctionnent ainsi sur ce principe. Cela peut ˆetre aussi adapt´e
`a certains probl`emes de calcul scientifiques, o`u les donn´ees en entr´ee et en sortie
sont clairement identifi´es. En revanche, cette approche devient d´elicate lorsqu’il
s’agit de mod´eliser et/ou de simuler des processus plus complexes, avec des
donn´ees d’origine vari´ee, qui ne se pr´esentent pas toujours sous la forme. L’ap-
proche syst´emique est alors handicap´ee, car elle cherche `a anticiper pr´ecis´ement
les donn´ees qu’elle manipule. On voit aussi que cette vision implique souvent
une analyse ascendante de la probl´ematique, o`u le concepteur/programmmeur
se pose d’abord la question de comment il va stocker ses donn´ees.
Dans la vision objet, on regroupe les donn´ees et les op´erations qui sont
propres `a ces donn´ees. Pour r´esoudre un probl`eme donn´e, on fait collaborer entre
eux des objets qui vont communiquer entre eux pour r´esoudre le probl`eme. On
parle de message passing. De fait, on s’int´eresse plus aux services/messages que
rendent/comprennent chaque objet qu’`a comment les donn´ees sont repr´esent´ees
au sein de l’objet. On dispose de plus de moyens pour regrouper des objets entre
eux, de fa¸con durable ou non.
Normalement chaque objet est responsable de ses donn´ees, et un objet ex-
1

terne n’a pas `a les toucher directement. On parle d’encapsulation. Cela fournit
une s´ecurit´e suppl´ementaire et permet de d´ecomposer un probl`eme complexe
en sous-probl`emes ind´ependants. Une fois qu’un objet est bien valid´e, son fonc-
tionnement est donc garanti dans l’ensemble du syst`eme, aucun autre endroit
du programme ne pouvant modifier son comportement.
L’approche objet a ´et´e propos´ee pour pouvoir d´evelopper des programmes `a
plus grandes ´echelles, programmes que l’on pouvait ensuite d´ecomposer plus faci-
lement en sous-probl`emes. L’approche objet, qui ne consid`ere que les op´erations
que peut faire un objet, permet aussi de voir de la mˆeme mani`ere des objets
avec des sp´ecificit´es distinctes, mais quelques services communs. Une autre ca-
ract´eristique de l’approche objet est de pouvoir d´efinir et manipuler des abs-
tractions, ce qui facilite notamment la conception des programmes. Le poly-
morphisme permet ensuite d’utiliser des r´ealisations concr`etes et sp´ecifiques des
abstractions.
En informatique, le polymorphisme est l’id´ee d’autoriser le mˆeme code `a ˆetre
utilis´e avec diff´erents types, ce qui permet des impl´ementations plus abstraites
et g´en´erales.
Exemples : L’approche objet est particuli`erement efficace pour faire des IHM. On
voit bien qu’une IHM doit faire coexister des composants bien diff´erents (fenˆetres,
dessins, boutons, champs de texte ou de saisie, zones de dessins, tableaux) tout
en assurant une mise en page coh´erente. Mieux, les derni`eres IHM permettent
d’int´egrer `a la vol´ee des composants nouveaux (a priori inconnus) mais qui savent
r´epondre `a quelques messages. Par exemple, Acrobat Reader peut s’ouvrir dans
une fenˆetre firefox.
Les sc`enes 3D sont des arbres d’objets.
On peut mod´eliser une fonction `a l’aide d’un objet. On peut par exemple mod´eliser
un polynˆome sur n’importe quel corps tr`es facilement en programmation objet.
1.2 La pertinence de l’approche objet pour l’abstraction
Quelques exemples pour montrer le processus de r´esolution d’un probl`eme
dans une approche objet par rapport `a une approche imp´erative.
2

Quelques questions :
1. Comment mod´eliser une forme dans une approche imp´erative ?
La question est difficile, car trop floue. On ne voit pas quelle structure de
donn´ees va convenir `a toutes les formes possibles.
2. Comment mod´eliser une forme dans une approche objet ?
C’est plus facile, car on se pose simplement la question : que sait faire
une forme ? quelles demandes on va lui faire ? En d’autres termes, `a quels
messages l’objet sait-il r´epondre ?
Par exemple, une forme doit pouvoir donner son aire, son p´erim`etre, son
centre de gravit´e, ses moments, est-ce qu’un point est `a l’int´erieur de la
forme ou sur le bord ou `a l’ext´erieur, etc.
3. Dans l’approche objet, ce n’est qu’apr`es qu’on se pose la question de com-
ment ´ecrire ces fonctionnalit´es. D’ailleurs, l’approche objet permet de fa-
cilement d´ecouper le travail en sp´ecialisant les formes.
On aura donc un type Forme, et plein de sous-types qui r´ealisent des formes
particuli`eres : le carr´e, le disque, le rectangle, l’ellipse, le polygone, la courbe
radiale, etc.
4. On aura donc des types abstraits (e.g. Forme) et des types concrets (e.g.
Carre), et des relations de sous-typage. Tout type Python indique les mes-
sages auxquels il sait r´epondre : ce sont les fonctions ou m´ethodes associ´ees
au type.
5. On peut se poser la mˆeme question pour mod´eliser un animal, une fonction
math´ematique, une mol´ecule chimique, une variable statistique, etc.
3