Professional Documents
Culture Documents
avec
UML
Pierre-Alain Muller
Prface
UML est le rsultat dun long processus initialis depuis maintenant deux ans par
trois des mthodologistes les plus rputs : Grady Booch, Ivar Jacobson et Jim
Rumbaugh. Conscients que leurs travaux respectifs ne reprsentaient que les
diverses facettes dun mme problme, ils ont eu lintelligence de joindre leurs
efforts plutt que de se lancer dans dinutiles querelles de chapelles. Deux ans de
travail au sein de Rational Software Corporation, soutenus dans leurs efforts par
de nombreux autres spcialistes du domaine, leur ont permis de dfinir cette
nouvelle approche de la modlisation des logiciels base dobjets. UML est la
fois la synthse et le successeur naturel de leurs diffrents travaux. De par sa
standardisation par lOMG, qui devrait aboutir dans le courant de lanne 1997, et
de par son adoption par les plus grands acteurs du monde de linformatique :
IBM, Microsoft, Oracle, Hewlett Packard, pour ne citer que les plus grands, UML
est appel devenir trs court terme le standard pour la modlisation des
applications informatiques de demain.
Pierre Alain Muller, pour avoir pass cinq ans Rational Software en contact
direct avec les gourous du domaine, tait la personne la plus mme de rdiger ce
premier ouvrage en franais sur UML. Ses comptences indiscutables dans le
domaine, allies son sens profond de la pdagogie, font de cet ouvrage un
guide indispensable tous ceux qui veulent comprendre et appliquer les principes
dUML dans le dveloppement de leurs applications.
Etienne Morel
Directeur Gnral
Rational Software Europe
Redde Caesari
quae sunt Caesaris
Les principaux auteurs de la notation UML sont Grady Booch, Ivar Jacobson et
Jim Rumbaugh. Cet ouvrage fait constamment rfrence leurs travaux et je leur
rends bien volontiers ce qui leur appartient.
Au-del de la notation UML, cet ouvrage dcrit un processus de pilotage des
projets objet qui est largement inspir du processus de dveloppement mis au
point par les consultants de Rational Software Corporation. Quils soient ici tous
remercis, en particulier Philippe Kruchten.
Je remercie galement les personnes qui ont accept de relire le manuscrit et qui
mont apport leurs prcieux commentaires ; je pense surtout Jean-Luc Adda,
Jean Bzivin, Jrme Desquilbet, Nathalie Gaertner, Yves Holvot, Nasser Kettani,
Mireille Muller, Philippe Perrin, Michel Reyrolle, Marie-Christine Roch et Philippe
Studer.
Je noublie pas toutes les personnes qui ont influenc la rdaction de cet
ouvrage, tout particulirement Etienne Morel et Bernard Thirion, mais aussi JeanJacques Bockstaller, Tom Joad, Philippe Laroque, Grard Metzger, Bernard
Monnoye et les quelques centaines de personnes qui ont assist mes
formations sur lobjet. Je ne remercie pas Dominique Griesinger.
Enfin, je remercie Anne, Jonathan, Roxane et Lara pour leur patience et je leur
ddie cet ouvrage.
LA GENSE DUML
15
La dmarche d'abstraction...................................................................................... 36
Reprsentation graphique des classes.................................................................. 37
Description des classes ............................................................................................ 40
Les relations entre les classes .................................................................................... 44
Lassociation.............................................................................................................. 44
Lagrgation .............................................................................................................. 46
Correspondances entre diagrammes de classes et diagrammes dobjets ....... 48
Les hirarchies de classes ........................................................................................... 49
Gnralisation et spcialisation ............................................................................ 50
Des ensembles aux classes....................................................................................... 53
De la difficult de classer......................................................................................... 59
Lhritage ................................................................................................................... 64
Le polymorphisme ..................................................................................................... 70
LA NOTATION UML
83
199
Caractrisation du logiciel.........................................................................................200
La crise du logiciel .................................................................................................200
Les catgories de logiciels ....................................................................................200
La complexit des logiciels ...................................................................................201
La porte de lapproche objet...............................................................................204
289
Le processus .................................................................................................................289
Analyse des besoins .....................................................................................................290
Description des cas dutilisation...............................................................................292
Dtermination des cas dutilisation ....................................................................292
Configuration ..........................................................................................................294
Surveillance .............................................................................................................304
Contrle daccs .....................................................................................................309
Tableau rcapitulatif des cas dutilisation et des scnarios principaux .....310
Contrles de cohrence .........................................................................................311
Description des collaborations ..................................................................................312
Configuration ..........................................................................................................313
Surveillance .............................................................................................................333
Contrle daccs .....................................................................................................340
Analyse...........................................................................................................................342
Analyse du domaine................................................................................................342
Analyse de lexistant...............................................................................................343
Architecture..................................................................................................................354
Architecture logicielle ...........................................................................................354
Architecture matrielle ..........................................................................................356
Ralisation ...............................................................................................................357
ANNEXES
359
361
Strotypes prdfinis.................................................................................................361
Etiquettes prdfinies ..................................................................................................363
367
381
Classe.............................................................................................................................381
Classe vide................................................................................................................381
Classe avec attributs et oprations .....................................................................382
Classe paramtrable...............................................................................................383
Classe utilitaire .......................................................................................................383
Association....................................................................................................................384
Association 1 vers 1 ................................................................................................384
Association N vers 1 ...............................................................................................384
Association N vers 1 avec une contrainte ..........................................................385
Classe-association..................................................................................................387
Classe-association N vers N..................................................................................388
Agrgation.....................................................................................................................388
Agrgation 1 vers 1.................................................................................................388
Agrgation navigabilit restreinte...................................................................389
Agrgation par valeur............................................................................................389
Agrgation par valeur 1 vers N ............................................................................389
Hritage .........................................................................................................................390
Hritage simple........................................................................................................390
Hritage multiple ....................................................................................................390
GNRATION DE CODE JAVA
391
Classe.............................................................................................................................391
Classe vide................................................................................................................391
Classe avec attributs et oprations .....................................................................392
Classe abstraite.......................................................................................................392
Interface ....................................................................................................................392
Association....................................................................................................................392
Association 1 vers 1 ................................................................................................392
Association N vers 1 ...............................................................................................393
Agrgation.....................................................................................................................393
Agrgation 1 vers 1.................................................................................................393
Agrgation navigabilit restreinte...................................................................394
Hritage .........................................................................................................................394
Hritage simple........................................................................................................394
Hritage entre interfaces .......................................................................................394
Ralisation dune interface par une classe abstraite.......................................395
Ralisation dune interface par une classe........................................................395
Ralisation de plusieurs interfaces par une classe...........................................395
GNRATION DE CODE IDL
397
Classe.............................................................................................................................397
Classe vide................................................................................................................397
Classe avec attributs et oprations .....................................................................397
Association....................................................................................................................398
Association 1 vers 1 ................................................................................................398
Association N vers 1 ...............................................................................................398
Association 5 vers 1 ................................................................................................398
Agrgation.....................................................................................................................398
Agrgation 1 vers 1.................................................................................................398
Agrgation navigabilit restreinte...................................................................399
Hritage .........................................................................................................................399
Hritage simple........................................................................................................399
Hritage multiple ....................................................................................................399
GNRATION DE CODE VISUAL BASIC
401
Classe.............................................................................................................................401
Classe vide................................................................................................................401
Classe avec attributs et oprations .....................................................................402
Classe utilitaire .......................................................................................................402
Association....................................................................................................................403
Association 1 vers 1 ................................................................................................403
Association N vers 1 ...............................................................................................403
Hritage .........................................................................................................................404
Hritage simple........................................................................................................404
GNRATION DE CODE SQL
405
Classe.............................................................................................................................405
Classe vide................................................................................................................405
Classe avec attributs et oprations .....................................................................406
Association....................................................................................................................406
Association 1 vers 1 ................................................................................................406
Association N vers 1 ...............................................................................................406
Classe-association N vers N..................................................................................407
Hritage .........................................................................................................................407
Hritage simple........................................................................................................408
Hritage multiple ....................................................................................................408
GLOSSAIRE
409
BIBLIOGRAPHIE
419
423
CONTENU DU CD-ROM
435
Le livre se termine par des annexes sur la transition vers UML et sur des rgles de
mise en uvre, organises de la manire suivante :
Le lecteur novice est invit lire l'ensemble du livre, en suivant l'ordre des
chapitres. Ce conseil s'applique galement aux programmeurs qui ont acquis
une connaissance d'un langage de programmation objet comme C++, sans
avoir suivi de formation spcifique lanalyse et la conception objet.
1
La gense dUML
Linformatique sest glisse imperceptiblement dans notre vie quotidienne. Des
machines laver aux lecteurs de disques compacts, en passant par les
distributeurs de billets et les tlphones, quasiment toutes nos activits
quotidiennes utilisent du logiciel et, plus le temps passe, plus ce logiciel devient
complexe et coteux.
La demande de logiciels sophistiqus alourdit considrablement les contraintes
imposes aux quipes de dveloppement. Le futur des informaticiens sannonce
comme un monde de complexit croissante, la fois du fait de la nature des
applications, des environnements distribus et htrognes, de la taille des
logiciels, de la composition des quipes de dveloppement, et des attentes
ergonomiques des utilisateurs.
Pour surmonter ces difficults, les informaticiens vont devoir apprendre faire,
expliquer, et comprendre. Cest pour ces raisons quils ont et auront toujours
plus besoin de mthodes. Le temps de linformatique intuitive et des programmes
qui tombent en marche sachve. Place au doux rve de linformatique adulte,
raisonne, efficace !
recettes de cuisine, les pilotes droulent des check-lists avant le dcollage, les
architectes dessinent des plans et les musiciens suivent des rgles de
composition.
De mme, une mthode dlaboration de logiciels dcrit comment modliser et
construire des systmes logiciels de manire fiable et reproductible.
De manire gnrale, les mthodes permettent de construire des modles partir
dlments de modlisation qui constituent des concepts fondamentaux pour la
reprsentation de systmes ou de phnomnes. Les notes reportes sur les
partitions sont des lments de modlisation pour la musique. Lapproche objet
propose lquivalent des notes ce sont les objets pour la reprsentation des
logiciels.
Les mthodes dfinissent galement une reprsentation souvent graphique
qui permet dune part de manipuler aisment les modles, et dautre part de
communiquer et dchanger linformation entre les diffrents intervenants. Une
bonne reprsentation recherche lquilibre entre la densit dinformation et la
lisibilit.
En plus des lments de modlisation et de leurs reprsentations graphiques, une
mthode dfinit des rgles de mise en uvre qui dcrivent larticulation des
diffrents points de vue, lenchanement des actions, lordonnancement des
tches et la rpartition des responsabilits. Ces rgles dfinissent un processus
qui assure lharmonie au sein dun ensemble dlments coopratifs et qui
explique comment il convient de se servir de la mthode.
Avec le temps, les utilisateurs dune mthode dveloppent un savoir-faire li sa
mise en uvre. Ce savoir-faire, galement appel exprience, nest pas toujours
formul clairement, ni aisment transmissible.
1 La gense dUML 7
Plus rcemment, vers le dbut des annes 80, les mthodes objet ont commenc
merger. LHistoire avec un grand H est un ternel recommencement. La petite
histoire des mthodes se rpte elle aussi. Le cheminement des mthodes
fonctionnelles et des mthodes objet est similaire. Au dbut existait la
programmation, avec dans un cas le sous-programme et dans lautre, lobjet
comme lment structurant de base. Quelques annes plus tard, les informaticiens
poussent le concept structurant vers la conception et inventent la conception
structure dans un cas et la conception objet dans lautre. Plus tard encore, la
progression vers lanalyse est opre, toujours en exploitant le mme paradigme,
soit fonctionnel, soit objet. Chaque approche peut donc proposer une dmarche
complte, sur lensemble du cycle de vie du logiciel.
Figure 1 : Lvolution des mthodes, objet ou non, sest toujours faite de la programmation
vers lanalyse.
Dans les faits, la situation est lgrement plus complexe. En effet, souvent les
mthodes ne couvrent pas lensemble du cycle de vie. Cela se traduit alors par la
juxtaposition de mthodes : une mthode A pour lanalyse, suivie dune mthode
C pour la conception. Cette approche parcellaire, tant quelle est confine dans un
des paradigmes lapproche fonctionnelle ou lapproche objet reste
raisonnable. En revanche, le mlange de paradigmes est nettement moins
raisonnable, bien que comprhensible. Vers le milieu des annes 80, les bienfaits
de la programmation objet commencent tre largement reconnus, et la
conception objet semble une approche raisonnable pour qui veut mettre en uvre
un langage de programmation objet comme Smalltalk. Du ct de l'analyse par
contre, la notion danalyse objet nest que vapeur et supputation. Les entreprises
ont dvelopp cette poque une solide connaissance des mthodes danalyse
fonctionnelle et de modlisation smantique des donnes ; les informaticiens
semploient donc tout naturellement juxtaposer une phase de conception objet
une phase danalyse fonctionnelle. Cette manire de procder prsente de
nombreux inconvnients lis au changement de paradigme. Le passage de
lanalyse fonctionnelle la conception objet ncessite une traduction des
lments de modlisation fonctionnelle vers les lments de modlisation objet,
ce qui est loin dtre commode et naturel. En effet, il ny a pas de bijection entre
les deux ensembles, de sorte quil faut casser les lments de modlisation dune
des approches pour construire des fragment dlments de modlisation de
lautre approche. Le rsultat net de ce changement dtat desprit en cours de
dveloppement est de limiter considrablement la navigation entre lnonc des
besoins en amont de lanalyse et la satisfaction de ces besoins en aval de la
conception. Dautre part, une conception objet obtenue aprs traduction manque
trs souvent dabstraction et se limite lencapsulation des objets de bas
niveaux, disponibles dans les environnements de ralisation et dexcution. Tout
ceci implique beaucoup defforts pour des rsultats somme toute bien peu
satisfaisants.
1 La gense dUML 9
mise en uvre des diffrentes mthodes et ont marqu leffort dunification des
mthodes de Booch et OMT.
Origine
Elment
Booch
Catgories et sous-systmes
Embley
Fusion
Gamma et al.
Harel
Automates (Statecharts)
Jacobson
Meyer
Pr- et post-conditions
Odell
OMT
Associations
Shlaer-Mellor
Wirfs-Brock
Responsabilits (CRC)
Figure 3 : Principaux lments emprunts par Booch93 et OMT-2 aux diffrentes mthodes
objet.
reprsenter des systmes entiers (au-del du seul logiciel) par des concepts
objets,
1 La gense dUML 11
Les crateurs dUML insistent tout particulirement sur le fait que la notation
UML est un langage de modlisation objet et non pas une mthode objet. Les
commentaires recueillis en rponse la publication de la version 0.8 ont
clairement montr que les utilisateurs attendaient une formalisation des artefacts
du dveloppement, plutt que du processus dlaboration de ces artefacts. En
consquence, la notation UML a t conue pour servir de langage de
modlisation objet, indpendamment de la mthode mise en uvre. La notation
UML peut ainsi se substituer sans perte dinformation aux notations des
mthodes de Booch, OMT ou encore OOSE (Object Oriented Software
Engineering galement appele Objectory).
UML nest pas une notation propritaire : elle est accessible tous et les
fabricants doutils ainsi que les entreprises de formation peuvent librement en
faire usage. La volont douverture, la richesse de la notation et la dfinition
smantique prcise des lments de modlisation font dUML une notation
gnrale et simple, sans tre simpliste.
En franais, UML pourrait se traduire par langage unifi pour la modlisation
objet, mais il est plus que probable quUML se traduise plutt par notation
unifie, voire notation UML, sur le mme schma que mthode OMT.
Modle et mtamodle
Leffort initial porte sur lidentification et la dfinition de la smantique des
concepts fondamentaux qui forment les briques de base de la modlisation objet.
Ces concepts constituent les artefacts du dveloppement et ils doivent pouvoir
1 La gense dUML 13
tre changs entre les diffrents intervenants des projets. Pour raliser ces
changes, il faut dabord saccorder sur limportance relative de chaque concept,
tudier les consquences de ces choix et choisir une reprsentation graphique
dont la syntaxe soit la fois simple, intuitive et expressive.
Pour faciliter ce travail de dfinition et pour formaliser UML, tous les diffrents
concepts ont t eux-mmes modliss avec UML. Cette dfinition rcursive,
appele mtamodlisation, prsente le double avantage de permettre de classer
les concepts par niveau dabstraction, de complexit et de domaine dapplication,
et aussi de faire la preuve de la puissance dexpression de la notation, capable
entre autres de se reprsenter elle-mme.
Un mtamodle dcrit de manire formelle les lments de modlisation et la
syntaxe et la smantique de la notation qui permet de les manipuler. Le gain
dabstraction induit par la construction dun mtamodle facilite lidentification
dventuelles incohrences et encourage la gnricit. Le mtamodle dUML sert
de description de rfrence pour la construction doutils et pour le partage de
modles entre outils diffrents.
Un modle est une description abstraite dun systme ou dun processus, une
reprsentation simplifie qui permet de comprendre et de simuler. Le terme
modlisation est souvent employ comme synonyme danalyse, cest--dire de
dcomposition en lments simples, plus faciles comprendre. En informatique, la
modlisation consiste tout dabord dcrire un problme, puis dcrire la
solution de ce problme ; ces activits sappellent respectivement lanalyse et la
conception.
La forme du modle dpend du mtamodle. La modlisation fonctionnelle
dcompose les tches en fonctions plus simples raliser. La modlisation objet
dcompose les systmes en objets collaborants. Chaque mtamodle dfinit des
lments de modlisation et des rgles pour la composition de ces lments de
modlisation.
Le contenu du modle dpend du problme. Un langage de modlisation comme
UML est suffisamment gnral pour tre employ dans tous les domaines
informatiques et mme au-del, par exemple pour lingnierie des affaires.
Un modle est lunit de base du dveloppement ; il est fortement cohrent avec
lui-mme et faiblement coupl avec les autres modles par des liens de navigation.
En rgle gnrale, un modle est reli une phase prcise du dveloppement et
est construit partir dlments de modlisation avec leurs diffrentes vues
associes.
Un modle nest pas directement visible par les utilisateurs. Il capture la
smantique sous-jacente dun problme et contient des donnes exploites par
les outils pour lchange dinformation, la gnration de code, la navigation, etc.
UML dfinit plusieurs modles pour la reprsentation des systmes :
Les modles sont regards et manipuls par les utilisateurs au moyen de vues
graphiques, vritables projections au travers des lments de modlisation
contenus par un ou plusieurs modles. De nombreuses vues peuvent tre
construites partir des modles de base ; elles peuvent montrer tout ou partie des
modles. A chaque vue correspondent un ou plusieurs diagrammes. UML dfinit
neuf types de diagrammes diffrents :
Des notations diffrentes peuvent tre des vues du mme modle. Les notations
de Booch, OMT et OOSE utilisent des syntaxes graphiques diffrentes, mais
reprsentent les mmes concepts objet. Ces notations graphiques diffrentes ne
sont en fait que des vues diffrentes des mmes lments de modlisation, de
sorte quil est tout fait possible dutiliser diffrentes notations sans perdre le
contenu smantique. UML nest quune autre reprsentation graphique dun
modle smantique commun.
2
Lapproche objet
Ce chapitre prsente les concepts de base de lapproche objet. Il sadresse tout
particulirement aux informaticiens qui sorientent vers lobjet. La matrise des
notions prsentes dans ce chapitre est essentielle pour une bonne lecture de la
suite de louvrage. Les exemples prsents introduisent graduellement quelques
bases de la notation UML.
et, par effet de zoom, s'intresser aussi bien aux dtails qu' l'ordonnancement de
l'ensemble.
La construction dun logiciel est par consquent une suite ditrations du genre
division-runion ; il faut dcomposer diviser pour comprendre et il faut
composer runir pour construire. Ceci conduit une situation paradoxale : il
faut diviser pour runir !
Face ce paradoxe, le processus de dcomposition a t dirig traditionnellement
par un critre fonctionnel. Les fonctions du systme sont identifies, puis
dcomposes en sous-fonctions, et cela rcursivement jusqu lobtention
dlments simples, directement reprsentables dans les langages de
programmation (par les fonctions et les procdures).
Larchitecture du logiciel ainsi ralis est le reflet des fonctions du systme. Cette
dmarche, dont les mcanismes intgrateurs sont la fonction et la hirarchie,
apporte des rsultats satisfaisants lorsque les fonctions sont bien identifies et
lorsquelles sont stables dans le temps. Toutefois, tant donn que la fonction
induit la structure, les volutions fonctionnelles peuvent impliquer des
modifications structurelles lourdes, du fait du couplage statique entre architecture
et fonctions.
L'approche objet repose la fois sur le rationalisme d'une dmarche cartsienne et
sur une dmarche systmique qui considre un systme comme une totalit
organise, dont les lments solidaires ne peuvent tre dfinis que les uns par
rapport aux autres. Elle propose une mthode de dcomposition, non pas base
uniquement sur ce que le systme fait, mais plutt sur l'intgration de ce que le
systme est et fait.
2 Lapproche objet 17
Porte
Cabine
Ouvrir
Aller au RDC
Lumire
Bouton
Faire clignoter
Les objets
Lobjet est une unit atomique forme de l'union d'un tat et d'un comportement.
Il fournit une relation d'encapsulation qui assure la fois une cohsion interne
trs forte et un faible couplage avec l'extrieur. Lobjet rvle son vrai rle et sa
vraie responsabilit lorsque, par l'intermdiaire de l'envoi de messages, il s'insre
dans un scnario de communication.
Comportement visible
Un objet
Etat interne cach
Figure 7 : Chaque objet contient un tat interne qui lui est propre et un comportement
accessible aux autres objets.
Le monde dans lequel nous vivons est constitu d'objets matriels de toutes
sortes. La taille de ces objets est trs variable : certains sont petits, comme les
grains de sable, et dautres trs gros, comme les toiles. Notre perception intuitive
de ce qui constitue un objet est fonde sur le concept de masse, c'est--dire sur
une grandeur qui caractrise la quantit de matire d'un corps.
Par extension, il est tout fait possible de dfinir d'autres objets, sans masse,
comme les comptes en banques, les polices d'assurance ou encore les quations
mathmatiques. Ces objets correspondent alors des concepts plutt qu' des
entits physiques.
Toujours par extension, les objets peuvent galement appartenir des mondes
virtuels, par exemple, en association avec Internet, pour crer des communauts
de personnes qui ne sont pas situes au mme point gographique.
Les objets informatiques dfinissent une reprsentation abstraite des entits dun
monde rel ou virtuel, dans le but de les piloter ou de les simuler. Cette
reprsentation abstraite peut tre vue comme une sorte de miroir informatique, qui
renvoie une image simplifie d'un objet qui existe dans le monde peru par
l'utilisateur. Les objets informatiques, que nous appellerons dsormais objets,
encapsulent une partie de la connaissance du monde dans lequel ils voluent.
Les utilisateurs des technologies objet ont pris l'habitude de considrer les objets
comme des tres anims d'une vie propre, de sorte qu'ils les prsentent souvent
2 Lapproche objet 19
dans une vision anthropomorphique3. Ainsi, les objets sont souvent dsigns en
anglais par she ou he plutt que par it.
Comme les tres vivants, les objets du monde rel qui nous entourent naissent,
vivent et meurent. La modlisation objet permet de reprsenter le cycle de vie des
objets au travers de leurs interactions.
En UML, un objet se reprsente sous la forme dun rectangle ; le nom de l'objet
est soulign. Le diagramme suivant reprsente trois objets.
Un autre objet
Un objet
Encore un objet
Compte courant
Philippe
Didier
Assurance vie
Compte pargne
Compte courant
Il est souvent difficile de trouver un nom pour dsigner chaque objet ; cest
pourquoi la notation permet dindiquer un nom gnrique plutt que leur nom
individuel. Cet artifice permet de parler des objets en termes gnraux, tout en
vitant la multiplication de noms du type ga, bu, zo ou meu, qui vhiculent un
contenu smantique trs approximatif.
Le diagramme suivant montre des lves et des professeurs. Les deux points
prcisent quil sagit dobjets anonymes, de genre Elve et Professeur.
: Elve
: Elve
: Professeur
: Elve
: Elve
: Professeur
Un objet doit apporter une valeur ajoute par rapport la simple juxtaposition
dinformations ou de code excutable. Un objet sans tat ou sans comportement
peut exister marginalement, mais dans tous les cas, un objet possde une identit.
Ltat
Ltat regroupe les valeurs instantanes de tous les attributs dun objet sachant
quun attribut est une information qui qualifie lobjet qui le contient. Chaque
attribut peut prendre une valeur dans un domaine de dfinition donn. L'tat dun
objet, un instant donn, correspond une slection de valeurs, parmi toutes les
valeurs possibles des diffrents attributs.
Le diagramme suivant montre une voiture qui contient les valeurs de trois
attributs diffrents : la couleur, la masse et la puissance fiscale.
2 Lapproche objet 21
Une voiture
Bleu
979 kg
12 CV
Figure 11 : Ltat regroupe les valeurs des diffrents attributs qui caractrisent un objet. Dans
le cas dune voiture, la couleur ou la masse font partie de ltat.
Aprs un parcours
de 100 Km
Une voiture
20 litres
Figure 12 : L'tat d'un objet un moment donn est la consquence des comportements
passs.
Le comportement
Le comportement regroupe toutes les comptences dun objet et dcrit les actions
et les ractions de cet objet. Chaque atome de comportement est appel
opration. Les oprations dun objet sont dclenches suite une stimulation
externe, reprsente sous la forme dun message envoy par un autre objet.
Dans le diagramme suivant, selon la valeur du message, lOpration 1 ou
lOpration 2 est dclenche.
Un autre objet
Un message
Un objet
Opration 1
{...}
Opration 2
{...}
Dormir
2 Lapproche objet 23
: Avion
En vol
Atterrir
Dcoller
: Tour de contrle
: Avion
Au sol
Lidentit
En plus de son tat, un objet possde une identit qui caractrise son existence
propre. Lidentit permet de distinguer tout objet de faon non ambigu, et cela
indpendamment de son tat4. Cela permet, entre autres, de distinguer deux objets
dont toutes les valeurs dattributs sont identiques.
Lidentit est un concept, elle ne se reprsente pas de manire spcifique en
modlisation. Chaque objet possde une identit de manire implicite.
En phase de ralisation, lidentit est souvent construite partir dun identifiant
issu naturellement du domaine du problme. Nos voitures possdent toutes un
numro dimmatriculation, nos tlphones un numro dappel, et nous-mmes
sommes identifis par notre numro de scurit sociale. Ce genre didentifiant,
appel galement cl naturelle, peut tre rajout dans ltat des objets afin de les
distinguer. Il ne s'agit toutefois que d'un artifice de ralisation, car le concept
d'identit reste indpendant du concept d'tat.
Contraintes de ralisation
Les notions dtat, de comportement et didentit dcrites dans le chapitre
prcdent, sappliquent aux objets de manire trs gnrale, quel que soit
lenvironnement de ralisation. Toutefois, les objets peuvent galement possder
des caractristiques plus informatiques, lies aux contingences de
ralisation comme la distribution des programmes, les bases de donnes ou les
dveloppements multilangages.
Stockage
permanent
Figure 16 : Ltat des objets persistants est sauvegard dans un systme de stockage
permanent.
2 Lapproche objet 25
Le clone est la
copie conforme
de l'objet
d'origine
Un objet
Un clone
: Support de communication
Figure 17 : Les objets peuvent tre transmis le long dun support de communication.
Contexte B
Un objet
Un client
Figure 18 : Le miroir renvoie dans le contexte A, limage dun objet dfini dans le contexte B.
Catgories de comportement
Les objets interagissent pour raliser les fonctions de lapplication. Selon la
nature des interactions, c'est--dire selon la direction des messages changs, il
Un acteur
Un serveur
Figure 19 : Les objets peuvent tre regroups dans trois catgories selon la nature de leur
comportement.
Les acteurs 6 sont toujours des objets lorigine dune interaction. Ce sont
gnralement des objets actifs, cest--dire quils possdent un fil dexcution
(thread) et que ce sont eux qui passent la main aux autres objets.
Les serveurs, au contraire, ne sont jamais lorigine dune interaction, mais sont
toujours les destinataires des messages. Ce sont souvent des objets passifs qui
attendent quun autre objet ait besoin de leurs services. Dans ce cas, le flot de
contrle est pass au serveur par lobjet qui envoie le message et est rcupr
aprs excution du service.
Un client
Un serveur
Figure 20 : Lobjet client passe la main lobjet serveur, puis attend la fin du service avant
de reprendre son excution.
Les agents cumulent les caractristiques des acteurs et des serveurs. Ces objets
ont un comportement trs proche de celui des humains ; ils peuvent interagir avec
les autres objets tout moment, de leur fait ou suite une sollicitation externe.
2 Lapproche objet 27
Serveur 1
Un client
Un agent
Serveur 2
Serveur 3
Objet
paravent
Le concept de message
L'unit de communication entre objets s'appelle le message. Le message est le
support d'une relation de communication qui relie, de faon dynamique, les objets
qui ont t spars par le processus de dcomposition. Il permet l'interaction de
manire flexible, en tant la fois agent de couplage et agent de dcouplage. C'est
lui qui assure la dlgation des tches et garantit le respect des contraintes. Le
message est un intgrateur dynamique qui permet de reconstituer une fonction de
lapplication par la mise en collaboration dun groupe dobjets. Il acquiert toute sa
force d'intgration lorsqu'il est associ au polymorphisme et la liaison
dynamique, dfinis plus loin dans ce chapitre. Les messages, comme le montre la
figure suivante, sont reprsents par des flches places le long des liens qui
unissent les objets.
Message B
Objet 1
Message A
Objet 2
Message C
Message E
Objet 3
Objet 4
Message D
Un message regroupe les flots de contrle et les flots de donnes au sein d'une
entit unique. La notion de message est un concept abstrait qui peut tre mis en
uvre selon de nombreuses variantes, comme l'appel de procdure, l'vnement
discret, l'interruption, le datagramme UDP, la recherche dynamique, etc.
Le diagramme suivant dcrit compltement un message. La flche simple indique
le flot de contrle et les flches dcores de petits cercles montrent les flots de
donnes.
Message
Donne A
Objet 1
Donne B
Objet 2
Figure 23 : Les diffrentes flches montrent le flot de contrle et les flots de donnes.
Catgories de messages
Il existe cinq catgories principales de messages :
les itrateurs qui visitent ltat dun objet ou le contenu dune structure de
donnes qui contient plusieurs objets.
2 Lapproche objet 29
Lexemple suivant montre une classe C++ dont les fonctions membres ont t
regroupes selon la classification propose plus haut :
class Lapin
{
public:
// Constructeurs
Lapin();
Lapin(const Lapin &right);
// Destructeur
~Lapin();
// Assignation
const Lapin & operator=(const Lapin &right);
// Egalit
int operator==(const Lapin &right) const;
int operator!=(const Lapin &right) const;
// Autres Operations
void Manger();
void Dormir();
// Slecteurs
const String Nom() const;
const Int Age() const;
// Modifieurs
void ChangerNom(const String value);
void ChangerAge(const Int value);
private:
String Nom;
Int Age;
};
Figure 24 : Exemple de classe C++ dont les fonctions membres ont t regroupes selon les
grandes catgories de messages.
Ecrivain 1
Afficher
: Terminal
Ecrivain 2
Afficher
Afficher
Ecrivain 3
Ressource
critique
Figure 25 : Exemple dun objet Terminal accd par plusieurs objets Ecrivain.
Un destinataire
Envoi simple
Un destinataire
Envoi synchrone
2 Lapproche objet 31
Un destinataire
Envoi drobant
Un destinataire
Envoi minut
Un destinataire
Envoi asynchrone
Ecrivain 2
Afficher
: Terminal
Afficher
Afficher
Ecrivain 3
Ressource
critique
Bernard
Lettre par la poste
2 Lapproche objet 33
3: Z
2: Y
C
8: M8
3: M3
5: M5
C
A
1: M1
4: M4
10: M10
2: M2
9: M9
7: M7
6: M6
2 Lapproche objet 35
B
M1
C
M2
M3
M4
M5
M6
M7
M8
M9
M10
B
M1
C
M2
M3
M4
M5
M6
M7
M8
M9
M10
Les classes
Le monde rel est constitu de trs nombreux objets en interaction. Ces objets
constituent des amalgames souvent trop complexes pour tre compris dans leur
intgralit du premier coup. Pour rduire cette complexit ou du moins pour la
matriser et comprendre ainsi le monde qui l'entoure, ltre humain a appris
regrouper les lments qui se ressemblent et distinguer des structures de plus
haut niveau d'abstraction, dbarrasses de dtails inutiles.
La dmarche d'abstraction
L'abstraction est une facult des tres humains qui consiste concentrer la
rflexion sur un lment d'une reprsentation ou d'une notion, en portant
spcialement l'attention sur lui et en ngligeant tous les autres. La dmarche
dabstraction procde de lidentification des caractristiques communes un
ensemble dlments, puis de la description condense analogue la
description dun ensemble en comprhension de ces caractristiques dans ce
quil est convenu dappeler une classe. La dmarche d'abstraction est arbitraire :
elle se dfinit par rapport un point de vue. Ainsi, un objet du monde rel peut
tre vu au travers d'abstractions diffrentes, ce qui implique qu'il est important de
dterminer quels sont les critres pertinents dans le domaine d'application
considr.
La classe dcrit le domaine de dfinition dun ensemble dobjets. Chaque objet
appartient une classe. Les gnralits sont contenues dans la classe et les
particularits sont contenues dans les objets. Les objets informatiques sont
construits partir de la classe, par un processus appel instanciation. De ce fait,
tout objet est une instance de classe.
Les langages objet permettent de dcrire et de manipuler des classes et leurs
instances. Cela signifie que l'utilisateur peut construire en machine une
reprsentation informatique des abstractions qu'il a l'habitude de manipuler
2 Lapproche objet 37
mentalement, sans traduction vers des concepts de plus bas niveau (comme les
fonctions ou les procdures des langages de programmation non objet).
Les langages objet rduisent la distance entre notre faon de raisonner (par
abstraction) et le langage compris par les ordinateurs, de sorte quil est
globalement plus facile de raliser une application avec un langage objet quavec
un langage traditionnel, mme si lapproche objet demande une remise en cause
des habitudes acquises.
Objets
Programmation
plus abstraite
Fonctions
Simplification
Mnmoniques
Programmation
plus difficile
Codes binaires
Les quelques exemples suivants illustrent lemploi des classes pour dcrire de
manire gnrale quelques objets de notre entourage.
L'ensemble des nombres complexes regroupe des nombres qui ont une partie
relle et une partie imaginaire. La connaissance de la reprsentation interne du
nombre complexe cartsienne ou polaire nest pas ncessaire pour utiliser les
oprations dcrites dans lexemple suivant. La classe Nombre complexe
cache les dtails de sa ralisation.
Nombre complexe
Additionner( )
Soustraire( )
Multiplier( )
Diviser( )
Prendre le module( )
Prendre l'argument( )
Prendre la partie relle( )
Prendre la partie imaginaire( )
2 Lapproche objet 39
Tlviseur
Allumer( )
Eteindre( )
Changer de programme( )
Rgler le volume( )
Une transaction bancaire est une abstraction dune opration immatrielle, qui
rifie une interaction entre un client et une banque. Le dtail de ralisation des
transactions courantes, comme le retrait ou le dpt, ne sont pas connus du client
qui se contente dindiquer le compte sur lequel il dsire oprer et le montant
concern. Le compte est une autre abstraction du domaine bancaire.
Labstraction dissimule la complexit de la gestion des comptes, de sorte que les
transactions peuvent tre ralises simplement par le client tout seul, depuis un
guichet automatique ou depuis un Minitel.
Dpt
Retrait
Montant
Date
Montant
Date
Effectu sur
Compte d'pargne
Solde
Taux
Dposer( )
Retirer( )
Effectu partir
Compte courant
Solde
Dposer( )
Retirer( )
Ou {Y=A+B}
A
B
Y( )
Tous les types de donnes abstraits manipuls par les informaticiens sont,
comme leur nom lindique, des abstractions dcrites en termes doprations
applicables sur des valeurs. Ce genre dabstraction appartient typiquement la
conception, et napparat jamais en analyse o le terme collection est suffisant
pour dsigner les regroupements dobjets.
Liste
Pile
Premier( )
Dernier( )
Ajouter( )
Retirer( )
Cardinalit( )
Empiler( )
Dpiler( )
Cardinalit( )
Arbre binaire
Sous-arbre gauche( )
Sous-arbre droit( )
Traverser en profondeur( )
Une classe passe un contrat avec dautres classes ; elle sengage fournir les
services publis dans sa spcification et les autres classes sengagent ne pas
faire usage de connaissances autres que celles dcrites dans cette spcification.
2 Lapproche objet 41
Fournisseur
Client 1
Les contrats
dcrivent les
dpendances
entre les
classes.
Client 2
Figure 47 : Les donnes encapsules dans un objet ne sont pas accessibles depuis lextrieur.
Par dfaut, les valeurs dattributs dun objet sont encapsules dans lobjet et ne
peuvent pas tre manipules directement par les autres objets. Toutes les
interactions entre les objets sont effectues en dclenchant les diverses
oprations dclares dans la spcification de la classe et accessibles depuis les
autres objets.
Les rgles de visibilit viennent complter ou prciser la notion dencapsulation.
Ainsi, il est possible dassouplir le degr dencapsulation, mais aussi de
protection, au profit de certaines classes utilisatrices bien particulires, dsignes
dans la spcification de la classe fournisseur. Lintrt de briser lencapsulation
est par exemple de rduire le temps daccs aux attributs en supprimant la
ncessit de recourir des oprations de type slecteur.
Les trois niveaux distincts dencapsulation couramment retenus correspondent
ceux proposs par le langage de programmation C++ :
Le niveau le plus fort est appel niveau priv ; la partie prive de la classe est
alors totalement opaque et seuls les amis (au sens C++) peuvent accder aux
attributs placs dans la partie prive.
Le niveau le plus faible est obtenu en plaant les attributs dans la partie
publique de la classe. Ceci revient se passer de la notion dencapsulation et
rendre visibles les attributs pour toutes les classes.
Le niveau de visibilit peut tre prcis dans les reprsentations graphiques des
classes au moyen des caractres +, # et -, qui correspondent respectivement aux
niveaux public, protg et priv.
2 Lapproche objet 43
Rgles de visibilit
+ Attribut public
# Attribut protg
- Attribut priv
+ Opration publique( )
# Opration protge( )
- Opration prive( )
Figure 48 : Prcision des niveaux de visibilit dans les reprsentations graphiques des classes.
Nombre complexe
- Partie relle
- Partie imaginaire
+
+
+
+
+
+
+
+
Addition( )
Soustraction( )
Multiplication( )
Division( )
Addition( )
Soustraction( )
Multiplication( )
Division( )
Lassociation
Lassociation exprime une connexion smantique bidirectionnelle entre classes.
Une association est une abstraction des liens qui existent entre les objets
instances des classes associes. Le diagramme suivant reprsente des objets lis
entre eux et les classes associes correspondantes. Les associations se
reprsentent de la mme manire que les liens. La distinction entre un lien et une
association est opre en fonction du contexte du diagramme.
Pierre-Alain : Etudiant
Un lien
Mulhouse : Universit
Un lien
Jean-Jacques : Etudiant
Purdue : Universit
Eric : Etudiant
Un lien
Anne : Etudiant
Un lien
Strasbourg : Universit
Un lien
Laurence : Etudiant
Une association
Universit
Etudiant
Figure 50 : Les liens entre les universits et les tudiants sont tous instances de lassociation
entre la classe Universit et la classe Etudiant.
Il faut noter que lassociation est un concept de mme niveau dabstraction que
les classes. Lassociation nest pas contenue par les classes ou subordonne aux
classes ; elle est le reflet dune connexion qui existe dans le domaine
dapplication.
2 Lapproche objet 45
Pour amliorer la lisibilit des diagrammes, lassociation peut tre dcore par une
forme verbale active ou passive. Dans les exemples suivants, le sens de lecture
est prcis par les signes < et >.
Hberge >
Universit
Etudiant
Etudiant
Il est possible de prciser le rle dune classe au sein dune association : un nom
de rle peut tre spcifi de part et dautre de lassociation. Lexemple suivant
montre deux associations entre la classe Universit et la classe Personne.
Le diagramme prcise que certaines personnes jouent le rle dtudiant, alors que
dautres personnes jouent le rle denseignant. La deuxime association porte
galement un nom de rle du ct de la classe Universit pour indiquer que
luniversit joue le rle demployeur pour ses enseignants. Le nommage des rles
prend tout son intrt lorsque plusieurs associations relient deux mmes classes.
Etudiant
Universit
Employeur
Personne
Enseignant
Les rles portent galement une information de multiplicit qui prcise le nombre
dinstances qui participent la relation. Linformation de multiplicit apparat
dans les diagrammes de classes proximit du rle concern.
Le tableau suivant rsume les valeurs de multiplicit les plus courantes :
1
Un et un seul
0..1
Zro ou un
M .. N
De M N (entiers
naturels)
De zro plusieurs
0 .. *
De zro plusieurs
1 .. *
D'un plusieurs
*
Personne
0..1
Employeur
*
Enseignant
Lagrgation
Une relation exprime une forme de couplage entre abstractions. La force de ce
couplage dpend de la nature de la relation dans le domaine du problme. Par
dfaut, lassociation exprime un couplage faible, les classes associes restant
relativement indpendantes lune de lautre. Lagrgation est une forme
particulire dassociation qui exprime un couplage plus fort entre classes. Une
des classes joue un rle plus important que lautre dans la relation. Lagrgation
permet de reprsenter des relations de type matre et esclaves, tout et parties ou
compos et composants.
Les agrgations reprsentent des connexions bidirectionnelles dissymtriques. Le
concept dagrgation est une notion purement logique, compltement
indpendante des choix de reprsentation qui relvent de la conception dtaille
et non de la modlisation. Mathmatiquement, lagrgation est une relation
transitive, non symtrique et rflexive.
Lexemple suivant montre quune personne peut soccuper de plusieurs enfants.
La relation est de nature dissymtrique dans le domaine considr : ladulte est
responsable des enfants. La relation est galement rflexive : certaines personnes
2 Lapproche objet 47
Parent
0..2
Enfants
*
<S'occupe de
Moteur
1
Agrgat
Composants
*
Agrgat
Composants
*
: Composant
: Agrgat
: Composant
: Agrgat
: Composant
Composants
partags
0..*
1..*
1..*
*
Relation
1 *
Lien
*
*
Objet
*
*
Diagramme de classes
Diagramme d'objets
*
Les rgles suivantes gouvernent la transition entre les deux types de diagramme :
2 Lapproche objet 49
chaque objet est instance dune classe et la classe de lobjet ne peut pas
changer durant la vie de lobjet,
les liens relient les objets, les relations relient les classes,
un lien entre deux objets implique une relation entre les classes des deux
objets,
un lien entre deux objets indique que les deux objets se connaissent et quils
peuvent changer des messages,
les diagrammes dobjets qui contiennent des objets et des liens sont
instances des diagrammes de classes qui contiennent des classes et des
relations.
Les diagrammes de classes et les diagrammes dobjets doivent tre cohrents les
uns par rapport aux autres. Toutefois, il faut tre conscient que le processus de
modlisation objet nest pas un processus linaire, de sorte quil nest pas
souhaitable de construire un type de diagramme et ensuite den driver
intgralement lautre type. Forcer la cration dun type de diagramme avant un
autre limite la libert de cration. Pour prendre une image musicale, dissocier la
construction des diagrammes dobjets de celle des diagrammes de classes,
reviendrait demander un compositeur de considrer sparment la hauteur des
notes et leur dure.
En pratique, les diagrammes dobjets et les diagrammes de classes se construisent
en parallle, par de nombreux allers et retours entre les deux reprsentations. Il ny
a aucune raison de dfinir les classes avant les objets. Il est vrai que chaque objet
est instance dune classe, mais la dtermination de la classe peut trs bien tre
postrieure celle des objets. Le monde rel qui nous entoure contient des objets
et non des classes : il semble donc naturel de trouver dabord les objets puis den
abstraire les classes. En fait, il ny a pas de rgle gnrale ; dans certains cas, la
structure des classes est vidente, dans dautres cas, les objets sont plus faciles
identifier que les classes.
Gnralisation et spcialisation
La gnralisation et la spcialisation sont des points de vue ports sur les
hirarchies de classes.
La gnralisation consiste factoriser les lments communs (attributs,
oprations et contraintes) d'un ensemble de classes dans une classe plus
gnrale appele super-classe. Les classes sont ordonnes selon une hirarchie ;
une super-classe est une abstraction de ses sous-classes.
La gnralisation est une dmarche assez difficile car elle demande une bonne
capacit d'abstraction. La mise au point dune hirarchie optimale est dlicate et
itrative. Les arbres de classes ne poussent pas partir de leur racine. Au
contraire, ils se dterminent en partant des feuilles car les feuilles appartiennent
au monde rel alors que les niveaux suprieurs sont des abstractions construites
pour ordonner et comprendre.
Lexemple suivant montre une hirarchie des moyens de transport. La flche qui
symbolise la gnralisation entre deux classes pointe vers la classe plus gnrale.
Abstractions plus gnrales
Vhicule
Vhicule terrestre
Voiture
Camion
Vhicule arien
Avion
Hlicoptre
2 Lapproche objet 51
Transmission
Continue
Variateur
Discrte
Drailleur
Bote de vitesses
Super-classe
Sous-classe
Classe plus
gnrale
Classe plus
spcialise
En fait, la situation est tout fait paradoxale ! Il est plutt difficile de trouver les
super-classes, mais les programmes crits dans leurs termes sont plus simples
dvelopper. Il est assez facile de trouver les sous-classes, mais difficile de les
raliser.
La gnralisation ne porte aucun nom particulier ; elle signifie toujours : est un ou
est une sorte de. La gnralisation ne concerne que les classes, elle nest pas
instanciable en liens et, de fait, ne porte aucune indication de multiplicit. Dans
l'exemple suivant, le lion est une sorte de carnivore et il nest pas possible pour
un lion dtre plusieurs fois un carnivore : un lion est un carnivore.
Animal
Carnivore
Lion
Herbivore
Mouton
Lapin
La gnralisation est une relation non rflexive : une classe ne peut pas driver
d'elle-mme.
A
B
Impossible !!!
La gnralisation est une relation non symtrique : si une classe B drive d'une
classe A, alors la classe A ne peut pas driver de la classe B.
2 Lapproche objet 53
Impossible !!!
C
B
La gnralisation est par contre une relation transitive : si C drive d'une classe B
qui drive elle-mme d'une classe A, alors C drive galement de A.
A
X
Proprit caractristique de X
Figure 67 : Une classe donne une description abstraite dun ensemble dobjets qui partagent
des caractristiques communes.
Figure 68 : Les lments des ensembles Y et Z sont dabord des lments de lensemble X. Les
proprits caractristiques P (Y) et P (Z) englobent la proprit caractristique P (X).
Les classes et les sous-classes sont lquivalent des ensembles et des sousensembles. La gnralisation des classes correspond la relation dinclusion des
ensembles. De ce fait, les objets instances dune classe donne sont dcrits par la
proprit caractristique de leur classe, mais galement par les proprits
2 Lapproche objet 55
Proprit caractristique de Y
Proprit caractristique de Z
Figure 70 : Les livres pour enfants et ceux pour lenseignement reprennent les caractristiques
gnrales des livres.
Proprit caractristique de Y
Proprit caractristique de Z
T
Proprit caractristique de T
2 Lapproche objet 57
Dans le monde des classes, la situation prcdente met en jeu une classe
abstraite, cest--dire une classe qui ne donne pas directement des objets. Elle
sert en fait de spcification plus abstraite pour des objets instances de ses sousclasses. Le principal intrt de cette dmarche est de rduire le niveau de dtails
dans les descriptions des sous-classes. Le nom dune classe abstraite est en
italique dans les diagrammes de classes.
Classe abstraite
Classe concrte A
Le nom des
classes abstraites
est en italique
Classe concrte B
Proprit caractristique de Y
Proprit caractristique de Z
T
Proprit caractristique de T
Les objets de la classe T sont dcrits une seule fois par la proprit
caractristique de X. Le nombre de branches de la gnralisation nest pas
significatif pour la propagation des proprits caractristiques et ainsi T ne
possde pas deux fois la proprit caractristique de X.
Les objets sont instances dune classe ou ne le sont pas ; il nest pas possible
dtre plusieurs fois instance de la mme classe.
2 Lapproche objet 59
De la difficult de classer
La classification n'est pas toujours une opration triviale. En effet, la
dtermination des critres de classification est difficile et dans certains cas il n'est
pas possible de se dterminer. En 1755, bien avant UML, Jean-Jacques Rousseau,
dans louvrage Discours sur lorigine et les fondements de lingalit parmi les
hommes, voque le problme de la classification dans les termes suivants :
Chaque objet reut dabord un nom particulier, sans gard aux genres et aux
espces (...). Si un chne sappelait A, un autre chne sappelait B ; car la
premire ide que lon tire de deux choses, cest quelles ne sont pas la mme ;
et il faut souvent beaucoup de temps pour observer ce quelles ont de commun :
de sorte que plus les connaissances taient bornes, et plus le dictionnaire
devint tendu. Lembarras de toute cette nomenclature ne put tre lev
facilement, car, pour ranger les tres sous des dnominations communes et
gnriques, il en fallait connatre les proprits et les diffrences ; il fallait des
observations et des dfinitions, cest--dire de lhistoire et de la mtaphysique,
beaucoup plus que les hommes de ce temps-l nen pouvaient avoir.
Les classifications doivent avant tout bien discriminer les objets. Les bonnes
classifications sont stables et extensibles. Il arrive quelles comportent des
exceptions inclassables selon les critres retenus. Le grand panda, par exemple,
fait partie de la famille des ours alors que le petit panda est plus proche des ratons
laveurs. Lornithorynque appartient la famille des mammifres tout en tant
ovipare.
Les classifications seffectuent selon des critres dpendant du point de vue. Il
n'y a donc pas une classification, mais des classifications, chacune adapte un
usage donn.
Ainsi, pour les animaux, de nombreux critres peuvent tre retenus :
la station,
le type de nourriture,
la protection.
La dtermination des critres pertinents et de lordre dans lequel ils doivent tre
appliqus nest pas toujours facile. Une fois les critres arrts, il faut les suivre
de manire cohrente et uniforme selon lordre dtermin.
Lordre dapplication des critres est souvent arbitraire, et conduit des
dcompositions covariantes qui se traduisent par des parties de modle
isomorphes.
Dans lexemple suivant, le critre de la station a t appliqu avant le critre de la
nourriture. Sans informations supplmentaires, il est bien difficile de dire pourquoi
ce choix a t effectu.
Animal
Bipde
Herbivore
Quadrupde
Carnivore
Herbivore
Carnivore
Covariance
Les animaux peuvent tout aussi bien tre spcialiss dabord par rapport leur
type de nourriture.
Animal
Herbivore
Bipde
Quadrupde
Carnivore
Bipde
Quadrupde
Covariance
2 Lapproche objet 61
Animal
Station
Protection
Nourriture
Bipde
Quadrupde
Herbivore Carnivore
A plumes
A poils
A cailles
Lapin
0..*
0..*
Moto
Cross
Enduro
Licence
Cross
Enduro
Vhicule terrestre
Voiture
Camion
Monet et Goyon
Lnumration de toutes les marques nest pas non plus une bonne ide car cela
cr normment de sous-classes. Il vaut mieux favoriser le critre le plus global
car cest lui qui donnera des sous-classes plus extensibles. En rgle gnrale, il
vaut mieux limiter le nombre de sous-classes chaque niveau hirarchique, quitte
augmenter le nombre dobjets par classe et se rserver les attributs dobjets
pour qualifier finement les objets.
La drive vers un trop grand nombre de classes est illustre dans lexemple
suivant. Dune part, le critre de la couleur est trop prcis pour dterminer une
classe et dautre part, il gnre trop de classes. Enfin, du fait du lien statique entre
classe et instance, le modle ne permet pas de changer la couleur dune voiture !
Il faut en fait que le critre de gnration dune classe soit statique. La couleur
doit tre un attribut des vhicules, pas un critre de spcialisation.
Vhicule terrestre
Voiture
Voiture bleue
Voiture rouge
Voiture verte
2 Lapproche objet 63
Papillon
Chenille
Chrysalide
Lpidoptre
Figure 83 : Le modle ci-dessus nest pas adapt pour reprsenter les papillons, car la
relation qui lie un objet sa classe nest pas mutable.
Apparence
Stade
Chenille
Chrysalide
Lpidoptre
Ralise >
Type
*
Type A
Type B
Type C
Livre
Gommette
1 Couleur
Lhritage
Il existe de nombreuses manires de raliser la classification. En programmation
objet, la technique la plus utilise repose sur lhritage entre classes.
Principe gnral
Lhritage est une technique offerte par les langages de programmation pour
construire une classe partir dune ou plusieurs autres classes, en partageant des
attributs, des oprations et parfois des contraintes, au sein d'une hirarchie de
classes. Les classes enfants hritent des caractristiques de leurs classes
parents ; les attributs et les oprations dclars dans la classe parent, sont
accessibles dans la classe enfant, comme sils avaient t dclars localement.
Lhritage est utilise pour satisfaire deux besoins distincts : la classification et la
construction. Cette ambivalence de la relation dhritage, qui peut la fois classer
et construire, est la source de beaucoup dincohrences de programmation. Il en
est de lhritage comme de la conduite automobile ; il faut se tenir ni trop droite
ni trop gauche, mais bien au milieu de la voie, sinon le risque daccident est
lev. Il faut apprendre utiliser correctement lhritage, comme il faut apprendre
conduire les voitures.
En programmation, avec un langage objet comme C++, la classification se ralise
trs souvent par une relation dhritage entre la classe plus gnrale et la classe
plus spcifique. Lhritage propage les caractristiques de la classe parent dans
les classes enfants, de sorte que plusieurs classes peuvent partager une mme
description. De ce point de vue, lhritage permet une description conomique
dun ensemble de classes relies par une relation de classification.
De nombreux programmeurs effectuent un amalgame entre la notion de
classification implique par lhritage et la composition virtuelle qui en rsulte.
Ces programmeurs recherchent avant tout une conomie dexpression court
terme ; ils ont pris lhabitude dintgrer des composants dans un compos en
exploitant la propagation des caractristiques ralise automatiquement par la
relation dhritage. La construction de composants par hritage est une technique
de programmation parfaitement respectable, condition de clairement matrialiser
le fait dans le programme. Lorsque le programmeur construit par hritage, il doit
indiquer que la relation dhritage concerne est utilise pour la construction et
non pour la classification. Le langage C++, par exemple, permet de distinguer
2 Lapproche objet 65
deux proprits diffrentes, il serait judicieux den renommer une afin de pouvoir
les distinguer. Il nexiste pas de rponse toute faite ce problme : les langages
objet diffrent dans leur manire de le traiter.
Z
A de X
A de Y
Figure 89 : Exemple de collision de noms. Le nom A est dfini dans les deux super-classes X
et Y.
A de T
A de T
Z
A de T par X
A de T par Y
Figure 90 : Exemple de collision de noms dans le cas dune forme dhritage en losange.
Cette situation est suffisamment ennuyeuse pour que certains langages objet,
comme Java ou Ada 95, noffrent pas dhritage multiple. Dans la pratique,
lhritage multiple peut tre employ sans trop de soucis lorsque sa mise en
uvre a accompagn llaboration du modle depuis le dbut. Par contre, il y a
fort peu de chances pour que lhritage multiple soit la manire deffectuer une
2 Lapproche objet 67
Paquetage A
Paquetage B
XA
XB
Mlange
Hasardeux !!!
Figure 91 : Lhritage multiple nest pas adapt pour la construction dune classe par fusion
de plusieurs classes issues de paquetages labors de manire indpendante.
La dlgation
Lhritage nest pas une ncessit absolue et peut toujours tre remplac par la
dlgation. La dlgation prsente lavantage de rduire le couplage dans le
modle : dune part, le client ne connat pas directement le fournisseur, et dautre
part, le fournisseur peut tre modifi en cours de route. Cette approche permet la
mise en uvre de la gnralisation multiple avec les langages qui ne possdent
que lhritage simple. Le diagramme suivant illustre le mcanisme de dlgation ;
le client communique avec une interface qui propage les questions un ou
plusieurs dlgus.
: Client
Question
Propagation
: Dlgu 1
: Interface
Propagation
: Dlgu 2
Animal
Station
Bipde
Nourriture
Quadrupde
Herbivore
Carnivore
Basic
ignore : int
foreground : int
gc : GC
2 Lapproche objet 69
BasicClassRec
class
1
core_class 1
BasicPart
foreground : int
* gc : GC
basic_class
CoreClassPart
BasicClassPart
...
ignore : int
Le principe de substitution
La classification propage ltat, le comportement et les contraintes. Il ny a pas de
demi-mesure : toutes les proprits de la classe parent sont valables intgralement
pour la classe enfant. Le besoin dhriter partiellement est le signe que la relation
dhritage considre ne ralise pas vraiment une relation de classification.
Le principe de substitution, nonc originellement par Liskow8, permet de
dterminer si une relation dhritage est bien employe pour la classification. Le
principe de substitution affirme que :
il doit tre possible de substituer nimporte quel objet instance dune sousclasse nimporte quel objet instance dune super-classe sans que la
smantique du programme crit dans les termes de la super-classe ne soit
affecte.
Lillustration suivante montre un programme symbolis par un rectangle qui
fait rfrence des objets de la classe parent. Si le principe de substitution est
vrifi, tout objet instance de la classe CP doit pouvoir tre remplac par un objet
instance de la classe CE, sans que cela naffecte le programme crit dans les
termes de la classe CP.
CP
CE
La notion de gnralisation implique que la proprit caractristique de la superclasse est incluse dans la proprit caractristique de la sous-classe. Or, les
compilateurs de certains langages ne sont pas capables de vrifier intgralement
que cette condition est satisfaite dans le cas de lhritage, car la syntaxe seule ne
suffit pas toujours pour exprimer lensemble des proprits. Les attributs et les
oprations sont propags automatiquement, mais les contraintes ne le sont pas
ncessairement. Souvent, une contrainte est traduite par une forme de code
particulire, implante dans la ralisation dune opration. Comme les langages
objet permettent la redfinition des oprations dans les sous-classes, les
programmeurs peuvent involontairement introduire des incohrences entre la
spcification dune super-classe et la ralisation dans une des sous-classes. Ces
incohrences concernent principalement les contraintes exprimes de manire
programme et non dclarative. Ladhrence au principe de substitution garantit
quune relation dhritage entre classes correspond bien une gnralisation.
Malheureusement, la mise en uvre du principe de substitution est du ressort du
programmeur et non du compilateur et, comme le programmeur est humain, il nest
pas labri dune erreur. Sans respect du principe de substitution, le
polymorphisme dcrit dans le paragraphe suivant ne peut tre mis en uvre.
Le polymorphisme
Le terme polymorphisme dcrit la caractristique dun lment qui peut prendre
plusieurs formes, comme leau qui se trouve ltat solide, liquide ou gazeux. En
informatique, le polymorphisme dsigne un concept de la thorie des types, selon
lequel un nom dobjet peut dsigner des instances de classes diffrentes issues
dune mme arborescence.
Principe gnral
Les interactions entre objets sont crites selon les termes des spcifications
dfinies, non pas dans les classes des objets, mais dans leurs super-classes.
Ceci permet dcrire un code plus abstrait, dtach des particularismes de chaque
classe, et dobtenir des mcanismes suffisamment gnraux pour tre encore
valides dans le futur, quand seront crs de nouvelles classes.
2 Lapproche objet 71
Application
Le diagramme suivant reprsente une collection polymorphe, le zoo. Le zoo
contient de nombreux animaux qui peuvent tre soit des lions, soit des tigres, soit
des ours. Le nom Animal, connu de la classe Zoo, dcrit collectivement toutes
les sortes danimaux. Le logiciel, crit au niveau dabstraction du zoo, na pas
besoin de connatre les dtails propres chaque animal.
Zoo
Animal
1
Lion
Tigre
Ours
Les animaux de lexemple prcdent savent tous dormir, mais chaque race a ses
habitudes particulires. La spcification de lanimal dit que les animaux peuvent
dormir. Les sous-classes particularisent lopration Dormir() selon les gots
de chaque race. Le diagramme suivant montre comment chaque race danimaux
lhabitude de dormir.
Animal
Zoo
1
* Dormir( )
Lion
Dormir ()
{
Sur le ventre
}
Tigre
Dormir ()
{
Sur le dos
}
Ours
Dormir ()
{
Dans un arbre
}
Les mcanismes gnraux crits selon la spcification du zoo nont pas besoin de
connatre les gots particuliers de chaque genre danimal pour invoquer
lopration Dormir(). Ainsi, le soir venu, le gardien se promne au travers du
zoo et informe chaque animal quil est temps de dormir.
Le zoo
Dormir
Le gardien
: Animal
Termin qui est vrai lorsque tous les lments ont t visits.
2 Lapproche objet 73
Itrateur
Collection
Liste
Pile
< Manipule
Suivant( )
Initialiser( )
Valeur( )
Termin( )
File
Le mcanisme qui endort les animaux du zoo est indpendant des animaux qui se
trouvent rellement dans le zoo un moment donn : leffectif de chaque espce
nest pas inscrit dans lalgorithme qui se contente dexploiter un itrateur sur une
collection. Le mcanisme ne dpend pas non plus de la sous-classe prcise de
lanimal courant : si de nouveaux animaux sont ajouts dans le zoo, il nest pas
ncessaire de modifier le code qui endort les animaux existants pour endormir les
nouveaux arrivants. Les particularits des nouveaux animaux sont encapsules
dans leur classe qui est rajoute dans le modle par drivation de la classe
Animal dj existante. Pour prendre en compte un nouvel animal, il suffit donc
de crer une sous-classe, de raliser lopration Dormir() dont il hrite, et
ventuellement de recompiler.
Animal
Zoo
1
* Dormir( )
Lion
Dormir ()
{
Sur le ventre
}
Tigre
Dormir ()
{
Sur le dos
}
Ours
Paresseux
Dormir ()
{
Dans un arbre
}
Dormir ()
{
Sans fin
}
Figure 102 : Exemple de prise en compte dun nouvel animal par ajout dune sous-classe.
2 Lapproche objet 75
Figure 103 : Sans liaison dynamique, le programmeur doit effectuer lui-mme le choix de
lopration qui correspond au message Dormir().
Oiseau
Plumes
Bec
Voler ()
{
Mettre la tte dans le sable
}
Voler( )
Msange
Moineau
Autruche
S'envoler
: Moineau
Voler
Voler
: Msange
: Sauveteur
Voler
Enterrer sa tte
2 Lapproche objet 77
I
Z( )
Classe
abstraite
J
Classe
abstraite
Z de I( )
K
Z selon K( )
L
Z de K( )
M
Z selon M( )
Ralisation
de Z
Hritage
de Z
Modification
de Z
Figure 106 : Exemple de hirarchie de classes. Lopration Z est dfinie dans la classe de
base I, puis ralise dans la classe K et modifie dans la classe M.
Les objets de la classe Client possdent des liens polymorphes vers des
objets des classes K, L ou M.
: K, L ou M
Un_I
Un Client
Un_K
: K, L ou M
Un_L
Un_M
: L ou M
:M
Figure 107 : Chaque objet de la classe Client peut communiquer avec quatre objets
instances des classes concrtes K, L ou M.
Le lien Un_I est polymorphe et peut dsigner un objet instance dune classe
concrte drive de I par exemple la sous-classe K. Le client peut ainsi manipuler
un objet instance dune sous-classe, au travers de la spcification dune superclasse. Toutes les caractristiques de la super-classe sappliquent aux objets
instances des sous-classes, en particulier le message Z peut tre envoy
lobjet Un_K le long du lien polymorphe Un_I.
Le code correspondant lopration Z est recherch lexcution en descendant
larbre dhritage jusqu la classe prcise de lobjet. La classe K ralise
lopration Z, le message est compris et lopration ralise dans la classe K est
excute.
Un Client
Un_I
Un K
Z()
Lien
polymorphe
Dclenchement
de l'opration Z
ralise dans K
Figure 108 : Le lien Un_I dsigne un objet de la classe K. Le message est compris, car la
classe K ralise lopration Z.
Le cas de figure suivant est proche du cas prcdent, si ce nest que la recherche
seffectue un cran plus bas dans la hirarchie. La classe L nayant pas modifi la
ralisation de lopration Z hrite de la classe K, le mme comportement que
prcdemment est dclench.
2 Lapproche objet 79
Un Client
Un_I
Un L
Z()
Lien
polymorphe
Dclenchement
de l'opration Z
ralise dans K
Figure 109 : La ralisation de lopration Z prsente dans la classe L est hrite de la classe
K. A lexcution, le comportement ralis dans la classe K sera dclench.
Toute classe intermdiaire dans larborescence des classes peut fournir une
spcification pour manipuler les objets instances de ses sous-classes. A ce titre,
le lien Un_L peut tre exploit de manire polymorphe pour manipuler des objets
instances de la classe M. Comme M modifie lopration Z, lexpression Un_L.Z()
dclenche le code ralis dans la classe M.
Un Client
Un_L
Un M
Z()
Lien
polymorphe
Dclenchement
de l'opration Z
modifie dans M
Un Client
Un_K
Un K
Z()
Lien
polymorphe
Dclenchement
de l'opration Z
ralise dans K
Influence du typage
Le polymorphisme existe dans les environnements typs comme dans les
environnements non typs, mais seuls les environnements typs garantissent
une excution sans surprise des programmes condition toutefois de respecter
le principe de substitution. La notion de typage permet au compilateur de vrifier
statiquement que les messages envoys un objet seront compris lors de
lexcution. En Ada 95, en Eiffel, en C++ ou en Java, les messages sont toujours
compris par le destinataire du fait du typage fort. En labsence de typage fort,
nimporte quel message peut tre envoy nimporte quel objet. En Smalltalk, un
message peut ne pas tre compris et lexpditeur doit donc se prparer cette
ventualit. Ceci nenlve rien la vertu de la liaison dynamique, toujours utile
pour trouver le code le plus adapt en fonction de la classe. Mais la diffrence
des langages typs, la recherche peut tre infructueuse.
Il importe de ne pas confondre le polymorphisme avec la surcharge des
oprations, parfois appele polymorphisme ad hoc. Certains langages autorisent
lemploi dun mme nom pour dsigner une famille doprations, avec un profil de
paramtres diffrent pour chaque opration. La surcharge est un moyen lgant
doffrir la notion de signature variable, sans tomber dans le travers des oprations
nombre de paramtres variable comme en C. La surcharge est toujours rsolue
statiquement par les compilateurs, elle na rien voir avec la liaison dynamique.
Les heureux parents reconnatront le comportement de leur progniture dans la
classe suivant. Lopration Manger() est surcharge : elle existe sous trois
formes diffrentes, identifiables statiquement par le compilateur en fonction de la
signature.
2 Lapproche objet 81
Enfant
Manger ()
Manger (Lentement : Boolen = Vrai)
Manger (Lentement : Boolen, Comme_Un_Cochon : Boolen)
Figure 112 : Exemple dune opration surcharge. La classe Enfant propose trois
oprations Manger() diffrentes, identifiables statiquement par leur signature.
3
La notation UML
La notation UML est une fusion des notations de Booch, OMT, OOSE et dautres
notations. UML est conue pour tre lisible sur des supports trs varis comme
les tableaux blancs, le papier, les nappes de restaurants, les crans dordinateurs,
les impressions en noir et blanc, etc. Les concepteurs de la notation ont recherch
avant tout la simplicit ; UML est intuitive, homogne et cohrente. Les symboles
embrouills, redondants ou superflus ont t limins en faveur dun meilleur
rendu visuel.
UML se concentre sur la description des artefacts du dveloppement de logiciel,
plutt que sur la formalisation du processus de dveloppement lui-mme : elle
peut ainsi tre utilise pour dcrire les lments logiciels, obtenus par
lapplication de diffrents processus de dveloppement. UML nest pas une
notation ferme : elle est gnrique, extensible et configurable par lutilisateur.
UML ne recherche pas la spcification outrance : il ny a pas une reprsentation
graphique pour tous les concepts imaginables ; en cas de besoins particuliers,
des prcisions peuvent tre apportes au moyen de mcanismes dextension et de
commentaires textuels. Une grande libert est donne aux outils pour le filtrage et
la visualisation dinformation. Lusage de couleurs, de dessins et dattributs
graphiques particuliers est laiss la discrtion de lutilisateur.
Ce chapitre propose un survol de la smantique des lments de modlisation
dUML, dcrits de manire prcise dans le document UML 1.0, Semantics 9. Cette
prsentation a pour objectif dintroduire les principaux concepts de modlisation
et de montrer leur articulation au sein de la notation UML. Les lments de
visualisation et les lments de modlisation sont prsents conjointement, en se
Composants
Dploiement
Classes
Cas d'utilisation
Squence
Etats-Transitions
Activit
Objets
Collaboration
10
3 La notation UML 85
Concepts de base
Il est pratique de reprsenter la smantique des lments de modlisation dUML
selon le formalisme dUML.
Ce type de reprsentation rcursive pose cependant le problme de luf et de la
poule, principalement lors de lapprentissage. Cest pourquoi il est conseill, en
premire lecture, de considrer les diagrammes comme des exemples de la
notation, plutt que de chercher approfondir leur comprhension
Quoi quil en soit, les diagrammes montrent des vues simplifies du mtamodle
afin de rendre le texte accessible au plus grand nombre de lecteurs.
11
Possde
0..1
Modle
0..*
0..*
0..*
Rfrence
Elment
Elment de modlisation
Elment de visualisation
1..*
0..*
Projection
Figure 114 : Extrait du mtamodle. Reprsentation des deux grandes familles d'lments qui
forment le contenu des modles.
3 La notation UML 87
Elment de modlisation
Relation
Dpendance
Source
Classification
Strotype
0..*
Cible
0..*
1..*
Elment
Note
0..*
name : Name
ValeurEtiquete
0..*
nom : Nom
0..1
0..*
0..*
Contrainte
0..* Proprit
0..1
Les strotypes
Les strotypes font partie des mcanismes dextensibilit, prvus dans UML.
Chaque lment de modlisation d'UML a au plus un strotype, lorsque la
smantique de base de l'lment est insuffisante. Un strotype permet la
mtaclassification dun lment d'UML. Il permet aux utilisateurs
(mthodologistes, constructeurs doutils, analystes et concepteurs) dajouter de
nouvelles classes dlments de modlisation, en plus du noyau prdfini par
UML. Les strotypes facilitent galement lunification de concepts proches,
comme les sous-systmes ou les catgories, qui sont exprims au moyen de
strotypes de paquetage.
Les strotypes permettent lextension contrle des classes du mtamodle, par
les utilisateurs dUML. Un lment spcialis par un strotype S est
smantiquement quivalent une nouvelle classe du mtamodle, nomme elle
aussi S. A lextrme, toute la notation aurait pu tre construite partir des deux
classes Truc et Strotype, les autres concepts en drivant par strotypage
de la classe Truc.
Les concepteurs dUML ont recherch lquilibre entre les classes incluses
dorigine, et les extensions apportes par les strotypes. Ainsi, seuls les
concepts fondamentaux ont t exprims sous la forme de classes distinctes. Les
autres concepts, drivables de ces concepts de base, ont t traits comme des
strotypes.
Les tiquettes
Une tiquette est une paire (nom, valeur) qui dcrit une proprit dun
lment de modlisation. Les proprits permettent lextension des attributs des
lments du mtamodle. Une tiquette modifie la smantique de llment quelle
qualifie.
Les notes
Une note est un commentaire attach un ou plusieurs lments de modlisation.
Par dfaut, les notes ne vhiculent pas de contenu smantique. Toutefois, une
note peut tre transforme en contrainte au moyen dun strotype, et dans ce
cas, elle modifie la smantique des lments de modlisation auxquels elle est
attache.
Les contraintes
Une contrainte est une relation smantique quelconque entre lments de
modlisation. UML ne spcifie pas de syntaxe particulire pour les contraintes,
qui peuvent ainsi tre exprimes en langage naturel, en pseudo-code, par des
expressions de navigation ou par des expressions mathmatiques.
La relation de dpendance
La relation de dpendance dfinit une relation dutilisation unidirectionnelle entre
deux lments de modlisation, appels respectivement source et cible de la
relation. Les notes et les contraintes peuvent galement tre source dune relation
de dpendance.
3 La notation UML 89
Liste
Boolen
Expression
Point
Multiplicit
Chane
Temps
Nom
Non interprt
Boolen. Un boolen est un type numr qui comprend les deux valeurs
Vrai et Faux.
Expression. Une expression est une chane de caractres dont la syntaxe est
hors de la porte dUML.
Liste. Une liste est un conteneur dont les parties sont ordonnes et peuvent
tre indexes.
Nom. Un nom est une chane de caractres qui permet de dsigner un lment.
Des noms composs peuvent tre forms partir de noms simples, selon la
rgle suivante :
nom_compos ::= nom_simple { . nom_compos }
Le nom dun lment peut tre qualifi par le nom du paquetage qui le contient
ou qui le rfrence, selon la syntaxe suivante :
nom_qualifi ::= qualificateur "::" nom_simple
qualificateur ::= nom_de_paquetage
{ "::" qualificateur }
Point. Un point est un tuple (x, y, z) qui dcrit une position dans
lespace. Par dfaut, la composante z prend la valeur 0.
Chane. Une chane est une suite de caractres, dsigne par un nom.
Temps. Un temps est une chane qui reprsente un temps absolu ou relatif et
dont la syntaxe est hors de la porte d'UML.
Les paquetages
Les paquetages offrent un mcanisme gnral pour la partition des modles et le
regroupement des lments de modlisation. Chaque paquetage est reprsent
graphiquement par un dossier.
Nom de
paquetage
Les paquetages divisent et organisent les modles de la mme manire que les
rpertoires organisent les systmes de fichiers. Chaque paquetage correspond
un sous-ensemble du modle et contient, selon le modle, des classes, des objets,
des relations, des composants ou des nuds, ainsi que les diagrammes associs.
La dcomposition en paquetages nest pas lamorce dune dcomposition
fonctionnelle ; chaque paquetage est un regroupement dlments selon un
critre purement logique. La forme gnrale du systme (larchitecture du
systme) est exprime par la hirarchie de paquetages et par le rseau de relations
de dpendance entre paquetages.
Les strotypes <<Catgorie>> et <<Sous-systme>> permettent de
distinguer, si besoin est, les paquetages de la vue logique et les paquetages de la
vue de ralisation (ces vues sont dtailles dans le quatrime chapitre).
Cat
<<Catgorie>>
Sub
<<Sous-systme>>
Figure 118 : Les paquetages peuvent tre strotyps, pour distinguer par exemple les
catgories de la vue logique et les sous-systmes de la vue de ralisation.
12
3 La notation UML 91
Fournisseur
<<Import>>
Client
Figure 120 : Reprsentation des imports entre deux paquetages au moyen dune relation de
dpendance strotype.
Une relation de dpendance entre deux paquetages signifie quau moins une
classe du paquetage client utilise les services offerts par au moins une classe du
paquetage fournisseur. Toutes les classes contenues par un paquetage ne sont
pas ncessairement visibles de lextrieur du paquetage.
Loprateur :: permet de dsigner une classe dfinie dans un contexte diffrent
du contexte courant. Lexpression Zoo::Kangourou dsigne la classe
Kangourou dfinie dans le paquetage Zoo.
Un paquetage est un regroupement dlments de modlisation, mais aussi une
encapsulation de ces lments. A limage des classes, les paquetages possdent
une interface et une ralisation. Chaque lment contenu par un paquetage
possde un paramtre qui signale si llment est visible ou non lextrieur du
paquetage. Les valeurs prises par le paramtre sont : public ou
implementation (priv).
Dans le cas des classes, seules celles indiques comme publiques apparaissent
dans linterface du paquetage qui les contient ; elles peuvent alors tre utilises
par les classes membres des paquetages clients. Les classes de ralisation ne
sont utilisables quau sein du paquetage qui les contient.
Classe
exporte
Fournisseur
Client
Ralisation
Figure 121 : Seules les classes exportes sont visibles lextrieur des paquetages.
P1
P2
3 La notation UML 93
P1
P2
P3
IHM
Mtier
Erreur
global
Persistance
Com
Figure 124 : Afin de rduire la charge graphique, les dpendances envers les paquetages
visibles globalement ne sont pas portes dans les diagrammes.
Instance de
Objet
*
Relie
*
Relation
Relie
Instance de
Diagramme de classes
Lien
Diagramme d'objets
Figure 125 : Extrait du mtamodle. Les diagrammes de classes reprsentent les classes et les
relations.
Les classes
Les classes sont reprsentes par des rectangles compartiments. Le premier
compartiment contient le nom de la classe. Le nom de la classe doit permettre de
comprendre ce que la classe est, et non ce quelle fait. Une classe nest pas une
fonction, une classe est une description abstraite condense dun ensemble
dobjets du domaine de lapplication. Les deux autres compartiments contiennent
respectivement les attributs et les oprations de la classe.
Nom de classe
Une classe contient toujours au moins son nom. Lorsque le nom na pas encore
t trouv, ou nest pas encore arrt, il est conseill de faire figurer un nom
gnrique facile identifier, comme A_Dfinir. Les compartiments dune
classe peuvent tre supprims lorsque leur contenu nest pas pertinent dans le
contexte dun diagramme. La suppression des compartiments reste purement
visuelle, elle ne signifie pas quil ny a pas dattribut ou dopration.
3 La notation UML 95
Nom de classe
Vhicule
<<Utilitaire>>
Etat = test
Auteur = pam
Figure 128 : Les compartiments de classes peuvent contenir un strotype et des proprits,
dfinis librement par lutilisateur.
Figure 129 : Visualisation des attributs et des oprations dans les compartiments de la classe.
Figure 130 : Exemple dattribut driv. La surface dun rectangle peut tre dtermine
partir de la longueur et de la largeur.
3 La notation UML 97
Figure 132 : Reprsentation des diffrents niveaux de visibilit des attributs et des oprations.
Les interfaces
Une interface utilise un type pour dcrire le comportement visible dune classe,
dun composant (dcrits plus loin dans louvrage) ou dun paquetage. Une
interface est un strotype dun type. UML reprsente les interfaces au moyen de
petits cercles relis par un trait llment qui fournit les services dcrits par
linterface.
Figure 133 : Reprsentation dune interface au moyen dun petit cercle reli la classe qui
fournit effectivement les services.
Une classe
<<Interface>>
<<Interface>>
Vue A
Vue B
Un utilisateur
Un autre utilisateur
Une interface fournit une vue totale ou partielle dun ensemble de services offerts
par un ou plusieurs lments. Les dpendants dune interface utilisent tout ou
partie des services dcrits dans linterface.
Classe gnrique
3 La notation UML 99
Elment
Table gnrique
Annuaire<Personne>
Math
Math
Les associations
Les associations reprsentent des relations structurelles entre classes dobjets.
Une association symbolise une information dont la dure de vie nest pas
ngligeable par rapport la dynamique gnrale des objets instances des classes
associes. La plupart des associations sont binaires, cest--dire quelles
connectent deux classes. Les associations se reprsentent en traant une ligne
entre les classes associes.
Figure 138 : Les associations se reprsentent en traant une ligne entre les classes associes.
Les associations peuvent tre reprsentes par des traits rectilignes ou obliques,
selon les prfrences de lutilisateur. Lusage recommande de se tenir le plus
possible un seul style de reprsentation des traits afin de simplifier la lecture
des diagrammes au sein dun projet.
Figure 139 : Les associations peuvent tre reprsentes par des traits rectilignes ou obliques
selon les prfrences de lutilisateur.
mme lien. Dans lexemple suivant, la contrainte est exprime au moyen dun
strotype qui prcise que la classe Cours ralise une association ternaire.
Salle
<<Association ternaire>>
Etudiant
Enseignant
Cours
Dbut
Fin
Figure 141 : Reprsentation dune association ternaire au moyen dune classe avec
strotype.
Comme pour les associations binaires, les extrmits dune association n-aire sont
appeles rles et peuvent porter un nom. La difficult de trouver un nom diffrent
chaque rle dune association n-aire est souvent le signe dune association
darit infrieure.
Nom
Figure 142 : Les associations peuvent tre nommes afin de faciliter la comprhension des
modles.
Travaille pour
Socit
Figure 143 : Nommage dune association par une forme verbale active.
Personne
Socit
Figure 144 : Nommage dune association par une forme verbale passive.
Dans les deux cas, le sens de lecture du nom peut tre prcis au moyen dun
petit triangle dirig vers la classe dsigne par la forme verbale et plac
proximit du nom de lassociation.
Dans un but de simplification, le petit triangle peut tre remplac par les signes <
et > disponibles dans toutes les fontes.
Socit
<Travaille pour
Personne
Figure 146 : Le nommage des rles exprime comment une classe voit une autre classe au
travers dune association. Dans lexemple ci-dessus, la personne voit la socit comme son
employeur, et la socit voit la personne comme son employ.
Le nommage des associations et le nommage des rles ne sont pas exclusifs lun
de lautre ; toutefois, lusage mlange rarement les deux constructions. Il est
frquent de commencer par dcorer une association par un verbe, puis de se
servir plus tard de ce verbe pour construire un substantif verbal qui nomme le rle
qui convient.
Lorsque deux classes sont relies par une seule association, le nom des classes
suffit souvent caractriser le rle ; le nommage des rles prend tout son intrt
lorsque plusieurs associations relient deux classes. Dans ce cas, il ny a aucune
corrlation par dfaut entre les objets qui participent aux deux relations. Chaque
association exprime un concept distinct. Dans lexemple suivant, il ny a pas de
relation entre les passagers et le pilote.
Pilote
Avion
Personne
Passagers
La prsence dun grand nombre dassociations entre deux classes peut tre
suspecte. Chaque association augmente le couplage entre les classes associes
et un fort couplage peut tre le signe dune mauvaise dcomposition. Il est
galement frquent que les dbutants visualisent plusieurs fois la mme
association en nommant chaque association avec le nom dun des messages qui
circulent entre les objets instances des classes associes.
Personne
Conduire
Voiture
Dmarrer
Laver
Arrter
Figure 148 : Exemple de confusion entre association et messages. Une seule association est
suffisante pour permettre une personne de conduire, dmarrer, laver et arrter sa voiture.
Un et un seul
0..1
Zro ou un
M .. N
De M N (entiers
naturels)
De zro plusieurs
0 .. *
De zro plusieurs
1 .. *
D'un plusieurs
Lexemple suivant montre que plusieurs personnes travaillent pour une mme
socit. La multiplicit de valeur 1 du ct de la classe Socit nest pas trs
raliste car elle signifie que toutes les personnes ont un emploi. La multiplicit de
valeur 0..* du ct de la classe Personne signifie quune socit emploie de
zro plusieurs personnes.
0..* Personne
Socit Employeur
1
Employ
Figure 150 : Ce modle supprime le chmage ! Chaque personne travaille pour une socit,
chaque socit emploie de zro plusieurs personnes.
Moteur
1
Figure 151 : La multiplicit dune association est le reflet dune contrainte du domaine.
1
1
*
1 vers 1
1 vers N
N vers N
*
*
Figure 152 : Description gnrique des associations selon les valeurs de multiplicit.
Etudiant
0..*
Ralise >
0..*
Travail
0..*
1
1
Chambre
Note
Numro
Figure 153 : Exemples de placement des attributs selon les valeurs de multiplicit.
note est un attribut de la relation entre la classe des tudiants et la classe des
travaux.
En fin danne, chaque tudiant reoit un diplme avec une mention qui dpend
de la performance individuelle de ltudiant. La relation entre le diplme et
ltudiant est personnalise car un diplme ne concerne quun tudiant donn. La
mention devient un attribut du diplme. La mention nest pas stocke dans
ltudiant pour deux raisons : elle ne qualifie pas un tudiant et un tudiant peut
obtenir plusieurs diplmes. Chaque tudiant possde une chambre et une
chambre nest pas partage par plusieurs tudiants. Lassociation entre les
tudiants et les chambres est du type 1 vers 1. Le numro est un attribut de la
classe Chambre puisquun numro caractrise une chambre.
Personne
1
0..*
{Ordonne}
Figure 154 : La contrainte {Ordonne} indique que la collection des comptes dune
personne est ordonne.
Personne
{Sous-ensemble}
*
Dlgus
Figure 155 : La contrainte {Sous-ensemble} indique que les objets qui participent la
relation Dlgus participent galement la relation Parents dlves.
Personne
{Ou-exclusif}
Etudiants
Les associations peuvent galement relier une classe elle-mme, comme dans le
cas des structures rcursives. Ce type dassociation est appel association
rflexive. Le nommage des rles prend nouveau toute son importance pour
distinguer les instances qui participent la relation. Lexemple suivant montre la
classe des personnes et la relation qui unie les parents et leurs enfants en vie.
Parents
Personne
2
Enfants *
Figure 157 : Toute personne possde de zro deux parents, et de zro plusieurs enfants. Le
nommage des rles est essentiel la clart du diagramme.
Les classes-associations
Une association peut tre reprsente par une classe pour ajouter, par exemple,
des attributs et des oprations dans lassociation. Une classe de ce type, appele
parfois classe associative ou classe-association, est une classe comme les autres
et peut ce titre participer dautres relations dans le modle. La notation utilise
une ligne pointille pour attacher une classe une association. Dans lexemple
suivant, lassociation entre les classes A et B est reprsente par la classe C, qui
elle-mme est associe la classe D.
A
C
attributs
oprations( )
Une association qui contient des attributs sans participer des relations avec
dautres classes est appele association attribue. Dans ce cas, la classe
rattache lassociation ne porte pas de nom spcifique.
Etudiant
Ralise >
Travail
Note
Cl
Figure 160 : Restriction dune association, au moyen dun attribut particulier appel cl.
Figure 161 : Une restriction rduit le nom bre dinstances qui participent une association.
La restriction dune association peut tre opre en combinant les valeurs des
diffrents attributs qui forment la cl.
Echiquier
Ligne
Colonne
Case
1
Figure 162 : Combinaison dune ligne et dune colonne pour identifier une case de
lchiquier.
Les agrgations
Une agrgation reprsente une association non symtrique dans laquelle une des
extrmits joue un rle prdominant par rapport lautre extrmit. Quelle que soit
larit lagrgation ne concerne quun seul rle dune association.
Lagrgation se reprsente en ajoutant un petit losange du ct de lagrgat.
A
Une agrgation
les valeurs dattributs dune classe se propagent dans les valeurs dattributs
dune autre classe ;
une action sur une classe implique une action sur une autre classe ;
les objets dune classe sont subordonns aux objets dune autre classe.
Linverse nest pas toujours vrai : lagrgation nimplique pas ncessairement les
critres voqus plus haut. Dans le doute, les associations sont prfrables. De
manire gnrale, il faut toujours choisir la solution qui implique le couplage le
plus faible.
Les agrgations peuvent tre multiples, comme les associations. Tant quaucun
choix de ralisation na t effectu, il ny a aucune contrainte particulire sur les
valeurs de multiplicit que peuvent porter les rles dune agrgation. Cela
signifie, en particulier, que la multiplicit du ct de lagrgat peut tre suprieure
1. Ce type dagrgation correspond par exemple au concept de copropritaire.
Le diagramme suivant montre que des personnes peuvent tre copropritaires des
mmes immeubles.
Propritaire
Personne
1..*
Immeuble
0..*
La composition
Les attributs constituent un cas particulier dagrgation ralise par valeur : ils
sont physiquement contenus par lagrgat. Cette forme dagrgation est appele
composition, et se reprsente dans les diagrammes par un losange de couleur
noire.
La composition implique une contrainte sur la valeur de la multiplicit du ct de
lagrgat : elle ne peut prendre que les valeurs 0 ou 1. La valeur 0 du ct du
composant correspond un attribut non renseign.
Agrgat
0..1
Composant
*
<=>
Voiture
Cylindre
Moteur
...
Carburateur
Figure 166 : Une agrgation par valeur est smantiquement quivalente un attribut ; elle
permet de montrer comment un attribut participe dautres relations dans le modle.
La navigation
Les associations dcrivent le rseau de relations structurelles qui existent entre
les classes et qui donnent naissance aux liens entre les objets, instances de ces
classes. Les liens peuvent tre vus comme des canaux de navigation entre les
objets. Ces canaux permettent de se dplacer dans le modle et de raliser les
formes de collaboration qui correspondent aux diffrents scnarios.
Par dfaut, les associations sont navigables dans les deux directions. Dans
certains cas, seule une direction de navigation est utile ; ceci se reprsente par
une flche porte par le rle vers lequel la navigation est possible. Labsence de
flche signifie que lassociation est navigable dans les deux sens. Dans lexemple
suivant, les objets instances de A voient les objets instances de B, mais les objets
instances de B ne voient pas les objets instances de A.
A
Figure 167 : Lassociation entre les classes A et B est uniquement navigable de A vers B.
Une association navigable uniquement dans un sens peut tre vue comme une
demi-association. Cette distinction est souvent ralise pendant la conception,
mais peut trs bien apparatre en analyse, lorsque ltude du domaine rvle une
dissymtrie des besoins de communication.
Expressions de navigation
UML dfinit un pseudo-langage pour reprsenter les chemins au sein des
diagrammes de classes. Ce langage trs simple dfinit des expressions qui servent
par exemple prciser des contraintes.
La partie gauche de lexpression dsigne un ensemble dobjets, ventuellement
rduit un singleton. Un nom de classe dsigne lensemble des objets instances
de la classe.
La syntaxe des expressions de navigation est donne par les quatre rgles
suivantes :
Dans le cas dune association, lexpression retourne une collection dobjets qui
contient le nombre dlments spcifis par la multiplicit du rle. Lexpression
UnePersonne.Enfants dsigne toutes les enfants dune personne donne.
Personne
Parents
2
Enfants *
Lexpression boolenne est construite partir des objets contenus par lensemble
et partir des liens et valeurs accessibles par ces objets. La cible est un ensemble
dobjets qui vrifient lexpression. La cible est un sous-ensemble de lensemble
de dpart.
Dans lexemple prcdent, lexpression boolenne UnePersonne.Enfants
[ge>=18ans] dsigne tous les enfants majeurs dune personne donne.
cible ::=
ensemble . slecteur [ valeur_de_cl ]
Personne
Parent
Prnom
1
Mre/Pre
Enfant
0..1
Figure 169 : Les valeurs de cls peuvent galement tre utilises dans les expressions de
navigation.
ou enfin, en posant :
{papa = UnePersonne.Parent[Pre]}
et
{papi = UnePersonne.(Parent[Pre] ou
Parent[Mre]).Parent[Pre]}
alors
{papi.Parent[Pre] =
papa.Parent[Pre].Parent[Pre]}
ce qui revient dire, comme chacun sait, que le papa de papi est le papi de papa !
La gnralisation
UML emploie le terme gnralisation pour dsigner la relation de classification
entre un lment plus gnral et un lment plus spcifique. En fait, le terme
gnralisation dsigne un point de vue port sur un arbre de classification. Par
exemple, un animal est un concept plus gnral quun chat, un chien ou un raton
laveur. Inversement, un chat est un concept plus spcialis quun animal.
Llment plus spcifique peut contenir des informations qui lui sont propres,
condition de rester totalement cohrent avec la description de llment plus
gnral. La gnralisation sapplique principalement aux classes, aux paquetages
et aux cas dutilisation.
Dans le cas des classes, la relation de gnralisation exprime le fait que les
lments dune classe sont aussi dcrits par une autre classe (en fait par le type
dune autre classe). La relation de gnralisation signifie est un ou est une sorte
de. Un chat est un animal, il sagit de gnralisation. Un chat a deux oreilles, il ne
sagit pas de gnralisation, mais de composition.
La relation de gnralisation se reprsente au moyen d'une flche qui pointe de la
classe plus spcialise vers la classe plus gnrale. La tte de la flche est ralise
par un petit triangle vide, ce qui permet de la distinguer dune flche ouverte,
symbole de la proprit de navigation des associations. Dans lexemple suivant,
la classe Animal est une abstraction des classes Chat, Chien et Raton
laveur.
Animal
Chat
Chien
Raton laveur
Les attributs, les oprations, les relations et les contraintes dfinies dans les
super-classes sont hrits intgralement dans les sous-classes. En
programmation, la relation de gnralisation est trs souvent ralise en utilisant
la relation dhritage entre classes, propos par les langages objet. Lhritage est
une manire de raliser la classification, mais ce nest pas la seule. La relation de
gnralisation dfinie par UML est plus abstraite que la relation dhritage telle
quelle existe dans les langages de programmation objet comme C++. Lhritage
est une relation statique ; elle induit un couplage trs fort entre classes, et se
rvle peu adapte la notion de classification dynamique ou la notion de
mtamorphose. En analyse, il vaut mieux parler de gnralisation ou de
classification, et se proccuper plus tard, lors de la conception, de la manire de
raliser la gnralisation.
Les classes peuvent avoir plusieurs super-classes ; dans ce cas, la gnralisation
est dite multiple et plusieurs flches partent de la sous-classe vers les diffrentes
super-classes. La gnralisation multiple consiste fusionner plusieurs classes
en une seule classe. Les super-classes nont pas ncessairement un anctre
commun. Dans lexemple suivant, la classe Tapis volant possde deux
anctres compltement disjoints, les classes Tapis et Vhicule. La forme de
gnralisation qui regroupe les classes Vhicule, Vhicule
terrestre13, Vhicule Arien et Tapis volant, est appele
gnralisation en diamant ou en losange.
13
Pour se convaincre que les tapis sont bien des vhicules terrestres, il suffit
dobserver mes enfants...
Vhicule
Tapis
Terrestre
Arien
Tapis volant
Une classe peut tre spcialise selon plusieurs critres simultanment. Chaque
critre de la gnralisation est indique dans le diagramme en associant un
discriminant la relation de gnralisation. Lorsque les flches sont agrges, le
discriminant napparat quune seule fois. Labsence de discriminant est
considre comme un cas particulier de gnralisation.
Vhicule
Motorisation
A voile
A moteur
Milieu
Terrestre
Marin
Champignon
{Exclusif}
Agaricus
Boletus
Pas de
mlange des
dimensions
Pied bleu
Bolet de loup
Motorisation
A voile
{Inclusif}
A moteur
Milieu
Terrestre
Ptrolette
Marin
Mlange
des deux
dimensions
{Incomplte}
Maths
Franais
Go
Figure 176 : La contrainte {Incomplte} signale quil peut exister dautres cours ; la
classification est extensible.
Maths
...
Go
Figure 177 : Exemple de vue incomplte. Les points dlision caractrisent la vue et non le
modle.
Introduction au mtamodle
De nombreux lments de modlisation prsentent une dichotomie commune
(essence, manifestation), par laquelle un type reprsente lessence
dune abstraction et linstance fournit une manifestation concrte. Il existe
galement une dichotomie (spcification, ralisation) par laquelle
des classes et des types primitifs ralisent des types.
Un type spcifie un domaine de valeurs et un ensemble d'oprations applicables
ces valeurs. Une classe ralise un type : elle fournit la reprsentation des attributs
et la ralisation des oprations (les mthodes). Cette distinction se propage avec
les sous-classes de sorte que la spcification donne par un type est valable pour
toutes les sous-classes et qu'une sous-classe peut raliser plusieurs types.
Le diagramme de classes ci-dessous reprsente la dichotomie (essence,
manifestation) et la dichotomie (spcification, ralisation).
Elment de modlisation
Instance
Type
Instance de >
0..*
Domaine de dfinition
0..1 Oprations
Dichotomie
(essence, manifestation)
Dichotomie
(spcification,
ralisation)
Ralise
Mthode
Classe
0..*
Figure 179 : Extrait du mtamodle. Une instance manifeste un type, une classe ralise un
type.
le type primitif qui correspond un type qui n'est pas ralis par une classe,
comme les entiers ou les types numrs,
le cas d'utilisation qui est une squence d'actions effectues par un acteur et
un systme.
Type
Type de base
Classe
Cas d'utilisation
le nud qui est un dispositif physique sur lequel des composants peuvent
tre dploys pour leur excution.
Classe
Classe active
Signal
Composant
< Dploie
0..*
Noeud
0..*
Les relations
UML dfinit cinq sortes de relations. La plus gnrale est appele relation de
dpendance et sapplique de manire uniforme tous les lments de
modlisation. Lassociation et la gnralisation concernent tous les types, en
particulier les classes et les cas dutilisation. Les deux dernires, les transitions et
les liens, sappliquent certains lments de modlisation du comportement.
Ce paragraphe se limite la description des relations statiques entre classes,
prsentes dans le diagramme suivant. Les liens et les transitions sont prsents
plus loin dans ce chapitre.
Relation
Association
Gnralisation
Dpendance
Lassociation
L'association spcifie une connexion smantique bidirectionnelle entre types. Une
association possde au moins deux rles qui dcrivent la part prise par les types
participant l'association.
Association
1
{ordonne}
2..*
Rle
0..*
multiplicit : Multiplicit
0..1
navigable : Boolen
agrgat : Boolen
changeable : Boolen
ordonne : Boolen
Participant
Cl de filtrage 0..*
Type
Attribut
Agrgat. Spcifie si les instances du type associ au rle sont le tout dans
une relation du genre (tout, parties). Seul un des rles d'une
association peut possder un attribut d'agrgation positionn Vrai. Si, de
plus, la multiplicit de ce rle vaut 1, alors le tout possde les parties et la
destruction du tout entrane la destruction des parties. Si la multiplicit est
suprieure 1, plusieurs instances jouent le rle du tout et partagent les
parties ; la destruction dune des instances du tout n'entrane pas la
La gnralisation
La gnralisation spcifie une relation de classification par laquelle une instance
d'un sous-type peut tre substitue une instance d'un super-type. Un supertype peut avoir plusieurs sous-types et un sous-type peut avoir plusieurs supertypes.
Gnralisation
Super-type
Sous-type
0..*
0..* {ordonne}
Elment gnralisable
Abstrait : Boolen
Feuille : Boolen
Racine : Boolen
Strotype
Paquetage
Type
Feuille. La valeur Vrai prcise que l'lment ne peut avoir des sous-types.
Racine. La valeur Vrai prcise que l'lment ne peut avoir des super-types.
La dpendance
La dpendance est une relation d'utilisation unidirectionnelle entre lments (de
modlisation et de visualisation). La relation de dpendance relie des lments au
sein d'un mme modle.
Dpendance
0..*
Cible
Elment 0..*
Source
{ La cible et la source
appartiennent au
mme modle}
UML dfinit galement une relation de trace entre lments qui appartiennent
des modles diffrents. La trace faciliter peut servir notamment reprsenter
lhistoire des constructions prsentes dans les diffrents modles. Cette relation
de trace est une relation de dpendance strotype.
Dpendance
0..* Elment
0..*
Cible
Source
{ La cible et la source
appartiennent au
mme modle}
Strotype
Trace
{ La cible et la source
n'appartiennent pas
ncessairement au
mme modle}
Figure 186 : Extrait du mtamodle. La relation de trace est une relation de dpendance
strotype.
Figure 187 : Les cas dutilisation partitionnent lensemble des besoins dun systme.
Le formalisme des cas dutilisation bas sur le langage naturel est accessible
sans formation particulire des utilisateurs, qui peuvent ainsi exprimer leurs
attentes et leurs besoins en communiquant facilement avec les experts du
domaine et les informaticiens. La terminologie employe dans la rdaction des cas
dutilisation est celle employe par les utilisateurs dans leur vie de tous les jours,
de sorte que lexpression des besoins sen trouve grandement facilite. Les
informaticiens, quant eux, sont constamment ramens par les cas dutilisation
vers les proccupations premires des utilisateurs ; ils vitent ainsi de driver
vers des constructions techniquement sduisantes, mais pas forcment
Cas d'utilisation X
Acteur A
Acteur B
Cas d'utilisation Y
Un acteur reprsente un rle jou par une personne ou une chose qui interagit
avec un systme. Les acteurs se dterminent en observant les utilisateurs directs
du systme, ceux qui sont responsables de son exploitation ou de sa
maintenance, ainsi que les autres systmes qui interagissent avec le systme en
question. La mme personne physique peut jouer le rle de plusieurs acteurs
(vendeur, client). Dautre part, plusieurs personnes peuvent jouer le mme rle, et
donc agir comme le mme acteur (tous les clients). Le nom de lacteur dcrit le rle
jou par lacteur.
Dans lexemple suivant, Monsieur Schmoldu, garagiste de son tat, passe le plus
clair de son temps dans le rle du mcanicien, mais peut loccasion jouer le rle
Conduire
Client
Entretenir
Rparer
Vendeur
Mcanicien
Vendre
Figure 189 : Une mme personne physique peut jouer le rle de plusieurs acteurs.
Les candidats acteurs se recrutent parmi les utilisateurs, les clients, les
partenaires, les fournisseurs, les vendeurs, les autres systmes, en rsum, les
personnes et les choses extrieures a un systme qui interagissent avec lui en
changeant de linformation (en entre et en sortie). La dtermination des acteurs
permet de prciser les limites du systme de manire progressive : floues au
dpart, elles se prcisent au fur et mesure de llaboration des diffrents cas
dutilisation. Cette activit de dlimitation est extrmement importante car elle sert
de base contractuelle o est signal ce qui doit tre fait, ce qui fait partie du
systme dvelopper et ce qui nen fait pas partie. Elle prcise galement les
lments intangibles, que lquipe de dveloppement ne peut pas modifier.
Il existe quatre grandes catgories dacteurs :
Les acteurs principaux. Cette catgorie regroupe les personnes qui utilisent
les fonctions principales du systme. Dans le cas dun distributeur de billets,
il sagit des clients.
Les autres systmes. Cette catgorie regroupe les systmes avec lesquels le
systme doit interagir. Dans le cas dun distributeur de billet, le systme du
groupement bancaire qui gre un parc de distributeurs apparat comme un
acteur.
Une fois identifis, les acteurs doivent tre dcrits dune manire claire et concise,
en trois ou quatre lignes maximum. Lorsquil y a beaucoup dacteurs dans un
systme, il est conseill de les regrouper par catgories afin de faciliter la
navigation dans le modle des cas dutilisation.
Les cas dutilisation se dterminent en observant et en prcisant, acteur par
acteur, les squences dinteraction les scnarios du point de vue de
lutilisateur. Ils se dcrivent en termes dinformations changes et dtapes dans
la manire dutiliser le systme. Un cas dutilisation regroupe une famille de
scnarios dutilisation selon un critre fonctionnel. Les cas dutilisation sont des
abstractions du dialogue entre les acteurs et le systme : ils dcrivent des
interactions potentielles, sans entrer dans les dtails de chaque scnario.
Les cas dutilisation doivent tre vus comme des classes dont les instances sont
les scnarios. Chaque fois quun acteur interagit avec le systme, le cas
dutilisation instancie un scnario ; ce scnario correspond au flot de messages
changs par les objets durant linteraction particulire qui correspond au
scnario. Lanalyse des besoins par les cas dutilisation saccommode trs bien
dune approche itrative et incrmentale.
La porte des cas dutilisation dpasse largement la dfinition des seuls besoins
du systme. En effet, les cas dutilisation interviennent tout au long du cycle de
vie, depuis le cahier des charges jusquaux tests, en passant par lanalyse, la
conception, la ralisation et la rdaction de la documentation pour lutilisateur. De
ce point de vue, il est possible de naviguer vers les classes et les objets qui
collaborent pour satisfaire un besoin, puis vers les tests qui vrifient que le
systme sacquitte correctement de sa tche.
Utilisateur
Exprime
Comprend Analyste
Cas d'utilisation
Ralise
Conoit
Vrifie
Programmeur
Testeur
Architecte
Figure 190 : Les cas dutilisation servent de fil conducteur pour lensemble du projet.
<<Utilise>>
Cas d'utilisation B
Cas d'utilisation A
Cas d'utilisation B
Cas d'utilisation A
Virement
par minitel
<<Etend>>
Client distant
Client local
<<Utilise>>
Virement
Identification
Figure 194 : Exemple de mise en uvre des diffrentes relations entre cas dutilisation.
Les cas dutilisation peuvent tre prsents aux travers de vues multiples : un
acteur avec tous ses cas dutilisation, un cas dutilisation avec tous ses acteurs,
etc.
Les cas dutilisation peuvent galement tre groups selon leurs squences de
dclenchement types, cest--dire en fonction de leurs enchanements, ou encore
en fonction des diffrents points de vue, souvent corrls aux grandes catgories
dacteurs (client, fournisseur, maintenance...).
Ltape suivante consiste classer les cas dutilisation selon leur acuit par
rapport lactivit de la socit, leur intrt pour les clients, la nature des risques,
la simplicit de leur mise en uvre ou leur impact sur les processus dj en place.
la fin du cas dutilisation, autrement dit lvnement qui cause larrt du cas
dutilisation ; il doit tre clairement identifi et document par la phrase :
Quand Y se produit, le cas dutilisation est termin. ;
ou
pendant que
-- autre chose
fin pendant
choix X
b)
choix Y
c)
choix Z
Lorsquun cas dutilisation devient trop complexe (plus de dix pages par exemple),
il est possible de le dcouper en cas dutilisation plus petits. Cette opration nest
toutefois effectue que lorsque les cas dutilisation ont t dcrits en dtail, aprs
examen des principaux scnarios.
Figure 195 : Un cas dutilisation dcrit (de manire abstraite) une famille de scnarios.
existe-t-il une brve description qui donne une vraie image du cas
dutilisation ?
les mmes termes employs dans des cas dutilisation diffrents ont-ils bien la
mme signification ?
est-ce que toutes les alternatives sont prises en compte par le cas
dutilisation ?
est-ce que tous les besoins identifis de manire informelle ont t allous
un cas dutilisation ?
existe-t-il des cas dutilisation qui ne sont pas rfrencs par des besoins
informels ?
Figure 196 : La transition vers lobjet est effectue en ralisant un cas dutilisation par une
collaboration.
La ralisation dun cas dutilisation par une collaboration est un instant crucial de
la modlisation ; cest le moment du virage vers lobjet. Une dcomposition qui
suit directement la forme des cas dutilisation conduit une approche structure
classique, avec tous les dfauts des structures calques sur les fonctions.
Une approche objet ralise un cas dutilisation au moyen dune collaboration
entre objets. Les scnarios, instances du cas dutilisation, sont reprsents par
des diagrammes dinteraction (diagrammes de collaboration et diagrammes de
squence).
La figure suivante illustre le choix de dcomposition aprs ltude des cas
dutilisation.
Cas 1
<<Utilise>>
Cas 2
Cas 3
Figure 197 : Reprsentation du virage vers lobjet aprs une tude des cas dutilisation.
Nom de l'objet
: Classe
Figure 198 : Reprsentations graphiques dun objet ; le nom ou la classe de lobjet peuvent
tre supprims du diagramme.
Le nom de la classe peut contenir le chemin complet, compos partir des noms
des diffrents paquetages englobants spars par des doubles deux points,
comme dans lexemple suivant :
BoutonOK : IHM::Contrles::BoutonPoussoir
Figure 201 : Exemple dobjet anonyme de la classe Voiture, muni dun attribut
Couleur dont la valeur est rouge.
: Roue
: Roue
: Moteur
: Roue
: Roue
Voiture
1
1
4
Roue
Les liens instances des associations rflexives peuvent relier un objet lui-mme.
Dans ce cas, le lien est reprsent par une boucle attache un seul objet. Le
diagramme suivant reprsente deux liens, instances de la mme association
Collaborateur
Personne
Patron
Etienne : Personne
Patron
Patron
Denis : Personne
Jean-Luc : Personne
Figure 204 : Exemple de liens instances dune relation rflexive. Etienne est le patron de
Jean-Luc, Denis est son propre patron.
La plupart des liens sont binaires. Il existe toutefois certains liens darit
suprieure, par exemple ceux qui correspondent aux relations ternaires. La
reprsentation des liens ternaires peut se combiner avec les autres lments de la
notation : le diagramme suivant reprsente une famille de liens ternaires, instances
dune association ternaire de multiplicit N du ct de la classe Etudiant. Cette
notation prsente lavantage de lever les ambiguts inhrentes la
reprsentation de la multiplicit des associations darit suprieure 2.
: Partie
: Partie
Fentre
Ascenseur
1
1
1
Zone de dessin
Figure 207 : Exemple dune classe composite Fentre qui contient une zone de dessin et
deux ascenseurs.
: Zone de dessin
: Ascenseur
: Ascenseur
Figure 208 : Reprsentation dun objet composite, instance de la classe composite dcrite
dans le diagramme prcdent.
Passagers
: Personne
: Bus
Conducteur
: Personne
: Destination
Les valeurs des cls de restriction des associations peuvent galement tre
rajoutes dans les diagrammes dobjets. Le diagramme suivant reprsente les
liens de parent entre Lara, Jonathan, Roxane, Anne et Pierre-Alain.
Figure 210 : Exemple de reprsentation des valeurs des cls de restriction des associations.
Une interaction est ralise par un groupe dobjets qui collaborent en changeant
des messages. Ces messages sont reprsents le long des liens qui relient les
objets, au moyen de flches orientes vers le destinataire du message.
Le diagramme suivant reprsente une cabine dascenseur qui demande une
porte de souvrir.
: Cabine
Ouvrir
: Porte
Figure 211 : Exemple dinteraction entre deux objets. La cabine demande la porte de
souvrir.
3: Fermer
2: Allumer
: Porte
: Lumire
Destruction
A
B
{local}
Copie de B
Figure 213 : Reprsentation dune interaction entre trois objets. Lobjet B a t copi
localement par lobjet A, dans le but de permettre lannulation ventuelle de la destruction de
B.
Les objets et les liens crs ou dtruits au cours dune interaction peuvent
respectivement porter les contraintes {nouveau} ou {dtruit}. Les objets
crs, puis dtruits au sein de la mme interaction, sont identifis par la contrainte
{transitoire}.
B
{nouveau}
A
D
{dtruit}
C
{transitoire}
: Instituteur
Instituteur
Elve
1
: Elve
*[tous] : Debout
Figure 215 : Reprsentation condense dune famille de liens, instances dune mme
association.
La place de lutilisateur
La notation permet de faire figurer un acteur dans un diagramme de collaboration
afin de reprsenter le dclenchement des interactions par un lment externe au
systme. Grce cet artifice, linteraction peut tre dcrite de manire plus
abstraite, sans entrer dans les dtails des objets de linterface utilisateur. Le
premier message de linteraction est envoy par lacteur, reprsent soit par le
symbole graphique des acteurs du modle des cas dutilisation, soit par un objet
muni dun strotype qui prcise sa qualit dacteur. Le diagramme suivant
montre un fragment dinteraction ; elle correspond un appel de cabine
dascenseur par une personne.
1: Venir me chercher au RDC
: Personne
: Cabine
: Ascenseur
Figure 217 : Reprsentation des objets actifs. Le cadre des objets actifs est plus pais que
celui des objets passifs.
Synchronisation
Le point de synchronisation dun message est exprim sous la forme dune
squence denvoi de message, termine par le caractre /. Tous les messages
rfrencs dans cette liste doivent avoir t envoys pour valider lenvoi du
message courant.
La syntaxe dun point de synchronisation prend la forme suivante :
synchronisation ::= rang {, synchronisation} /
rang ::= [entier | nom de flot dexcution]{. rang}
Lentier reprsente le rang de lenvoi de message au sein de lembotement
englobant. Le nom identifie un flot dexcution parallle au sein dun
embotement. Ainsi, lenvoi de message 3.1.3 suit immdiatement lenvoi
3.1.2 au sein de lembotement 3.1, alors que lenvoi 3.1.a est effectu
simultanment lenvoi 3.1.b.
Dans lexemple suivant, le message Message est envoy lorsque les envois A.1
et B.3 ont t satisfaits.
A.1, B.3 / Message
Squence
La squence indique le niveau dembotement de lenvoi de message au sein de
linteraction. La squence est constitue dune suite de termes spars par des
points. Chaque squence possde la syntaxe suivante :
:X
[X>Y] : Message
A
Rsultat
Le rsultat est constitu dune liste de valeurs retournes par le message. Ces
valeurs peuvent tre utilises comme paramtres des autres messages compris
dans linteraction. Ce champ nexiste pas en labsence de valeurs retournes. Le
format de ce champ est libre :
p := Question
A
Nom
Il sagit du nom du message. Souvent ce nom correspond une opration dfinie
dans la classe de lobjet destinataire du message.
Arguments
Il sagit de la liste des paramtres du message. Les arguments et le nom du
message identifient de manire unique laction qui doit tre dclenche dans
lobjet destinataire. Les arguments peuvent contenir des valeurs retournes par
des messages envoys prcdemment, ainsi que des expressions de navigation
construites partir de lobjet source.
Les expressions suivantes donnent quelques exemples de la syntaxe denvoi des
messages :
4 : Afficher (x, y) -- message simple
3.3.1 : Afficher (x, y) -- message imbriqu
4.2 : ge := Soustraire (Aujourdhui,
DateDeNaissance)
-- message imbriqu avec valeur retourne
[Age >= 18 ans] 6.2 : Voter () - message
conditionnel
4.a, b.6 / c.1 : Allumer (Lampe) synchronisation avec dautres flots dexcution
1 * : Laver () - itration
3.a, 3.b / 4 *||[i := 1..n] : Eteindre () itration parallle
Les arguments des messages sont reprsents dans les diagrammes, soit en
utilisant du pseudo-code, soit directement dans la syntaxe du langage de
programmation. La notation propose galement une reprsentation graphique des
arguments sous la forme de flches termines par de petits cercles. Le diagramme
suivant donne un exemple de reprsentation graphique des arguments dun
message.
Message
Argument
Argument
Figure 222 : Reprsentation graphique des arguments dun message au moyen de flches
termines par de petits cercles.
Introduction au mtamodle
Les collaborations
Une collaboration est un mcanisme compos dlments structurels et
comportementaux. Les collaborations fournissent un mcanisme dorganisation,
mais possdent, contrairement aux paquetages, une identit et une porte
smantique. Un mme lment peut intervenir dans plusieurs collaborations.
Une collaboration englobe deux genres de construction : un contexte compos
d'une description de la structure statique des objets concerns et une interaction
reprsente par une squence de messages changs par les dits objets. Les deux
aspects sont requis pour pleinement documenter le comportement, mais chaque
aspect peut tre visualis indpendamment.
Les collaborations s'emploient, selon leur niveau de dtail, pour dcrire des
spcifications et pour exprimer des ralisations. Le tableau suivant rsume les
lments de modlisation qui peuvent tre dcrits par une collaboration.
Spcification
Type
Opration
Cas dutilisation
Ralisation
Classe
Mthode
Figure 223 : Tableau rcapitulatif des lments de modlisation qui peuvent tre dcrits par
des collaborations.
Type
0..1
Reprsente
Opration
{Ou}
*
Comportement
0..1
Reprsente
*
*
0..1
Collaboration
Modle : Boolen
*
*
Type
*
*
Relation
*
*
Contrainte
*
Note
*
Instance
Les interactions
Une interaction exprime le comportement qui rsulte de la collaboration dun
groupe dinstances. Une interaction peut tre visualise selon le point de vue du
temps (par les diagrammes de squence) ou selon le point de vue de lespace (par
les diagrammes de collaboration). Les interactions comprennent principalement
les lments suivants :
les liens qui relient les instances et servent de support pour les envois de
message,
15
Comportement
0..1
0..*
Relation
Collaboration
0..1 Interaction
0..*
0..*
Instance
Lien
0..*
Association
0..1
1
0..* 2..*
Participant
Message
Rle
0..*
16
vertical peut tre gradu afin dexprimer prcisment les contraintes temporelles,
dans le cas par exemple de la modlisation dun systme temps rel.
Un objet
Un autre objet
Encore un objet
Un message
Un autre message
Ligne
tlphonique
Appel
Dcroche
Tonalit
Numrotation
Indication de sonnerie
Sonnerie
Dcroche
All
les envois synchrones pour lesquels lmetteur est bloqu et attend que
lappel ait fini de traiter le message,
les envois asynchrones pour lesquels lmetteur nest pas bloqu et peut
continuer son excution.
Message synchrone
Message asynchrone
Un autre objet
Un message
Un objet
Message
rflexif
Composant a Composant b
Point d'entre
Figure 232 : Utilisation dun message rflexif comme point dentre dune interaction
interne.
Un objet
Crer
Un autre objet
Dtruire
Figure 234 : Reprsentation de la priode dactivit dun objet au moyen dune bande
rectangulaire superpose la ligne de vie de lobjet.
Le diagramme suivant montre le cas dun objet A qui active un autre objet B. La
priode dactivit de lobjet A recouvre la priode dactivit de lobjet B. Dans le
cas dun appel de procdure, le flot dexcution est pass par lobjet A lobjet B.
Lobjet A est alors bloqu jusqu' ce que lobjet B lui redonne la main.
Dans le cas dun appel de procdure, et plus gnralement dans le cas des envois
synchrones, le retour en fin dexcution de lopration est implicite : il nest pas
ncessaire de le reprsenter dans les diagrammes. Lobjet A reprend son
excution lorsque laction dclenche dans lobjet B est termine.
A
Retour
implicite
Figure 236 : Dans le cas des envois synchrones, le retour est implicite en fin dactivit et ne
ncessite pas de reprsentation particulire.
En revanche, dans le cas des envois asynchrones, le retour doit tre matrialis
lorsquil existe. Le diagramme suivant montre un objet B initialement activ par un
objet A, qui retourne un message lobjet A avant de cesser son excution. Il faut
noter que la fin de lactivation dun objet ne correspond pas la fin de sa vie. Un
mme objet peut tre activ de nombreuses fois au cours de son existence.
X
Retour
explicite
Retour
explicite
avant suicide
Figure 237 : Reprsentation explicite du retour dans le cas des envois asynchrones. La lettre
X symbolise une fin dactivit qui correspond galement une fin de vie.
Rcursion
Structures de contrle
Les formes des diagrammes de squence refltent indirectement les choix de
structure. Les deux diagrammes suivants prsentent respectivement un mode de
contrle centralis et un mode dcentralis.
Contrle dcentralis
Contrle centralis
Figure 239 : La forme des diagrammes de squence est le reflet du mode de contrle de
linteraction.
Message
{y-x < 3 s}
y
{z-y < 1 s}
Message
Message
z
t
Message
{t'-t < 2 s}
t'
B
Message
end loop
*[X] Message
Message
If X
else
Message
end if
[X] Message
[non X] Message
B
[X]
Message
[Y]
Les automates
Le comportement des objets dune classe peut tre dcrit de manire formelle en
termes dtats et dvnements, au moyen dun automate reli la classe
considre.
Classe
Automate
1
0..1
Les objets qui ne prsentent pas un comportement ractif trs marqu peuvent
tre considrs comme des objets qui restent toujours dans le mme tat : leurs
classes ne possdent alors pas dautomate.
Le formalisme retenu par UML pour reprsenter les automates sinspire des
Statecharts17. Il sagit dautomates hirarchiques, possdant les concepts
dorthogonalit, dagrgation et de gnralisation (ces notions sont dfinies plus
loin dans le chapitre).
17
Orange
Vert
Figure 247 : De manire gnrale, tous les feux tricolores sont soit ltat rouge, soit ltat
orange, soit ltat vert.
Il est bien vident quil faut synchroniser ltat des feux qui se trouvent placs
autour du mme carrefour. Cette synchronisation, qui dpend de ltat du
carrefour, peut aussi tre dcrite dans un automate associ la classe des
carrefours.
Les tats
Chaque objet est un moment donn dans un tat particulier. Les tats se
reprsentent sous la forme de rectangles arrondis ; un chaque tat possde un
nom qui lidentifie.
Un tat
Un autre tat
Figure 248 : Les tats se reprsentent au moyen de rectangles arrondis. Chaque tat possde
un nom qui doit tre unique dans une porte lexicale donne.
Personne
0..1
1..* Age
Figure 250 : Une personne peut tre soit en activit, soit au chmage, soit la retraite.
ge de la personne,
Toto
Age : 30 ans
Titi
: Socit
Age : 40 ans
Ernest
Age : 75 ans
Figure 251 : Ltat des trois personnes est diffrent. Toto est au chmage, Titi en activit et
Ernest la retraite.
Les automates retenus par UML sont dterministes. Un diagramme dtatstransitions ne doit pas laisser de place aux constructions ambigus. Cela signifie
en particulier quil faut toujours dcrire ltat initial du systme. Pour un niveau
hirarchique donn, il y a toujours un et un seul tat initial. En revanche, il est
possible davoir plusieurs tats finaux qui correspondent chacun une condition
de fin diffrente. Il est galement possible de navoir aucun tat final, dans le cas
par exemple dun systme qui ne sarrte jamais.
Ltat initial se reprsente par un gros point noir. Un tat final se reprsente par
un gros point noir encercl.
Etat intermdiaire
Etat initial
Etat final
Figure 252 : Ltat initial est reprsent par un point noir. Un tat final est reprsent par un
point noir encercl.
Les transitions
Lorsque les conditions dynamiques voluent, les objets changent dtat en
suivant les rgles dcrites dans lautomate associ leurs classes. Les
diagrammes dtats-transitions sont des graphes dirigs. Les tats sont relis par
des connexions unidirectionnelles, appeles transitions. Le passage dun tat
lautre seffectue lorsquune transition est dclenche par un vnement qui
survient dans le domaine du problme. Le passage dun tat un autre est
instantan car le systme doit toujours tre dans un tat connu.
Figure 253 : Une transition permet de passer dun tat un autre tat ; elle se reprsente au
moyen dune flche qui pointe de ltat de dpart vers ltat darrive.
Figure 254 : Exemple de transition dun tat vers lui-mme dans un fragment dautomate
lexical.
Les vnements
Un vnement correspond loccurrence dune situation donne dans le domaine
du problme. Contrairement aux tats qui durent, un vnement est par nature une
information instantane qui doit tre traite sans plus attendre. Un vnement
sert de dclencheur pour passer dun tat un autre. Les transitions indiquent les
chemins dans le graphe des tats. Les vnements dterminent quels chemins
doivent tre suivis. Les vnements, les transitions et les tats sont
indissociables dans la description du comportement dynamique. Un objet, plac
dans un tat donn, attend loccurrence dun vnement pour passer dans un
autre tat. De ce point de vue, les objets se comportent comme des lments
passifs, contrls par les vnements en provenance du systme.
A
Evnement
le nom de lvnement,
lobjet expditeur,
lobjet destinataire,
En activit
Perte d'emploi
A la retraite
Embauche
Au chmage
Plus de 60 ans
Un autre objet
Un objet
Un autre objet
Un objet
La rponse
Figure 258 : Les besoins de communication par vnements synchrones peuvent se raliser
au moyen de deux vnements asynchrones, de direction oppose.
Figure 259 : Extrait de lautomate dun objet qui communique de manire synchrone
partir dvnements asynchrones. Lmetteur de la requte doit se mettre en attente de la
rponse.
Les gardes
Une garde est une condition boolenne qui valide ou non le dclenchement dune
transition lors de loccurrence dun vnement.
A
Evnement[ Condition ]
Evnement / Action
Figure 262 : Lorsquune transition est dclenche, laction qui lui est attache est excute
instantanment.
Figure 263 : Une action peut tre excute lentre ou la sortie dun tat, ou en cas
dvnement survenant dans ltat.
E1 / Action
on E1: Action
entry: Action d'entre
exit: Action de sortie
Figure 264 : Un vnement interne nentrane pas lexcution des actions de sortie et
dentre, contrairement au dclenchement dune transition rflexive.
Figure 265 : Les oprations qui durent sont forcment excutes au sein dun tat. Elles sont
identifies par le mot-cl do: suivi du nom de lopration.
Contrairement aux actions, les activits peuvent tre interrompues tout moment,
ds quune transition de sortie de ltat est dclenche. Certaines activits sont
cycliques et ne sarrtent que lorsquune transition de sortie est dclenche.
Dautres activits sont squentielles et dmarrent lentre dans ltat (tout de
suite aprs lexcution des actions dentre).
Lorsquune activit squentielle parvient son terme, ltat peut tre quitt si une
des transitions est franchissable. Ce type de transition qui nest pas dclenche
par un vnement est appele transition automatique.
[X]
[ not X ]
Figure 266 : Lorsque lactivit se termine, les transitions automatiques sans vnements,
mais ventuellement protges par des gardes sont dclenches.
Les tats peuvent galement contenir des variables exprimes sous la forme
dattributs. Les variables dtat appartiennent la classe associe lautomate,
mais peuvent tre reprsentes dans les diagrammes dtats-transitions
lorsquelles sont manipules par les actions ou les activits.
Login
Nom
Mot de passe
/ Op1
Un tat
entry: Op2
do: Op3
exit: Op4
on UnEvnement: Op5
/ Op6
Figure 268 : Le formalisme des diagrammes dtats-transitions offre six points pour spcifier
les oprations qui doivent tre excutes.
Gnralisation dtats
Les diagrammes dtats-transitions peuvent devenir assez difficiles lire lorsque,
du fait de lexplosion combinatoire, le nombre de connexions entre tats devient
lev : le diagramme se met alors ressembler un plat de spaghettis.
La solution pour matriser cette situation consiste utiliser le principe de
gnralisation dtats. Les tats plus gnraux sont appels super-tats, les tats
plus spcifiques sont appels sous-tats. Cette approche dabstraction procde
de la mme dmarche que la gnralisation et la spcialisation des classes ; elle
facilite la reprsentation et permet docculter les dtails.
Un tat peut tre dcompos en plusieurs sous-tats disjoints ; les sous-tats
hritent des caractristiques de leur super-tat, en particulier des variables dtat
et des transitions externes. La dcomposition en sous-tats est galement appele
dcomposition disjonctive (dcomposition de type ou-exclusif) car lobjet doit
tre dans un seul et un seul sous-tat la fois.
Les deux diagrammes suivants illustrent la simplification apporte par la
gnralisation dtats.
A
E1
E2
E2
C
Figure 269 : Exemple dautomate dans lequel la transition E2 peut tre factorise.
E1
A
B
E2
C
Les transitions internes peuvent tre hrites, sauf si la dcomposition en soustats a pour objet de dfinir un tat particulier pour le traitement dune transition
interne. Les transitions dentre ne sont pas hrites par tous les tats ; seul un
tat (le super-tat ou un de ses sous-tats) peut tre cible de la transition. Dans
lexemple suivant, ltat B est divis en deux sous-tats B1 et B2. La transition
dentre dans ltat B doit tre reporte sur un des sous-tats, soit directement
(comme dans le diagramme suivant), soit indirectement au moyen dun tat initial
embot.
A
B
A
B1
B2
Figure 271 : Ltat B est divis en deux sous-tats B1 et B2. La transition dentre dans ltat
B doit tre reporte directement sur un des sous tats.
Dans lexemple prcdent, ltat A est reli au sous-tat B1. Cette situation
manque dabstraction et est comparable un mcanisme crit selon la
spcification dune super-classe, mais ayant besoin de connatre le dtail des
sous-classes. Il est toujours prfrable de limiter les liens entre niveaux
hirarchiques dun automate en dfinissant systmatiquement un tat initial pour
chaque niveau. Le diagramme suivant limite les connaissances entre niveaux.
B
B1
B2
Figure 272 : Amlioration du niveau dabstraction dun automate par lajout dun tat
initial dans un super-tat.
Figure 273 : Les souches rduisent la charge dinformation, tout en matrialisant la prsence
des sous-tats de B.
Agrgation dtats
Lagrgation dtats est la composition dun tat partir de plusieurs autres tats
indpendants. La composition est de type conjonctive (composition de type et)
ce qui implique que lobjet doit tre simultanment dans tous les tats composant
lagrgation dtats. La conjonction dtats reprsente une forme de paralllisme
entre automates.
Lexemple suivant illustre diffrents aspects de la notion dagrgation dtats.
Ltat S est un agrgat form de deux tats indpendants T et U ; T est compos
des sous-tats X, Y et Z, et U des sous-tats A et B. Le domaine de S est le
produit cartsien de T et U.
S
T
X
E3
U
E1
A
Y
E1
Z
E2
E4[ in Z ]
B
E1
Z, B
Z, A
E4
E3
E3
E1
X, A
E1
X, B
Y, B
Le nombre dtats dun tel automate plat est au maximum gal au produit du
nombre dtats de chaque automate composant. Dans le cas dune agrgation de
trois automates dune centaine dtats chacun (ce qui est dj beaucoup),
lautomate plat quivalent pourrait contenir jusqu un million dtats !
Lhistorique
Par dfaut, un automate na pas de mmoire. La notation spciale H offre un
mcanisme pour mmoriser le dernier sous-tat visit et pour le rejoindre lors
dune transition entrant dans le super-tat qui lenglobe. Le concept dhistorique
sapplique au niveau dans lequel le symbole H est dclar. Le symbole H peut tre
plac nimporte o dans ltat ; le coin bas gauche est la position par dfaut.
Le diagramme suivant reprsente un tat C qui mmorise le dernier sous-tat actif.
Lhistorique est initialis lors du dclenchement de la transition issue de ltat
initial.
C
D2
In
A
Out
D1
Figure 276 : Exemple dautomate hirarchique. Ltat C mmorise le dernier sous-tat actif.
C
C1
C2
Lexemple suivant montre lutilisation de lhistorique pour la ralisation dun lavevaisselle. Le cycle de lavage est dcoup en trois grandes tapes : le rinage, le
lavage et le schage. A tout moment, la porte peut tre ouverte, pour rajouter par
exemple une tasse ; ds que la porte est referme, le cycle de lavage reprend au
point o il a t interrompu.
Rinage
Lavage
Schage
Porte ouverte
Porte ferme
Attente
Figure 278 : Un tat englobant peut mmoriser le dernier sous-tat actif. Le contrle est
transmis directement au sous-tat mmoris lorsquune transition qui arrive sur ltat spcial
H est dclenche.
Tlviseur
Bascul
Attente
Arrt
Bascul
Tlcommande
Bouton enfonc ^Tlviseur.Bascul
Attente
Crash
Atterrir
Dcoller
Au sol
Crer( immatriculation )
Figure 280 : La transition de cration emmne lobjet depuis ltat initial vers son premier
tat de fonctionnement. Larrive dans ltat final implique la disparition de lobjet.
Annulation transaction
Dpot effectu
B
Figure 281 : Reprsentation dune temporisation par combinaison dune activit dattente et
dune transition automatique.
Tempo( 3 minutes )
Annulation transaction
Dpot effectu
B
Introduction au mtamodle
Un automate reprsente un comportement qui rsulte doprations excutes
suite une squence de changements dtat. Un automate peut tre visualis
selon le point de vue des tats (par les diagrammes dtats-transitions) ou selon
le point de vue des actions (par les diagrammes dactivits). Un automate spcifie
le comportement dune collaboration.
Lexcution dune instance dautomate ne peut pas tre interrompue. A tout
moment, un automate peut ragir un vnement particulier qui lentrane dun
tat stable vers un autre tat stable. Lexcution de lautomate dbute partir du
pseudo-tat initial et se poursuit, au rythme des vnements, jusqu' ce quun
pseudo-tat final, non embot, soit atteint.
Automate
1
*
1
1..*
Source
Sommet
Pseudo tat
Transition
Cible
1..*
Etat
0..1
Effet
Action
0..1
1
Dclencheur
0..1
Evnement
SignalEvt
*
0..1
Signal
Appel
*
0..1
Opration
Temporel
*
0..1
Expression
Activit finie
E2
Figure 285 : Exemple de simplification graphique par reprsentation directe des activits.
Les transitions entre activits peuvent tre gardes par des conditions
boolennes, mutuellement exclusives. Les gardes se reprsentent proximit des
transitions dont elles valident le dclenchement.
permet d'ouvrir et de fermer des branches parallles au sein d'un flot d'excution
d'une mthode ou d'un cas d'utilisation. Les transitions au dpart d'une barre de
synchronisation sont dclenches simultanment.
L'exemple suivant montre que pour refroidir, il faut simultanment arrter le
chauffage et ouvrir les fentres.
Figure 289 : Exemple de synchronisation de flots de contrle parallles partir d'une barre
de synchronisation.
Figure 290 : Exemple de fusion de flots de contrle parallles regroups sur une barre de
synchronisation.
Figure 292 : Visualisation directe des objets responsables des diffrentes activits.
Figure 293 : Exemple de reprsentation mixte, incluant des tats et des activits.
Les modules
Les modules reprsentent toutes les sortes dlments physiques qui entrent
dans la fabrication des applications informatiques. Les modules peuvent tre de
simples fichiers, des paquetages du langage Ada, ou encore des bibliothques
charges dynamiquement.
Par dfaut, chaque classe du modle logique est ralise par deux composants : la
spcification et le corps. La spcification contient linterface de la classe alors que
le corps contient la ralisation de cette mme classe. La spcification peut tre
gnrique dans le cas des classes paramtrables.
Spcification
Corps
Gnrique
La spcification et le corps dune mme classe peuvent tre superposs dans les
diagrammes afin de rendre la notation plus compacte. Chaque corps dpend alors
implicitement de sa spcification.
gnrique. La procdure Itrer est un ami de X, ami tant pris au sens C++ de
friend.
X
Liste
<<Instanciation>>
Itrer
<<Ami>>
Figure 298 : Emploi de strotypes pour prciser la nature des choix de ralisation.
A'body
B'spec
B'body
<<Flot>> sont prdfinis par UML. Plusieurs flots peuvent partager le mme
espace dadressage au sein dun processus.
Les sous-programmes
Les sous-programmes regroupent les procdures et les fonctions qui
nappartiennent pas des classes. Ces composants peuvent contenir des
dclarations de types de base ncessaires pour la compilation des sousprogrammes. En revanche, ils ne contiennent jamais de classes.
Il existe deux reprsentations graphiques : une pour la spcification des sousprogrammes et une pour leur ralisation.
Les sous-systmes
Pour faciliter la ralisation des applications, les diffrents composants peuvent
tre regroups dans des paquetages selon un critre logique. Ils sont souvent
strotyps en sous-systmes pour ajouter les notions de bibliothques de
compilation et de gestion de configuration la smantique de partition dj
vhicule par les paquetages. Les sous-systmes jouent pour les composants le
mme rle que les catgories pour les classes.
<<Sous-systme>>
Figure 303 : Reprsentation graphique des sous-systmes partir dun paquetage et dun
strotype.
Les sous-systmes organisent la vue de ralisation dun systme ; chaque soussystme peut contenir des composants et dautres sous-systmes. Par
convention, tout composant du modle est plac soit au niveau racine, soit dans
un sous-systme. Les sous-systmes doivent tre vus comme de grandes briques
pour la construction des systmes.
Figure 304 : Les sous-systmes peuvent tre embots les uns dans les autres.
Cas d'utilisation
<<ralisation>>
*
*
Catgorie
Objet
Classe
1
Figure 305 : Les objets interagissent pour raliser les comportements dcrits
fonctionnellement dans les cas dutilisation.
Vue physique
Catgorie
Sous-systme
1
1..*
Classe
Module
*
Main
Interfaces
Sources
Tests
Docs
Noeud
Modem
<<Dispositif>>
PC
<<Processeur>>
Disque
<<Mmoire>>
PC
Connection
Serveur X
3
Serveur
1
SGBD
1
*
PC
<<RNIS>>
Pilote
1
Imprimante
<<Dispositif>>
Matre
Porte
1..10
que chaque PC peut tre le matre de 10 portes au plus. Trois terminaux X jouent
le rle de console pour accder au systme ; une imprimante est relie au serveur.
Le diagramme dcrit galement la nature des liens de communication entre les
diffrents nuds. Le serveur et les PC sont relis par une liaison RNIS ; les
terminaux X et le serveur communiquent via TCP/IP. La nature de la connexion
des autres nuds na pas t prcise.
Les nuds qui correspondent des processeurs du point de vue de lapplication
le strotype de processeurs napparat pas obligatoirement dans les
diagrammes de dploiement portent galement le nom des processus quils
hbergent. Le serveur excute un systme de gestion de bases de donnes ; les
PC hbergent le logiciel de pilotage ddi la commande et au contrle des
portes. Le nom de ces processus permet de faire le lien entre le diagramme de
dploiement et le diagramme des composants. Chaque processus nomm dans le
diagramme de dploiement excute un programme principal du mme nom, dcrit
dans le diagramme des composants.
Noeud
1
*
Processus
Programme principal
Nom
Nom
Figure 313 : Le nom des processus et des programmes principaux permet de faire le lien
entre les diagrammes de dploiement et de composants.
PC4
Porte 9
Porte 6
Porte 7
Porte 8
Figure 314 : Exemple dobjets dans un diagramme de dploiement. Les noms des objets sont
souligns afin de distinguer les objets des classes.
4
Encadrement
des projets objet
La prsence dun processus de dveloppement formalis, bien dfini et bien gr,
est un facteur de russite dun projet. Un processus est stable si ses
performances futures peuvent tre prdites statistiquement18.
UML tant avant tout un langage de modlisation elle ne dfinit pas un
processus de dveloppement particulier. Nanmoins, elle peut servir de notation
pour diffrentes approches mthodologiques bases sur les objets.
Lobjectif de ce chapitre est de prsenter les grandes lignes de lencadrement des
projets objet au travers dun cadre mthodologique gnrique proche de celui
dcrit par Objectory 4.019.
Il appartiendra chaque projet ou organisation de raffiner ce cadre en fonction de
ses besoins.
18
Caractrisation du logiciel
Ce chapitre a pour objet de caractriser le logiciel, de mettre en vidence lorigine
des difficults lies son dveloppement et desquisser les mesures prendre
pour les matriser.
La crise du logiciel
La formule est ne il y a trente ans20 pour dcrire la limite des technologies
disponibles et lincapacit matriser le logiciel qui en rsulte. Bien sr, au cours
de ces trente dernires annes, de nombreux progrs ont t raliss, mais le
logiciel est toujours en crise. Il est probable, comme le suggre Grady Booch, qu'il
ne s'agit pas dune crise mais plutt dun tat permanent.
Les mthodes objet ont pris le relais des techniques structures traditionnelles ;
les logiciels objet sont plus extensibles, plus proches des utilisateurs, plus faciles
maintenir, mais ils restent toujours difficiles raliser.
Il faut bien le dire, une des raisons de la crise du logiciel est la fuite en avant vers
la complexit des applications. La complexit intrinsque de chaque nouvelle
gnration de systme est plus grande de sorte que les solutions techniques qui
taient adaptes pour la gnration prcdente arrivent leurs limites pour la
gnration suivante. La crise du logiciel ne connat pas de fin.
Il existe plusieurs types de logiciels qui peuvent chacun se caractriser par les
contraintes quils placent sur le processus de dveloppement.
20
ce type de logiciel est quelque peu diffrent, et cela dautant plus que la diffusion
de ce type de logiciel est large. Une fois le logiciel en exploitation chez des milliers
de clients, ventuellement du monde entier, il nest gure ais de proposer des
corrections de dfauts, dautant que les revenus drivs des contrats de
maintenance sont faibles. Il faut donc maintenir un quilibre difficile entre qualit
du produit, cot de dveloppement et diffusion. Lobjectif de qualit moindre
cot est difficile tenir, mais impratif pour les produits marge faible et grande
distribution. Internet et le principe du shareware simplifient normment la
diffusion de ce type de logiciel, mais ne rsorbent pas limpratif de qualit.
La troisime catgorie comprend les logiciels essentiels au fonctionnement dune
entreprise et qui ne peuvent tre changs facilement : ils ont t construits pour
une tche donne et sont le fruit dun investissement non ngligeable. Ce type de
logiciel exige un comportement fiable, sr et prvisible : leur dfaillance peut
entraner la chute de lentreprise qui les utilise. Ils sont prsents la fois dans les
secteurs industriels et tertiaires, par exemple pour piloter un autocommutateur ou
pour grer une salle des marchs. La grande complexit de ces logiciels plus
prcisment de ces systmes logiciels provient dune part de la complexit
intrinsque lie au domaine des applications et dautre part de la complexit des
environnements dexcution, souvent htrognes et distribus. Leur
maintenance volutive devient de plus en plus difficile car chaque modification
rend le logiciel plus confus. Les informaticiens subissent alors le poids du pass,
souvent jusqu un point de rupture quil est essentiel danticiper. La triste ralit
est que lentropie des logiciels est limage de lentropie de lunivers : elle ne
cesse de crotre. De ce point de vue, un processus de dveloppement doit limiter
le dsordre logiciel.
La dernire catgorie de logiciels englobe les systmes vitaux, cest--dire ceux
dont dpend la vie dtres humains. Ces systmes se rencontrent dans les
domaines du transport de larmement et de la mdecine. Les contraintes
dexploitation de ces logiciels nont absolument rien voir avec les catgories
prcdentes. Un dysfonctionnement ne se chiffre plus en argent, mais en vies
humaines.
Linformaticien doit apprendre imiter la nature qui, dans ses constructions les
plus lmentaires comme les plus complexes, cherche toujours lquilibre stable,
la consommation dnergie minimale, loin du caprice ou du superflu.
Trop souvent, llaboration des logiciels reste une activit parcellaire et
disperse. Si linformaticien construisait des meubles, il commencerait par planter
des glands, dbiterait les arbres en planches, creuserait le sol la recherche de
minerai de fer, fabriquerait une forge pour faire ses clous et finirait par assembler
le tout pour obtenir un meuble. Ce mode de fabrication engendre une large
dispersion des efforts et requiert la matrise dune trop grande palette de
comptences. Durant les sicles passs, nos anctres ont appris spcialiser les
activits humaines et cest ainsi que certains spcialistes savent comment faire
pousser les arbres alors que dautres connaissent les secrets de fabrication des
clous. Lavantage immdiat de cette approche est que les autres personnes
peuvent se concentrer sur leur propre domaine de connaissance, par exemple la
fabrication des meubles. Un mode de dveloppement qui repose sur les paules
de quelques programmeurs hroques, de gourous et autres magiciens du logiciel,
ne constitue pas une pratique industrielle prenne et reproductible.
La formalisation du processus de dveloppement procde de cette constatation.
Les activits mises en uvre lors de llaboration du logiciel doivent tre dcrites,
expliques, motives : la connaissance et le savoir-faire informatique peuvent
alors se propager autrement que de bouche de druide oreille de druide21. Un
processus dcrit lenchanement des activits de lquipe de dveloppement ; il
dirige les tches de chaque individu ainsi que celles du groupe. Le processus
dfinit des points de mesures et des critres pour contrler et mesurer les
produits et les activits du projet.
Malheureusement, la formalisation du processus de dveloppement ne sapplique
que partiellement au domaine informatique. Contrairement lbnisterie,
linformatique est un domaine de connaissance trs jeune et pauvre en savoirfaire transmissibles. De plus, le niveau de formalisation du savoir-faire
informatique est trs faible. Avant de vouloir propager lexprience, il faut
dabord savoir la dcrire, la reprsenter, la modliser.
Cela revient galement dire que linformatique est un mtier qui sapprend
comme les autres mtiers : il nest pas possible de simproviser informaticien. Une
entreprise qui recherche un spcialiste de linformatique doit donc rechercher un
ingnieur informaticien plutt quun spcialiste de la chimie ou du textile.
21
Consquence de la complexit
Du fait de la complexit lie llaboration des logiciels, il y a fort peu de chances
quun logiciel soit exempt de dfauts. Au contraire, le risque de dficience grave
est lev.
Les dfauts logiciels, les bogues, sont comme les couacs en musique22. Les
meilleurs musiciens ne sont pas l'abri dun couac ; ce quils font est difficile et
assurer une qualit constante, sur une longue dure, lest aussi. Linformaticien
est confront au mme problme, quelles que soient ses comptences ; il nest
pas l'abri dun couac. Les logiciels sont crits par des humains, les humains
sont faillibles, les logiciels aussi.
La mise au point des logiciels est lente et chaotique, et le cot de maintenance est
disproportionn. Les techniques de test et de validation permettent de dgager
des chemins dexcution scuriss : suivis la lettre, ils permettent de garantir un
niveau de confiance raisonnable dans le logiciel.
Tous les dfauts nont pas les mmes consquences. Les dfauts danalyse se
traduisent par des logiciels qui ne satisfont pas leurs utilisateurs. Les dfauts de
conception gnrent des logiciels lourds manier, trop lents ou peu efficaces. Les
dfauts de ralisation induisent des comportements non prvus. Tout dfaut est
indsirable ; ceux introduits dans les activits en amont restent cependant les
plus difficiles corriger.
22
Quoi faire ? La rponse est exprime par lutilisateur qui dcrit ce quil attend
du systme, comment il entend interagir avec lui et quels sont les diffrents
intervenants. Il sagit dune description fonctionnelle qui ne rentre pas dans
les dtails de la ralisation : le quoi faire est purement descriptif.
Lapproche objet rpond ces questions, selon trois regards diffrents : lanalyse
objet, la conception objet et la programmation objet.
Figure 315 : Lapproche objet porte trois regards diffrents sur les systmes.
Lanalyse objet
Lanalyse remonte de la consquence vers le principe : elle essaie de comprendre,
dexpliquer et de reprsenter la nature profonde du systme quelle observe.
Lanalyse ne se proccupe pas de solutions mais de questions ; elle identifie le
quoi faire et lenvironnement dun systme, sans dcrire le comment qui est le
propre de la conception.
Lanalyse commence par la dtermination du quoi faire, cest--dire des besoins
de lutilisateur. Bien souvent, lutilisateur nest pas capable dexprimer clairement
ses attentes, de sorte que le cahier des charges nest quune reprsentation
approximative de ses besoins rels. La prsence dun imposant cahier des
charges nest pas toujours de bon augure. Sa qualit dpend trs fortement de
la technique employe pour son laboration. Trop souvent, les cahiers des
charges sont touffus, confus, contiennent des points contradictoires et ne
refltent pas les vrais besoins des utilisateurs. Lexprience montre que la
technique des cas dutilisation (use cases) se prte bien la dtermination des
besoins de lutilisateur.
Lanalyse se poursuit par la modlisation du domaine de lapplication, cest--dire
par lidentification des objets et des classes qui appartiennent fondamentalement
lenvironnement de lapplication, et par la reprsentation des interactions entre
ces objets. Lanalyse rend compte de la structure statique au moyen des relations
entre les classes et des interactions entre les objets au moyen des messages. Il
nexiste pas dordre prfrentiel dans llaboration des diffrents types de
diagrammes : ils sont souvent construits simultanment. Parmi les nombreux
diagrammes dfinis par UML, ceux qui montrent des lments de la vue logique
peuvent tre utiliss en analyse, en particulier :
Cette liste nest pas limitative et chaque projet est libre dutiliser dautres
techniques pour parfaire lanalyse de son problme. En particulier, les approches
cognitives et systmiques apportent souvent un clairage intressant et
complmentaire de la modlisation objet.
Lassise sur les lments du monde rel facilite le dpart de la dmarche car elle
concentre la pense sur des lments concrets. Elle doit imprativement tre
poursuivie par une dmarche dabstraction qui vise faire oublier les
contingences du monde rel et dterminer les concepts fondateurs qui sont
leurs origines. Si la rflexion se focalise trop sur lexistant, les risques de
reproduire une solution au lieu didentifier le problme pos sont grands (voir
plus loin le paragraphe sur la place de linformatique ou le choc des cultures).
Lanalyse est lantithse de la conformit. Lanalyse est souvent surprenante car
elle demande de changer de point de vue, doublier ce qui est connu, ce qui
simpose de prime abord, afin de trouver lessentiel, la nature cache des choses.
Le propre de lanalyse est de trouver une description laquelle personne navait
pens jusqualors, mais qui une fois dtermine simpose au point dtre
vidente.
Pour prendre une image, analyser cest regarder un point, un cercle, une ellipse,
une droite, deux droites scantes, une hyperbole et une parabole et reconnatre
que toutes ces formes peuvent tre obtenues par lintersection dun plan et dun
cne. Dans ce cas, le principe gnrateur peut tre exprim par une quation de la
forme ax2 + by2 + 2cx + 2dy + e = 0. Cette reprsentation est
conome car elle dcrit lessentiel. Lanalyse va lessentiel et recherche un
modle gnrique plus abstrait.
La consquence immdiate dune analyse bien mene est toujours une grande
conomie dans la ralisation qui sensuit, en vertu de la dichotomie (essence,
manifestation) sous-tendu par lapproche objet. Lidentification du principe
gnrateur permet de raliser en une seule fois ce qui se manifeste gnralement
sous plusieurs formes, puis de linstancier pour obtenir les diffrentes
manifestations dsires, voire souvent dautres manifestations non encore
prsentes dans le domaine.
Paralllement lanalyse de lenvironnement, se droule parfois une analyse de
lexistant et des contraintes de ralisation. Lobjet de cette analyse est de
comprendre parfaitement les caractristiques et les contraintes de
lenvironnement de ralisation afin de pouvoir prendre des dcisions motives et
La conception objet
Comme lanalyse et la conception, la conception et la ralisation se chevauchent
en partie. Il est rare de savoir comment tout faire : pour cette raison il faut essayer
des techniques alternatives, comparer les rsultats puis choisir en faisant des
compromis. La conception et la ralisation se compltent. La conception a besoin
dexprimenter, la ralisation a besoin de principes directeurs.
Afin de maintenir le plus longtemps possible les bnfices de l'abstraction, la
conception est gnralement subdivise en deux tapes : une tape logique
indpendante de lenvironnement de ralisation et une tape physique qui se
proccupe de lordonnancement des ressources et des particularits des langages
de programmation ou de lenvironnement dexcution.
La conception est souvent considre, tort, comme un simple enrichissement
des rsultats obtenus durant lanalyse. Il sagit l dune vision fortement
rductrice qui ignore tout simplement que la conception est le temps de la mise en
uvre du savoir-faire. Ce savoir-faire peut tre interne au projet ou acquis
lextrieur sous la forme doutils, de composants rutilisables ou plus largement
de cadres de dveloppement. Lmergence des patterns (les patterns et les
frameworks sont dcrits plus loin) marque une avance dans la formalisation du
la portabilit des sources, voire des excutables, qui rduit notablement les
cots de dveloppement et surtout de maintenance dans le cas dun
dveloppement multicibles.
le traitement des erreurs qui peut tre effectu par des exceptions ou par des
statuts exprims sous la forme de valeurs entires. Lexception ne peut tre
ignore, mais son traitement obscurcit le code normal. Le statut derreur est
simple mettre en uvre mais il peut tre ignor : le traitement de lerreur nest
alors pas garanti ;
la communication entre processus qui peut reposer sur des liaisons point-point, multi-points ou par diffusion. Elle peut tre assure par des mcanismes
ad hoc ou inscrite dans un schma gnral dintgration dapplication comme
Corba ou ActiveX ;
La programmation objet
La programmation objet est le dernier maillon de la chane objet, aprs lanalyse et
la conception. La programmation dans un langage objet est la manire la plus
commode de traduire une conception objet en un programme excutable par une
machine. Il est galement possible dutiliser un langage non objet, mais ceci
impose une charge de travail supplmentaire au programmeur qui doit simuler les
constructions objet.
Paralllement aux vrais langages objet, comme Smalltalk ou Java, il est possible de
trouver des langages ou des environnements teinture objet, par exemple Visual
Basic de Microsoft ou encore Powerbuilder de Powersoft ; dune certaine manire
ils permettent de faire de lobjet en douceur, sans sen rendre compte23.
Les langages de programmation objet sont en majorit des langages
algorithmiques et structurs. Ils offrent au moins les concepts de classes,
23
Ada est un langage de programmation de haut niveau conu pour rduire les
cots de dveloppement exorbitants auxquels le ministre de la dfense
amricain devait faire face dans les annes 70. Ada a t normalis une
premire fois en 1983 par lANSI. Aprs une dcennie dutilisation, le langage
Ada a t amlior par lajout de constructions objet et sa deuxime mouture,
standardise en 1995, en fait un langage objet part entire. Ada 83 est le
langage du gnie logiciel ; Ada 95 est le langage du gnie logiciel objet.
C++ est un langage objet hybride conu par Bjarne Stroustrup dans les
annes 80 : cest une extension du langage C. C++ corrige le C en rajoutant le
typage fort, les classes, la surcharge et la liaison dynamique. Sa syntaxe reste
touffue comme celle du C et rend C++ difficile mettre en uvre.
Java est le dernier-n des langages objet. Il sinspire de C++ pour la syntaxe et
de Smalltalk pour la machine virtuelle, tout en restant comme Eiffel
volontairement simple. Initialement conu pour la programmation des
24
Smalltalk est le langage objet par excellence : en Smalltalk, tout est objet, y
compris les classes elles-mmes. Smalltalk a t conu dans les annes 70 au
PARC (le centre de recherche de Xerox Palo Alto). Depuis 1980, Smalltalk est
accompagn dun environnement de dveloppement sophistiqu et dune
grande collection de classes prdfinies. Du fait de sa souplesse demploi et
de sa simplicit, Smalltalk connat actuellement un regain dintrt pour la
cration de systmes dinformation.
C++
Eiffel
Java
Smalltalk
Paquetage
Oui
Non
Non
Oui
Non
Hritage
Simple
Multiple
Multiple
Simple
Simple
Gnricit
Oui
Oui
Oui
Non
Non
Typage
Fort
Fort
Fort
Fort
Non typ
Liaison
Dynamique
Dynamique
Dynamique
Dynamique
Dynamique
Paralllisme
Oui
Non
Non
Oui
Non
Ramasse-miettes
Non
Non
Oui
Oui
Oui
Assertions
Non
Non
Oui
Non
Non
Persistance
Non
Non
Non
Non
Non
Figure 316 : Tableau rcapitulatif des grandes caractristiques des principaux langages
objet.
de mettre en place un plan de formation sous une forme qui combine thorie et
pratique,
de former tout le monde, les dveloppeurs mais aussi les groupes de test, les
quipes dassurance qualit et lencadrement.
une notation dont lobjectif est dassurer le rendu visuel des lments de
modlisation,
Figure 317 : Reprsentation des cinq niveaux de maturit des processus de dveloppement
selon Watts S. Humphrey.
Cas d'utilisation
<<Centr sur>>
<<Pilot par>>
<<Droulement>>
Processus Gnrique
Groupe A
Entreprise B
Figure 318 : Le processus de dveloppement prconis par les auteurs dUML est pilot par
les cas dutilisation, centr sur larchitecture et droul de manire itrative et incrmentale.
Figure 319 : Les cas dutilisation balisent les diffrentes activits et tapes du processus.
Les besoins sont dabord segments par rapport aux diffrents types
dutilisateurs (les acteurs) et dcrits par des cas dutilisation exprims dans le
langage des acteurs. A ce stade, les cas dutilisation aident lutilisateur articuler
ses besoins : il dcrit les services quil attend du systme sous la forme
dinteractions entre lacteur et le systme. Lanalyse des besoins est
principalement exprime par un modle des cas dutilisation.
Le processus continue par une dmarche danalyse objet. Les objets qui
appartiennent fondamentalement au domaine de lapplication sont identifis, puis
dcrits de manire gnrale par leurs classes. Chaque cas dutilisation est ensuite
ralis par une collaboration entre les objets trouvs prcdemment. La
dcomposition nest pas fonctionnelle : la collaboration qui ralise un cas
dutilisation nest quun cas particulier des collaborations potentielles gnres
par la structure des classes.
Le passage de lanalyse la conception est marqu par lintroduction de
considrations de ralisation dans les modles. Lanalyse dcrit le quoi dun
systme alors que la conception sintresse au comment. Les cas dutilisation
continuent de baliser la conception puisquils spcifient ce que les mcanismes
doivent faire.
Les cas dutilisation dcrivent les tests fonctionnels.
Cas d'utilisation
Dcrit le domaine
Ralise
Vrifie
Analyse
Conception
Test
Figure 320 : Les cas dutilisation coordonnent et balisent les diffrents modles.
Pour autant, les cas dutilisation ne donnent pas la forme du systme. Dans une
approche objet, la forme (larchitecture) du logiciel ne reflte pas la forme des cas
dutilisation.
Architecture logicielle
Le dveloppement dun logiciel peut tre vu comme la traverse dun ocan en
bateau. Le jour de dpart est connu, le jour darrive lest moins, et en cours de
route, il faudra affronter des temptes et rparer des avaries. La conception de
larchitecture dun logiciel a pour objet de donner un effort de dveloppement
les moyens de parvenir bon port.
Larchitecture logicielle sintresse la forme globale dune application : cette
forme merge de la conception au-del des structures de donnes ou des
algorithmes 26. Larchitecture logicielle se proccupe dintgrit, duniformit, de
simplicit et desthtisme. Elle est presque contre-courant dune discipline (le
dveloppement de logiciel) que rien ne prdispose aux vertus voques plus
haut, du fait principalement de limmatrialit du logiciel et de labsence de
contraintes physiques.
La mise en place d'une architecture adapte est la cl de vote du succs dun
dveloppement. Il importe de la stabiliser le plus tt possible. Il nexiste pas
darchitecture universelle, adapte tous les types dapplications. En revanche, il
existe des architectures rutilisables, dans les limites dun domaine particulier.
26
Dans le contexte de la dmarche objet, les lments sont les objets et les classes,
les formes sont des regroupements de classes et dobjets (les patterns), et les
motivations expliquent pourquoi tel ou tel regroupement est plus adapt quun
autre dans un contexte donn.
Larchitecture offre une vision globale de lapplication ; elle dcrit les choix
stratgiques qui dterminent les qualits du logiciel, comme la fiabilit,
ladaptabilit ou la garantie des performances, tout en mnageant des espaces
pour les dcisions tactiques prises en cours de dveloppement28.
Figure 321 : Larchitecture reflte les choix stratgiques gnraux et mnage des espaces
pour les dcisions tactiques ponctuelles.
la simplicit,
llgance,
lintelligibilit,
27
Perry D. E.and Wolf A. L. Oct. 1992, Foundations for the Study of Software
Architecture. ACM Software Eng. Notes, pp. 40-52.
28
La vision de larchitecte
Il nexiste pas une seule manire de considrer un systme. De multiples points de
vue sont requis. Par ailleurs, pour satisfaire les multiples intervenants chaque
type de diagramme ne donne quune image partielle dun systme.
Tous les projets objet couronns de succs se caractrisent par la prsence dune
forte vision de larchitecture. Cette vision peut tre dcrite partir de plusieurs
vues complmentaires, inspires de celles dcrites par Philippe Kruchten29, dans
son modle dit des 4 + 1 vues.
les objets,
les classes,
les collaborations,
les interactions,
29
Kruchten P. Nov. 95, The 4+1 View Model of Architecture. IEEE Software.
La vue de ralisation
La vue de ralisation se proccupe de lorganisation des modules dans
lenvironnement de dveloppement. Elle montre lallocation des classes dans les
modules, et lallocation des modules dans les sous-systmes. Les sous-systmes
sont eux-mmes organiss en niveaux hirarchiques aux interfaces bien dfinies.
La vue de ralisation traite des lments de modlisation suivants :
les modules,
les sous-programmes,
les interactions.
La vue de dploiement
La vue de dploiement dcrit les diffrentes ressources matrielles et
limplantation du logiciel dans ces ressources.
La vue de dploiement traite les points suivants :
les nuds,
les modules,
les acteurs,
les classes,
les collaborations.
Modle
1
Vue
1..5
Paquetage
0..1
Possde
*
*
Rfrence
*
Elment
Elment de modlisation
1..*
Elment de visualisation
< Montre
0..*
Figure 323 : Extrait du mtamodle. Organisation hirarchique des modles selon plusieurs
vues.
: Elment
: Elment
: Elment
: Elment
: Elment
Documentation de larchitecture
Larchitecture est dcrite dans un document darchitecture qui comprend :
une description textuelle des traits de larchitecture (les vues) et les besoinscls du systme,
Composants
Dploiement
Classes
Cas d'utilisation
Squence
Etats-Transitions
Activit
Objets
Collaboration
Figure 325 : Reprsentation des neuf types de diagrammes dfinis par UML.
Ces diagrammes forment la base des vues darchitecture dcrites plus haut. Il
importe de bien conceptualiser les liens entre les diffrents lments de
modlisation et leurs reprsentations associes afin de documenter un systme
avec clart et efficacit.
Un modle est une construction smantique, organise sous la forme dun rseau.
Ce rseau peut se parcourir en suivant les rgles gnrales dcrites dans le
mtamodle dUML.
Les diffrents diagrammes peuvent tre vus comme des chemins graphiques
parcourant les modles. Les paragraphes suivants proposent un exemple de
cheminement, depuis lnonc des besoins jusquau dploiement dans le matriel.
Cas d'utilisation
*
Besoin
Figure 326 : Les besoins des utilisateurs sont exprims, acteur par acteur, sous la forme de
cas dutilisation.
<<Ralise>>
*
Objet
Contexte
*
Collaboration
0..*
Interaction
0..1
Figure 327 : La transition vers lobjet est opre en ralisant un cas dutilisation par une
collaboration entre objets du domaine.
Expression du comportement
Le comportement dune collaboration ou dune classe peut se reprsenter sous la
forme dune interaction ou dun automate. Les interactions sont visualises du
point de vue temporel, par des diagrammes de squence et du point de vue
spatial, par des diagrammes de collaboration. Les automates sont visualiss du
point de vue des tats et des transitions, par des diagrammes dtats-transitions
et du point de vue des activits, par des diagrammes dactivits.
0..1
Classe
0..1
Collaboration
0..*
Automate
0..1
Interaction
0..*
0..*
Diagramme
d'tats-transitions
Diagramme
d'activits
Diagramme
d'interaction
Diagramme
de squence
Diagramme
de collaboration
Reprsentation de la structure
Chaque objet est instance dune classe. Les classes du domaine dcrivent de
manire gnrale les objets mtiers. Les objets sont reprsents dans les
diagrammes dobjets, dans les diagrammes de collaboration et dans les
diagrammes de squence. Les classes sont reprsentes dans les diagrammes de
classes.
Lien
Instance de >
Relation
Objet
*
Classe
*
Instance de >
Collaboration
*
*
Interaction
Diagramme de classe
0..*
0..1
Diagramme d'objets
1
*
Contexte
Diagramme d'interaction
*
Objet
Classe
1
*
*
Dpendance
Composant
1
Module
Sous-Programme
Tche
Programme principal
Figure 330 : Le code qui correspond aux objets et aux classes est stock dans des modules.
Programme principal
*
Processus
*
Noeud
Figure 331 : Un programme principal est une sorte de composant qui contient un code
excutable correspondant une ou plusieurs interactions.
dans la vue logique, les paquetages contiennent des objets, des classes,
dautres paquetages, et les diagrammes qui visualisent ces lments,
Les paquetages peuvent tre spcialiss sous la forme de catgories et de soussystmes, pour distinguer respectivement les paquetages de la vue logique et les
paquetages de la vue de ralisation.
Paquetage
Catgorie
Sous-systme
Figure 332 : Exemple de spcialisation des paquetages pour distinguer les concepts
dorganisation de la vue logique, de ceux de la vue de ralisation.
En rgle gnrale, il y a correspondance directe entre une catgorie et un soussystme. Les hirarchies de catgories et de sous-systmes peuvent diffrer,
entre autres pour :
Processus
*
*
1
1..*
Sous-systme
Noeud
*
Figure 333 : Reprsentation des correspondances entre les lments granularit forte.
Thread
*
Module
Processeur
*
Figure 334 : Reprsentation des correspondances entre les lments granularit fine.
Vue par vue, les lments forte granularit sont des agrgats dlments
granularit plus fine. UML permet de construire des modles empreints de cette
dcomposition hirarchique, et favorise ainsi la navigation entre les diffrents
points de vue et entre les niveaux de dtails de ces points de vue.
Catgorie
Processus
1
Classe
*
Module
Processeur
*
*
1
Thread
*
1..*
*
*
Sous-systme
Noeud
*
Figure 335 : Correspondance entre les lments de modlisation au sein dune reprsentation
hirarchique matrialise par les agrgations.
Cette dichotomie entre lments peut tre reprsente sous la forme dun
empilement pyramidal des lments de modlisation dUML ; il montre que tous
les lments sont visibles simultanment en cas de besoin, mais que la vision
peut galement se limiter un niveau dabstraction donn.
La figure prcdente fournit une vue du dessus de cet empilement. Les lments
de mme niveau hirarchique dans la pyramide sont en correspondance vue par
vue. La base de la pyramide regroupe les lments forte granularit, ltage
intermdiaire contient les lments fine granularit et le sommet est constitu
des cas dutilisation. Ces derniers se ralisent par des collaborations construites
partir des lments des niveaux infrieurs.
Grce ces correspondances entre lments de modlisation, UML facilite la
navigation entre les points de vue gnraux et les points de vue dtaills, comme
le dcrit Grady Booch, pour qui la forme gnrale influence les formes dtailles et
rciproquement. Il qualifie sa dmarche de Round Trip Gestalt30.
30
Vue de
ralisation
Vue des
processus
Vue de
dploiement
Acteurs
Cas
dutilisation
Diagramme de
classes
Diagramme
dobjets
Vue logique
Classes
Relations
Objets
Classes
Liens
Objets
Liens
Diagramme de
squence
Diagramme de
collaboration
Diagramme
dtatstransitions
Diagramme
dactivit
Acteurs
Acteurs
Objets
Objets
Objets
Messages
Messages
Messages
Acteurs
Acteurs
Objets
Objets
Objets
Liens
Liens
Liens
Messages
Message
Messages
Etats
Etats
Etats
Transitions
Transitions
Transitions
Activits
Activits
Activits
Transitions
Transitions
Transitions
Diagramme de
composants
Diagramme de
dploiement
Composants
Composants
Composants
Nuds
Liens
Figure 337 : Tableau rcapitulatif de lutilisation des lments dans les diffrents types de
diagrammes dans le but de reprsenter les diffrents points de vue.
Micro-architecture
Le terme anglais pattern, en franais forme, micro-architecture, ou schme,
dsigne des combinaisons rcurrentes dobjets et de classes. Elle se retrouvent
frquemment dans les conceptions objet et peuvent tre qualifies de savoir-faire
objet. Le principal intrt des patterns est de permettre la manipulation de
concepts darchitecture plus labors que les objets et classes. Ils augmentent la
puissance dexpression des langages de modlisation. Cette dmarche vite
galement de trop sattarder sur des objets lis aux particularits du domaine de
lapplication, et ainsi de rechercher des conceptions de plus haut niveau,
ventuellement moins performantes, mais plus flexibles et plus extensibles. Dans
une certaine mesure, un pattern est pour les objets, lquivalent du sousprogramme pour les instructions, ou encore des circuits intgrs pour les
transistors. Le pattern est lunit de rutilisation de conception objet.
Le concept de pattern 31 a t dcrit par Christopher Alexander32. Cet architecte
dsirait formaliser les grands traits de larchitecture afin de faciliter la construction
des btiments. Cette ide de formalisation des lments darchitecture, ou encore
des formes darchitecture (do le terme de pattern), peut tout fait tre
transpose dans le domaine du logiciel, afin de dfinir des formes logicielles
rutilisables dapplications en applications.
UML reprsente les patterns par les collaborations. Une collaboration regroupe
un contexte dobjets et une interaction entre ces objets. Une collaboration
convient donc pour la reprsentation des patterns de structure, comme des
patterns de comportement. Les collaborations sont reprsentes par des ellipses
pointilles, connectes aux objets qui y participent.
Le diagramme suivant reprsente un pattern de chane de responsabilit.
31
Alexander C., Ishikawa S., Silverstein M., Jacobson M., Fiskdahl-King I., Angel
S. 1977, A Pattern Language. Oxford University Press, New York.
32
Each pattern describes a problem which occurs over and over again in our
environment, and then describes the core of the solution to that problem, in
such a way that you can use this solution a million times over, without ever
doing it the same way twice. Christopher Alexander
Idiomes
Les patterns sont des constructions caractristiques totalement indpendantes
des langages de ralisation. Les patterns formalisent des choix darchitecture qui
peuvent tre mis en uvre de manire uniforme, quel que soit lenvironnement de
ralisation. Paralllement ces formes indpendantes, il existe des constructions
rcurrentes spcifiques un langage de programmation donn. Ces formes
particulires, appeles idiomes, regroupent des constructions syntaxiques
existantes. Les idiomes permettent de former de nouvelles constructions et ne
sont gnralement pas transposables tels quels dun langage lautre.
33
Gamma E., Helm R., Johnson R., Vlissides J. 1995, Elements of Reusable ObjectOriented Software. Addison-Wesley.
Macro-architecture
La reprsentation des grands systmes fait appel de nombreuses classes. Du
fait de la complexit des modles dont le contenu dpasse rapidement les
limites 35 de comprhension de l'tre humain il est impossible de distinguer les
traits de larchitecture dans les entrelacs de classes et de relations. Larchitecture
gnrale dune application ne peut pas se reprsenter partir dlments fine
granularit ; il faut introduire des concepts structurants plus larges pour faire
merger la macrostructure et pour faciliter la comprhension des modles.
Les patterns dcrivent de petites formes rcurrentes, utilisables au jour le jour
pour rsoudre des problmes ponctuels. Ces patterns nexpriment pas la forme
gnrale dune application. Cest pourquoi des reprsentations plus larges
regroupent les patterns au sein de frameworks, vritables infrastructures
rutilisables, ddies la ralisation dapplications cibles. Ces frameworks
34
Miller G. March 1956, The Magical Number Seven, Plus or Minus Two: Some
Limits on Our Capacity for Processing Information. The Psychological Review
V. 63 (2).
peuvent tre reprsents au moyen des trois concepts structurants proposs par
UML : les cas dutilisation, les paquetages et les collaborations. Ces concepts
expriment respectivement, le comportement vu de lextrieur, la macrostructure
statique et les patterns.
La macro-architecture se reprsente au moyen de catgories (paquetages
strotyps pour insister sur leur fonction architecturale). Les catgories
encapsulent les classes et les objets coupls logiquement au sein dlments plus
larges. Ils permettent ainsi de construire des niveaux hirarchiques. Ils
segmentent une application en couches dabstraction croissante. Chaque niveau
possde des interfaces bien dfinies. Un niveau de rang donn ne dpend que
des niveaux de rang infrieur. La forme gnrale dune application se reprsente
par des diagrammes de catgories, en fait des diagrammes de classes qui ne
contiennent que des catgories. Les diffrentes catgories sont relies entre elles
par des relations de dpendances strotypes pour reprsenter les imports entre
catgories.
<<Catgorie>>
<<Import>
>
<<Catgorie>>
<<Import>>
<<Catgorie>>
Figure 339 : Exemple de reprsentation des catgories et des imports entre catgories.
<<Framework>>
<<Catgorie>>
Wigdets
IHM
<<Miroir>>
<<Framework>>
<<Catgorie>>
<<Catgorie>>
Contrle
commande
Machine outil
Gamme
<<Catgorie>>
<<Catgorie>>
Com
Persistance
<<Catgorie>>
Systme
d'exploitation
Petit petit, des lments logiciels ont t rajouts pour contrler, commander ou
rguler. Ces premiers programmes ont dabord t dvelopps en assembleur ; ils
restent trs proches du matriel.
Cette topologie dapplication est la consquence dun manque de vision globale.
Elle se traduit par une absence totale dintgration entre les composants logiciels
et par une duplication de leffort, allant parfois jusqu' des redondances
matrielles. Dans le domaine de lautomobile, les systmes distincts dantipatinage et danti-blocage des roues illustrent bien ce phnomne.
Figure 342 : Des lments logiciels sont rajouts dans le systme, sans concertation.
Figure 344 : Aprs mutation, le savoir-faire de lentreprise est exprim dans du logiciel.
Figure 345 : Informatisation limite dans le cadre dun processus en place dans lentreprise.
Figure 346 : Intgration des processus dune entreprise dans un cadre informatique global.
36
Gall, J. 1986, Systematics : How Systems Really Work and How They Fail. 2nd
ed. Ann Arbor, MI : The General Systematics Press.
37
Le modle en cascade
Le cycle de vie en cascade38, dcrit par Royce ds 1970, a t largement employ
depuis, pour la description gnrale des activits lies au dveloppement de
logiciels.
Le cycle de vie en cascade prsente le dveloppement de logiciel comme une
suite de phases qui senchanent dans un droulement linaire, depuis lanalyse
des besoins jusqu' la livraison du produit au client. Chaque phase correspond
une activit.
Le dveloppement en cascade est rythm par la gnration de documents qui
servent de support tangible pour les revues de validation du passage dune
phase une autre.
Par rapport au modle en tunnel, le modle en cascade prsente lnorme
avantage de fournir des points de mesure concrets, sous la forme de documents ;
il augmente ainsi la visibilit sur ltat davancement du systme en cours de
dveloppement. Le diagramme suivants illustre le gain de visibilit apport par le
modle en cascade.
38
Figure 348 : Le modle de dveloppement en cascade ouvre des points de visibilit sur le
processus de dveloppement.
Le cycle en cascade est souvent reprsent sous la forme dune lettre V pour faire
apparatre que le dveloppement des tests est effectu de manire synchrone
avec le dveloppement du logiciel. Cette approche permet de tester ce qui devait
tre fait et non ce qui a t fait. Le diagramme suivant montre un exemple de
modle en V, dans lequel les tests fonctionnels sont spcifis lors de lanalyse,
les tests dintgration lors de la conception et les tests unitaires pendant la phase
de codage.
Avant cette phase dintgration, seuls des documents ont t produits. Or, ce
nest pas parce quun document passe avec succs une tape de validation sur
papier que le logiciel quil dcrit donnera forcment des rsultats convaincants.
En fait, la dmarche en cascade ne donne des rsultats satisfaisants que lorsquil
est effectivement possible denchaner les phases sans trop de problmes. Il faut
que lensemble des besoins soit parfaitement connu et le problme compltement
compris par les analystes ; il faut aussi que la solution soit facile dterminer par
les concepteurs et le codage rduit idalement la gnration automatique de
code, partir des documents de conception.
Hlas, les projets ne se prsentent pas tous sous ces conditions idales. Force
est de constater que la part d'inconnu, et donc de risques, peut tre grande dans
certains dveloppements, notamment du fait :
Pour toutes ces raisons, des retours dinformation entre les phases sont
ncessaires pour incorporer des corrections en amont, en fonction des
dcouvertes ralises en aval. Ces retours entre phases perturbent la vision
linaire donne par le cycle de vie en cascade, comme le montre le diagramme
suivant :
Figure 350 : La part dinconnu qui caractrise les systmes complexes se traduit par des
retours dinformation entre phases pour incorporer des corrections.
En fait, les retours entre phases ne sont que le reflet de la ralit. Tant que ces
retours restent marginaux et limits entre phases adjacentes, le modle en cascade
conserve toute sa pertinence. Dans le cas contraire, le modle en cascade nest
plus vraiment adapt. Il devient alors de plus en plus artificiel de considrer le
dveloppement comme un enchanement linaire.
Lorsquun modle ne reprsente plus une ralit, il faut en changer et non essayer
de faire coller la ralit au modle 39.
lutilisateur est plac devant des situations dutilisation concrtes qui lui
permettent de mieux structurer ses dsirs et de les communiquer lquipe de
dveloppement ;
les progrs se mesurent par des programmes dmontrables, plutt que par des
documents ou des estimations comme dans le cycle de vie en cascade.
Lencadrement dispose ainsi dlments objectifs et peut valuer les progrs
et ltat davancement avec plus de fiabilit.
Une mini-cascade
Dans le cycle de vie itratif, chaque itration reproduit le cycle de vie en cascade,
une plus petite chelle. Les objectifs dune itration sont tablis en fonction de
39
Figure 351 : Le cycle de vie itratif repasse plusieurs fois par les phases du cycle de vie en
cascade.
Figure 352 : Exemple de transition progressive entre les activits dune itration.
Le cycle de vie itratif nengendre pas les problmes : il rvle prcocement des
problmes qui auraient t dtects tardivement avec le cycle en cascade. Le
cycle en cascade semble prvisible : les revues danalyse et de conception se
succdent dans les dlais prvus. Tout va bien jusqu' la phase dintgration o
mille turpitudes sont commises pour livrer quelque chose au client. Le cycle de
vie itratif commence mal et se termine bien, contrairement au cycle de vie en
cascade qui commence bien et se termine mal.
Le cycle de vie itratif est une excuse pour ne pas planifier et grer un projet.
Il est vrai que les dveloppeurs se sentent laise avec le cycle itratif, mais ce
nest pas parce que les uns sont heureux que les autres en particulier
lencadrement doivent tre malheureux. En effet, le cycle de vie itratif leur
fournit plus de points de mesure que le cycle en cascade et ces mesures sont plus
fiables : elles sont connectes sur la ralit de lvaluation dun prototype, plutt
que sur la virtualit de la lecture dune documentation.
Voil une ide fausse dont il faut absolument se dfaire. Lanalyse itrative ne
consiste pas rajouter toujours et encore de nouveaux besoins ; elle permet de se
concentrer dabord sur les besoins majeurs et dincorporer plus tard les besoins
secondaires. Le cycle de vie itratif vite la paralysie par lanalyse.
Pour rgler le problme de lexplosion des besoins, il faut imprativement aider (il
faudrait plutt dire forcer) les utilisateurs articuler leurs besoins dans un cadre
stable et structurant. Les cas dutilisation apportent une trs bonne technique
pour ce faire ; leur laboration oblige les utilisateurs imaginer comment ils
comptent utiliser le futur systme. Ceci reste difficile en labsence dlments
concrets critiquer, comme cest le cas avec le cycle en cascade qui, dans ses
premires phases, ne produit que des documents. Le cycle de vie itratif vient au
secours des utilisateurs en leur fournissant des prototypes valuer. Les
informaticiens peuvent de leur ct exprimenter leurs choix de ralisation en
vraie grandeur.
Ds le dbut du dveloppement, un cycle itratif produit des prototypes
documents qui peuvent tre valus objectivement. Il soppose au cycle en
cascade qui ne fournit que des documents. Dans le premier cas, le logiciel est mis
en avant ; dans le second cas, ce sont les sous-produits. A qualit dencadrement
gale, un cycle itratif produit des rsultats plus stables quun cycle linaire.
Le cycle en cascade ne secoue pas assez les utilisateurs ; les documents quil
produit ne procurent quune illusion de progrs ; rien ne dit que leur contenu
satisfait rellement les besoins. Les revues de conception se passent bien, le
projet suit le plan de dveloppement jusqu' la phase dintgration. L, plus rien
ne marche : de nombreuses rparations sont alors effectues dans la prcipitation,
sans recul suffisant, et cela se traduit par des retards et un produit fragile et
difficile maintenir.
Le diagramme suivant reprsente la courbe de connaissance des besoins dans
une approche itrative. Tous les besoins ne sont pas ncessairement connus ds
le dbut ; la connaissance des besoins peut progresser avec les itrations.
Figure 354 : Exemple de progression dans la connaissance des besoins dans le cadre dune
dmarche itrative.
Ladoption de lapproche itrative ne fait pas disparatre tous les problmes par
magie. Lapproche itrative est seulement un outil pour mieux grer les problmes.
There is no silver bullet40
La documentation
Les prototypes sont les principaux produits tangibles issus du cycle de vie
itratif, de sorte quil nest pas ncessaire de fournir des documents pour servir
de support aux revues de validation de fin de phase, comme dans le cycle en
cascade.
Il est nanmoins possible de construire une documentation conventionnelle
lorsque celle-ci est exige par contrat. Cette documentation est constitue de
documents danalyse et de conception par exemple dans le format normalis DoD
2167a.
40
Figure 355 : La documentation gnre par un dveloppement itratif est semblable dans sa
forme la documentation traditionnelle, mais reflte plus fidlement ltat final du projet.
41
Figure 356 : Cycle itratif en b. Cette forme de cycle itratif est bien adapte pour les projets
modestes ou bien dfinis.
Figure 357 : Cycle itratif en b avec quelques retouches sur les activits en amont de la
construction. Litration reste principalement concentre sur la construction.
Le cycle en b est tout fait adapt pour les dveloppements bien circonscrits.
Une grande part d'incertitude sur les besoins est plus grande, une architecture
Figure 358 : Cycle de vie itratif en O. Cette forme de cycle itratif est bien adapte pour les
grands projets.
Quelle que soit la forme du cycle de vie itratif retenue, il convient de conduire
lanalyse aussi loin que possible, sans tre paralys par la recherche de lanalyse
parfaite. Le cycle itratif, avec son exigence de livraisons rgulires de
programmes excutables, encourage les projets dcoller et produire des
rsultats concrets.
42
la revue de dpart qui fige les objectifs de litration, les critres dvaluation
et la liste des scnarios raliser,
la revue dvaluation qui valide les rsultats de litration par rapport aux
critres dfinis avant de drouler litration.
Pour des itrations plus longues, il faut prvoir plus de revues intermdiaires pour
lapprobation des plans de tests, la mise en place de lassurance qualit, etc.
Les rsultats de litration sont valus par rapport aux critres dvaluation
dfinis lors de la planification de litration. Ils sont fonction des performances,
des capacits et des mesures de qualit. Il faut galement prendre en compte les
ventuels changements externes, comme lapparition de nouveaux besoins ou la
dcouverte des plans de la concurrence, et dterminer sil faut reprendre certaines
parties du systme et les assigner aux itrations restantes.
La premire itration est la plus difficile conduire car elle demande la mise en
place de lensemble de lenvironnement de dveloppement et de lquipe. Le
projet rencontre gnralement de nombreux problmes avec les outils,
lintgration entre les outils, les relations au sein de lquipe.
Les quipes qui appliquent une approche itrative sont gnralement trop
optimistes. Il faut rester modeste et ne pas attendre trop de la premire itration,
faute de quoi les dlais vont tre dpasss, le nombre ditrations ventuellement
rduit et les bnfices de lapproche itrative limits.
Lquipe perd gnralement pas mal de temps travailler avec le nouveau
compilateur, mettre en place la gestion de versions et de configurations, les
tests de non-rgression et le million dautres choses qui doivent tre rgles lors
de la premire itration. Pour la deuxime itration, tout rentre dans lordre,
chacun sait comment procder avec les outils et lquipe peut se concentrer sur
les fonctionnalits.
Processus du projet A
Processus du projet B
Figure 362 : Il appartient chaque projet dadapter le processus abstrait dcrit de manire
gnrale dans ce paragraphe.
Le processus de dveloppement dun logiciel peut tre observ selon deux points
de vue complmentaires :
La vue de lencadrement
La vue de lencadrement reprsente le dveloppement du logiciel comme un
enchanement de quatre phases :
Les progrs sont mesurs en termes davancement dans les phases. Certains
logiciels demandent plusieurs cycles pour prendre en compte des amliorations,
des demandes de nouvelles fonctionnalits, etc. La phase de transition dune
gnration donne recouvre alors souvent la phase dtude dopportunit de la
gnration suivante. Dans le cas de grands projets, les cycles peuvent tre mens
en parallle et plusieurs sous-systmes sont dvelopps indpendamment.
Figure 365 : Dans le cas de grands projets, des dveloppements de sous-systmes peuvent tre
mens en parallle.
La vue technique
La vue technique se concentre sur la mise uvre et lordonnancement de toutes
les activits techniques qui conduisent la livraison dune gnration du logiciel.
Le cycle de dveloppement est peru comme une suite ditrations par lesquelles
le logiciel volue par incrments. Chaque itration dbouche sur la livraison dun
programme excutable. Le contenu dune itration doit tre utile pour le
dveloppement ou pour lutilisateur. Il est dtermin en choisissant un sousensemble des fonctionnalits de lapplication au sein des cas dutilisation.
Certaines livraisons sont purement internes, dautres servent dmontrer ltat
davancement, certaines enfin sont places chez lutilisateur. Ditration en
itration, le programme grandit en fonctionnalit et en qualit, jusqu' ce quune
itration particulire donne la premire gnration du logiciel.
Les activits traditionnelles ne sont pas effectues en squence comme dans un
cycle de vie en cascade ; elles sont distribues saupoudres sur les
diffrentes itrations. Chaque itration comprend des activits de planification,
danalyse, de conception, dimplmentation, de test et dintgration, dont le
nombre varie en fonction de la position de litration dans le cycle.
Le programme excutable qui rsulte dune itration est appel prototype. Un
prototype est une tape concrte de la construction dun logiciel. Il fait la preuve
tangible mesurable des progrs raliss. Un prototype est un sous-ensemble
Figure 367 : Les deux points de vue sont synchroniss en fin de phase. La fin dune phase est
marque par la validation dun prototype.
Mais avant tout, il faut bien comprendre que le plus grand risque consiste ne
pas savoir o sont les risques. Il faut aussi se mfier des quipes plthoriques et
prendre garde aux chefs de projet qui mesurent leur prestige au nombre de
dveloppeurs sous leur responsabilit. Il ne sert rien davoir beaucoup de
dveloppeurs : il faut avoir les bons et savoir les faire travailler en quipe. La
gestion des risques regroupe toutes les activits requises pour construire un plan
de rduction des risques et pour conduire ce plan terme.
Le plan de rduction des risques dcrit, pour chaque risque identifi :
lallocation un prototype.
La rduction du risque pilote les itrations dans le cycle de vie itratif. Chaque
itration a pour objectif dliminer une part du risque global associ au
dveloppement dune application. Le diagramme suivant illustre le mcanisme de
rduction du risque par les itrations. Chaque itration est construite comme un
petit projet, avec pour objectif la rduction dune partie des risques identifis lors
la dfinition du projet.
Figure 368 : Chaque itration est construite comme un petit projet, ddi llimination
dune partie des risques identifis lors de la dfinition du projet.
Lapproche itrative identifie et traite les risques plus rapidement dans le cycle de
vie, de sorte que le risque peut tre rduit de manire significative ds la phase
dlaboration. Ditration en itration, les prototypes excutables valident les
choix du projet de manire concrte et mesurable, et le niveau de confiance dans
lapplication augmente. Le diagramme suivant montre la dcroissance plus rapide
du risque dans un dveloppement itratif. La principale diffrence avec le
diagramme prcdent provient de laxe des abscisses, gradu par les multiples
itrations ; elles se concentrent toutes sur la rduction dune part du risque
global.
Chaque itration est base sur la construction dun nombre rduit de scnarios
qui sattaquent dabord aux risques les plus importants et dterminent les classes
et les catgories construire dans litration. Les catgories forment un espace de
travail bien adapt aux dveloppeurs.
Les testeurs utilisent les mmes scnarios pour construire le plan de test et les
procdures de test de litration. A la fin de litration, lvaluation dtermine les
risques qui ont t limins ou rduits. Le plan des prototypes est rvis en
consquence.
Le diagramme suivant montre un exemple de rpartition des risques entre deux
prototypes conscutifs. Il illustre leffet dune itration en terme de rduction de
risque.
Itration
N vers N+1
Prototype N
Prototype N+1
Figure 371 : Une itration a pour objectif la rduction du risque associ une partie de
lapplication. La partition des fonctionnalits de lapplication est ralise selon les cas
dutilisation.
Chaque prototype explore une partie de lapplication dans le but de rduire une
part des risques. Selon la nature des risques tudier, les prototypes senfoncent
plus ou moins profondment dans larchitecture.
Le diagramme suivant reprsente diffrentes sortes de prototypes :
Figure 372 : Exemples de prototypes. Chaque prototype explore une partie de lapplication.
Les prototypes sont enchans une fois que larchitecture a t valide. Chacun
de ces prototypes correspond un ou plusieurs cas dutilisation. A chaque
itration la couverture des besoins augmente.
Le diagramme suivant montre comment quatre prototypes ont t dploys pour
dvelopper une application. Les deux premiers prototypes ont d tre retouchs,
pour corriger larchitecture ou pour prendre en compte de nouveaux besoins.
45
que larchitecture est tablie et stabilise, les retouches restent faibles et bien
localises. La somme des retouches des itrations suivantes doit rester infrieure
25 %. Les pourcentages, indiqus dans le graphique suivant, se rapportent
lensemble du systme et pas seulement litration la plus rcente.
Figure 374 : Exemple de lvolution des retouches avec le droulement des prototypes. Une
fois larchitecture valide et stabilise, la somme des retouches reste infrieure 25 % du
total.
Exemples de risques
Tous les projets rencontrent des risques dont le nombre varie selon la taille, la
complexit, le degr de nouveaut du projet et les qualifications de lquipe de
dveloppement.
Certains risques sont frquents, du fait de la navet des participants, des
relations fausses entre client et fournisseur, de linstabilit des besoins, etc.
Les grandes causes dchec des projets sont souvent lies :
dans le cas de trs grands projets, la situation gopolitique bien plus quaux
aspects techniques,
Le tableau suivant rsume les dix principaux risques rcurrents et les actions
entreprendre pour les rduire.
Risque
Impact
Rsolution
Qualit
Absence de convergence
Cot
Middleware
Dlais
Dveloppement itratif
Qualit
Dveloppement itratif
Cot
Objectifs proches
Dlais
Cot
Dmotivation
Environnement de dveloppement
inadapt
Utilisateurs dfavorables
Dlais
Cot
Dlais
Dmonstration de prototypes
Cot
Dlais
Cot
Dlais
Prototypes
Performances insuffisantes
Qualit
Excs de bureaucratie
Dlais
Fonctions inadaptes
Qualit
Prototypes
Figure 375 : Rsum des dix principaux risques rcurrents et des actions entreprendre pour
les rduire.
Chaque organisation ou projet devrait dfinir une liste de critres pour dterminer
quelles fonctionnalits doivent tre dveloppes dans une itration donne. Le
tableau suivant dcrit des exemples de critres suffisamment gnraux pour tre
appliqus tous les projets.
Critre
Description
Intrt
Cot de fabrication
Nouveaut
Interfaces ncessaires
Politique
Technologie
Planification
Tremplin
Figure 376 : Exemples de critres dapprciation des risques pour la dtermination des
itrations.
Informatique
Logistique
Interface
Lquipe de dveloppement est organise par rapport aux cas dutilisation dcrits
prcdemment. Les diffrents intervenants sont reprsents par des acteurs qui
interagissent avec les trois cas dutilisation identifis.
Le dveloppement informatique
Le dveloppement informatique est conduit par les trois acteurs suivants :
46
Jacobson I., Ericson M., Jacobson A. 1994, The Object Advantage, Business
Process Reengineering with Object Technology. Addison Wesley.
Architecte
Informatique
Abstractionniste
Dveloppeur
La logistique
La logistique interagit avec les acteurs suivants :
Chef de projet
Analyste
Intgrateur
Logistique
Bibliothcaire
Qualiticien
Documentaliste
Administrateur
-systme
Outilleur
Linterface
Linterface interagit avec les acteurs suivants :
Utilisateurclient
Chef de
produit
Interface
Client
Chef de projet
Support
technique
Financier
Les rles dcrits prcdemment peuvent tre jous par la mme personne. Dans
les petites organisations, il est frquent que le chef de projet remplisse galement
les rles darchitecte et danalyste. De mme, les dveloppeurs et les
abstractionistes sont souvent confondus.
Ltude dopportunit
Ltude dopportunit nest gnralement pas mene par les informaticiens, mais
par des spcialistes de ltude des marchs et de lanalyse de la concurrence. Ils
essaient de dterminer si la construction dun nouveau systme ou une
amlioration majeure dun systme existant est conomiquement justifie et
prsente un intrt pour lentreprise.
La premire opration consiste se doter dune vision gnrale du produit afin de
mieux le caractriser et de dgager des lments dapprciation. Cette vision peut
se rsumer par la formule suivante47 :
Vision = Quoi + Pour qui +
Combien
Combien estime le prix que les acheteurs du produit seront disposs payer.
La vision gnrale du projet est exprime dans un cahier des charges prliminaire,
dans un cahier des non-objectifs qui prcise ce que le projet nest pas, et dans un
argumentaire financier qui donne les premiers lments conomiques, par exemple
en termes destimation du retour sur investissement.
Ces diffrents lments peuvent tre difficiles apprcier en labsence dlments
de mesures tangibles. Cest pourquoi ltude dopportunit se base souvent sur
une analyse prliminaire du domaine (10 20 % des classes). Lorsque les
47
incertitudes sur la faisabilit dun projet sont leves, il est frquent de conduire
un prototype conceptuel. Son but premier est de dgager des lments concrets
pour valuer les risques lis aux fonctionnalits attendues, aux performances
requises, la taille ou la complexit du sujet, ou encore ladoption de
nouvelles technologies. A partir de l, le concept du produit est valid ou non.
Ce genre de prototype ne respecte pas les rgles habituelles de dveloppement. Il
recherche avant tout un rsultat rapide, sans insister sur la fiabilit ou la rapidit
dexcution. Cest avant tout une maquette jetable dont le code ne rentre pas
dans lapplication finale. Elle gagne tre ralise dans un environnement de
prototypage rapide, comme Smalltalk. Certaines applications sont dveloppes
intgralement partir du premier prototype. Pour ce faire, des outils de
dveloppement rapide dapplication (RAD) sont utiliss. Cette approche
fonctionne pour des projets modestes, mais ne se prte gure des systmes
plus consquents.
A ce stade, lquipe est constitue dun petit nombre de personnes qui entourent
larchitecte du systme ou larchitecte du logiciel. Elles continueront de participer
au dveloppement du projet.
Par la suite, une fois que la vision du produit est dfinie et que les risques
inhrents au projet ont t identifis dans leurs grandes lignes, ltude
dopportunit essaie destimer le cot du projet et le retour sur investissement.
Lestimation des cots et le retour sur investissement
La dtermination du retour sur investissement est assez difficile effectuer dans
le cas de linformatique, en raison essentiellement de limmatrialit des logiciels
et du manque dlments objectifs pour apprcier a priori leur cot.
Il faut rechercher un quilibre entre la fiabilit de lestimation des cots et le dlai
ncessaire pour produire cette estimation. Lestimation fausse immdiate ou le
cot exact connu la fin du dveloppement ntant pas acceptables, il est
judicieux de dcomposer lestimation en plusieurs tapes, afin de laffiner
progressivement.
La figure suivante reprsente, qualitativement, la prcision de lestimation du cot
dun dveloppement logiciel.
Du fait du faible niveau de visibilit sur les besoins rels et sur la nature des
risques durant ltude dopportunit, il est fort peu raliste dessayer destimer
prcisment les ressources ncessaires au projet.
Nanmoins, cette estimation est frquemment demande par le client. Il faut alors
expliquer celui-ci que la seule manire davoir une bonne ide du cot, cest de
financer une premire tranche jusqu la fin de la phase dlaboration. A la lumire
de linformation rcolte, il pourra dcider de poursuivre ou non leffort de
dveloppement, avant daborder la monte en charge de la phase de construction.
Lapproche objet seule ne permet pas dvaluer le cot final plus rapidement que
les approches traditionnelles. En revanche, associe une dmarche itrative, elle
permet de garantir une dtermination plus prcise de ce cot partir de la phase
dlaboration.
Pour un petit projet, ltude dopportunit est souvent rduite un cahier des
charges. Pour un projet moyen, dune anne environ, ltude dopportunit
fabrication du prototype incluse prend approximativement un mois. Pour un
gros projet, le prototype devient un petit projet part entire, souvent dnomm
dmonstrateur, et passe lui-mme par les diffrentes phases nonces plus haut.
La phase dlaboration
La phase dlaboration commence par lanalyse des besoins et par la modlisation
du domaine. Elle a pour objectif de dfinir les choix darchitecture, dexplorer et de
rduire les risques du projet, et finalement de dfinir un plan complet qui quantifie
les moyens mettre en uvre pour mener bien le dveloppement.
La phase dlaboration est conduite par une quipe restreinte, emmene par
larchitecte logiciel. Elle est constitue dun petit groupe de dveloppeurs et d'un
ou deux experts du domaine ou dutilisateurs. Il est souvent judicieux dadjoindre
un reprsentant de lquipe de test et dassurance qualit, un outilleur
Figure 382 : Exemple de ralisation dun cas dutilisation par une collaboration entre trois
objets.
un plan dtaill des itrations, les critres dvaluation et le cahier des charges
de chaque itration et les rsultats de lassurance qualit ;
La phase de construction
Cette phase a pour objectif de dvelopper un produit logiciel prt pour la
transition dans la communaut des utilisateurs. Dans les cycles itratifs en b, la
phase de construction correspond la mise en uvre effective des itrations.
Certaines itrations sont purement internes, dautres sont galement visibles
lextrieur du projet. Chaque itration produit la livraison dun prototype
excutable.
Un prototype force la fin dune itration et oblige lquipe de dveloppement
fournir un rsultat concret, mesurable. Un prototype est stable et autosuffisant ;
une plus grande stabilit, mesure par la rduction dans les changements
apports aux modles ;
quun prototype est une tape, pas un systme complet, sinon les frustrations
peuvent tre grandes.
En cas durgence, il vaut mieux reporter des fonctionnalits que manquer un
rendez-vous avec les utilisateurs. Tout prototype dmontrable, mme incomplet,
augmente le niveau de confiance des utilisateurs, et par suite du client. Il faut
toutefois prendre garde leffet congre qui se caractrise par une accumulation
de fonctionnalits non satisfaites, toujours remises la prochaine livraison. Il faut
essayer de tenir le plan des livraisons car la tendance naturelle est de repousser
les livraisons en raison du retard pris par rapport la ralisation des
fonctionnalits. En repoussant la fin des itrations, et par suite la livraison des
prototypes, le danger est grand de revenir au modle en cascade et de perdre les
avantages de la dmarche itrative.
Les catgories permettent dallouer les responsabilits dans lquipe. Les petits
changements sont pris en compte lintrieur dune classe ou dune catgorie.
Les grands changements demandent la coordination entre les responsables de
chaque catgorie et une remonte de la dcision au niveau de larchitecte. Il est
normal de devoir jeter du code en phase de construction. En revanche, au-del de
25 % de changements cumuls dans les livraisons de construction, larchitecture
doit tre considre comme instable. Linstabilit de larchitecture est
gnralement le signe dune phase dlaboration qui na pas donn une place
suffisante lexprimentation.
La phase de transition
La phase de transition consiste transfrer le logiciel dans la communaut de ses
utilisateurs. Cette phase est dune complexit variable selon le type
dapplication ; elle comprend la fabrication, lexpdition, linstallation, la
formation, le support technique et la maintenance. Lquipe de dveloppement se
rduit un petit groupe de dveloppeurs et testeurs, assists temps partiel par
larchitecte, garant de la cohrence de lensemble, et par un documentaliste
responsable de la mise jour de la documentation. Le relais est pass au
personnel du support technique, ainsi quaux formateurs et aux commerciaux.
En phase de transition, le dveloppement initial est presque termin ; tous les
artefacts ont atteint suffisamment de maturit pour tre distribus largement vers
deux catgories de destinataires : les utilisateurs et les responsables du projet.
Les principaux produits destination des utilisateurs comprennent :
La dure de la phase de transition est trs variable selon le critre de fin de phase.
Si la fin est indique par le client au cours dun processus de recette, la transition
dure au maximum un mois pour un projet dune anne. En revanche, si la fin du
projet correspond la fin de la vie du projet, la transition peut tre beaucoup plus
longue.
Conseils pratiques sur la transition
La difficult de cette phase est inversement proportionnelle la qualit du produit
et au degr de prparation des utilisateurs. Tous les produits ncessitent une
formation. Il ne faut pas ngliger la phase dinstallation du produit ; une
installation difficile peut dcourager les utilisateurs et rduire leur confiance dans
le produit.
Pour un systme de remplacement, beaucoup d'efforts sont ncessaires pour
mettre en place le nouveau systme en parallle avec le systme existant.
Dans certaines organisations, lquipe de maintenance et lquipe de
dveloppement sont nettement dissocies. Cette situation nest pas optimale car
elle engendre une rupture trop nette dans le cycle de dveloppement. Elle induit
surtout un moment de flottement dans le partage des responsabilits, entre les
dveloppeurs initiaux et les dveloppeurs de maintenance. Il est plus judicieux
dassurer un recouvrement entre les deux quipes, en incluant des personnes du
support technique et de la maintenance ds le dbut du projet et en assignant
temps partiel quelques dveloppeurs initiaux dans lquipe de maintenance.
Figure 383 : Rpartition typique des activits au sein des phases de la vue de lencadrement.
les tests et les mesures de qualit se rpartissent sur toutes les phases et
concernent tous les prototypes ;
Le tableau suivant rsume les objectifs et les points de dcisions rapports aux
itrations de la vue technique et aux phases de la vue de lencadrement.
Itration
Phase
Objectif
Itration prliminaire
Etude dopportunit
Comprendre le
problme
Point de dcision
Allouer les
ressources pour
llaboration
Itration
darchitecture
Elaboration
Comprendre la
solution
Itration
darchitecture
Elaboration
Comprendre la
solution
Allouer les
ressources pour la
construction
Itration de
dveloppement
Construction
Raliser la solution
Itration de
dveloppement
Construction
Raliser la solution
Itration de
dveloppement
Construction
Raliser la solution
Livrer le produit
Itration de transition
Transition
Transmettre la
solution
Itration de transition
Transition
Transmettre la
solution
Recette par le client
Figure 386 : Tableau rcapitulatif des objectifs et des points de dcisions rapports aux
itrations et aux phases.
Le tableau suivant rcapitule les tapes, les points de mesure et les rsultats de
chaque phase.
Phase
Etape
Mesure
Rsultat
Etude
dopportunit
Plan marketing
Compltude dun
prototype
Lancement effectif du
projet
Prototype excutable
Risque
Elaboration
Stabilit
80 % des scnarios
Simplicit
80 % du modle du
domaine
Compltude des
livraisons
Produit complet
Modle du domaine
Architecture
Construction
Prototypes
Plan de dploiement
Taux de dfauts
Documentation
complte
Densit de dfauts
Qualit satisfaisante
Stabilit
Transition
Versions bta
Satisfaction des
utilisateurs
Version dfinitive
Taux de dfauts
Densit de dfauts
Stabilit
Figure 387 : Tableau rcapitulatif des tapes, des points de mesure des rsultats de chaque
phase.
5
Etude de cas :
application de contrle
daccs un btiment
Ce chapitre prsente lutilisation dUML pour la modlisation objet dun systme
de contrle des accs un btiment.
Ltude de cas dcrite dans ce paragraphe est inspire dune application
dploye lESSAIM (Ecole Suprieure des Sciences Appliques pour
lIngnieur Mulhouse).
Le modle de cet exemple ralis avec loutil Rational Rose est disponible sur
le CD-ROM qui accompagne louvrage.
Le processus
Ltude de cas dbute directement par lanalyse des besoins. Les besoins du
systme sont dtermins partir de linformation recueillie durant linterview du
superviseur du futur systme. Ces besoins sont exprims sous la forme de cas
dutilisation, dans un langage trs proche des utilisateurs.
Ltude des cas dutilisation demande de choisir le niveau de granularit des
informations reprsentes dans les interactions ; ce qui pose souvent le problme
du petit rocher ou du gros caillou. Dans lexemple suivant, les cas dutilisation
sont dlibrment considrs comme des lments forte granularit.
La dfinition des droits daccs est effectue en dcrivant pour chaque groupe de
personnes les diffrents groupes de portes qui sont accessibles et sous quelles
contraintes horaires. Les droits daccs sont dcrits dans un calendrier annuel qui
dcrit la situation semaine par semaine. Etant donn la faible variation des droits
dans le temps, un calendrier peut tre initialis au moyen de semaines types qui
dcrivent une configuration de droits donne. Le superviseur peut crer autant de
semaines types quil le dsire. Les changements apports une semaine type
sont automatiquement propags dans tous les calendriers qui utilisent cette
semaine type. Les changements apports directement dans un calendrier, par
exemple pour prendre en compte un jour fri, ne sont pas affects lors de la
modification dune semaine type.
La figure suivante reprsente une semaine type. Les parties en gris
correspondent aux plages horaires pendant lesquelles laccs nest pas autoris.
Lundi
00
01
01
02
...
...
06
07
07
08
08
09
...
...
21
22
22
23
23
24
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche
superviseur,
gardien,
porteur de badge.
Superviseur
Porteur de
badge
Gardien
Les acteurs interagissent avec le systme. Ltude des cas dutilisation a pour
objectif de dterminer ce que chaque acteur attend du systme. La dtermination
des besoins est base sur la reprsentation de linteraction entre lacteur et le
systme. Cette approche prsente lavantage de forcer lutilisateur dfinir
prcisment ce quil attend du systme.
Cas dutilisation
Superviseur
Configuration du systme
Gardien
Exploitation du systme
Utilisateur
Superviseur
Configuration
Identification
Contrle d'accs
Porteur de badge
Surveillance
Gardien
Configuration
La configuration est dclenche par le superviseur.
Superviseur
Configuration
Identification
Le superviseur se connecte au systme et donne son mot de passe.
Le systme vrifie lidentit du superviseur et autorise la connexion.
: Systme
: Superviseur
Login (mot de passe)
Vrification
Autorisatio
: Systme
: Superviseur
Modification d'une porte
Liste des portes
Choix d'une porte
Informations de la porte
: Systme
: Superviseur
Modification d'une personne
Liste des personnes
Choix d'une personne
Informations de la personne
Modification des informations
Informations de la personne
Sauvegarde des informations
: Systme
: Superviseur
Modification d'un groupe de personnes
Liste des groupes
Choix d'un groupe
Informations du groupe
Modification des informations
Informations du groupe
Sauvegarde des informations
: Systme
: Superviseur
: Systme
: Superviseur
Recherche d'une personne (badge)
Informations de la personne
: Systme
: Superviseur
Recherche portes franchissables (personne)
Liste de portes
Choix d'une porte
Informations sur la porte
Figure 399 : Recherche des portes franchissables par une personne donne.
: Systme
: Superviseur
Recherche des groupes d'une personne
Liste des personnes
Choix d'une personne
Liste de groupes
Figure 400 : Recherche des groupes qui contiennent une personne donne.
: Superviseur
: Systme
: Superviseur
: Systme
Figure 402 : Modification des accs dun groupe de personnes un groupe de portes.
: Systme
: Superviseur
: Systme
: Superviseur
Figure 404 : Recherche des droits daccs dune personne pour une porte donne.
Surveillance
La surveillance est dclenche par le gardien.
Surveillance
Gardien
Identification
Le gardien se connecte au systme et donne son mot de passe.
Le systme vrifie lidentit du gardien et autorise la connexion.
: Systme
: Gardien
Login (mot de passe)
Vrification
Autorisation
: Systme
: Gardien
Rapport vnements (Priode)
Loop
Evnements
End loop
: Systme
: Gardien
Purge (Priode)
: Systme
: Superviseur
Rapport alarmes (Priode)
Liste des alarmes
Loop
Delay Priode
End loop
: Systme
: Gardien
Incendie
Le gardien dclenche lalarme incendie.
Le systme ouvre toutes les portes.
: Systme
: Gardien
Incendie
Ouverture de toutes les portes
Contrle daccs
Le contrle daccs est dclench par le porteur de badge.
Contrle d'accs
Porteur de badge
Autorisation de passage
La personne prsente son badge.
Le systme dtermine si laccs est autoris.
Si laccs est autoris
Le systme commande louverture de la porte.
: Systme
: Porteur de
badge
Prsente son badge
Ouvre la porte
End if
Scnarios principaux
Configuration
Identification
Configuration
Configuration
Configuration
Configuration
Configuration
Cas dutilisation
Scnarios principaux
Configuration
Configuration
Configuration
Configuration
Configuration
Configuration
Affichage des droits daccs dune personne pour une porte donne
Surveillance
Identification
Surveillance
Surveillance
Surveillance
Surveillance
Surveillance
Incendie
Contrle
daccs
Autorisation de passage
Contrles de cohrence
Les contraintes suivantes doivent tre prise en compte par le systme :
une porte doit toujours tre au moins dans son propre groupe,
une personne doit toujours tre au moins dans son propre groupe,
les plages horaires dfinies dans une journe ne doivent pas se chevaucher.
Figure 414 : Ralisation dun cas dutilisation par une collaboration entre objets du
domaine.
Utilisateur
Systme
<<Vue>>
I_Personne
<<Substitut>>
Personne
Dans un systme dinformation, les informations qui font foi sont celles
contenues dans le systme. Dans un systme automatis, la vrit est toujours
lextrieur du systme. Dans les deux cas, il importe de bien synchroniser ltat de
la trilogie dobjets.
Les acteurs ninterviennent plus directement dans les collaborations.
Linteraction avec les utilisateurs est exprime sous la forme de messages
envoys et reus par les objets dinterface. Le niveau de granularit de ces objets
est variable, mais en rgle gnrale les mcanismes reprsents en termes dobjets
collaborants vitent daller trop loin dans les dtails de la ralisation de linterface
utilisateur. Il y a deux raisons cela : dune part, faciliter la lecture des
diagrammes, et dautre part, favoriser la rutilisation des objets mtiers.
Linterface est toujours trs dpendante de chaque application. En revanche, les
objets mtiers peuvent souvent tre rutiliss par dautres applications.
Configuration
Identification du superviseur
Dans un premier temps, lacteur peut tre conserv pour reprsenter de manire
compacte linterface utilisateur.
2: LireMotDePasse
1: LireNom
: Login
: Superviseur
3: Vrifier (MotDePasse)
Superviseur : Personne
Figure 416 : Reprsentation dune collaboration entre des objets du domaine et un acteur.
2: LireMotDePasse
1: LireNom
: Login
3: Vrifier (MotDePasse)
Superviseur : Personne
Figure 417 : Reprsentation globale de linterface utilisateur au moyen dun objet de classe
LimiteDuSystme.
Par la suite, les grandes lignes de linterface utilisateur peuvent tre dcrites au
moyen de classes qui reprsentent les diffrentes fentres. Dans ce cas, le but
nest pas de dcrire de manire prcise les classes graphiques de linterface, mais
plutt de capturer la forme gnrale des interactions et ainsi de quantifier la
charge de travail pour le dveloppement de linterface. La fabrication de
linterface proprement dite est du ressort doutils spcialiss dans la construction
et la gnration automatique des interfaces graphiques.
Par convention, chaque objet du domaine est visualis par un objet dinterface de
mme nom, prfix par la lettre F. Dans le diagramme suivant, lobjet de classe
Login est accessible par lintermdiaire dun objet graphique F_Login.
4: Cacher ( )
2: Lire (Nom, MotDePasse)
1: Afficher ( )
: F_Login
: Login
: F_Configuration
5: Afficher ( )
3: Correct ? ( MotDePasse)
Superviseur : Personne
Figure 418 : Ralisation de la connexion au systme par une collaboration entre objets.
Login
1
1
F_Configuration
Personne
Login
Lecture nom
entry: Invite nom
Nom lu
Lecture mot de passe
entry: Invite mot de passe
Nom ou
mot de
passe
incorrect
Mot de passe lu
Vrification
Les classes dinterface utilisateur drivent toutes les deux dune classe
Fentre qui dfinit les oprations Afficher() et Cacher().
Fentre
Afficher( )
Cacher( )
F_Login
F_Configuration
: Porte
5: Image ( )
6: Valeur ( )
: Porte
: L_Portes
Porte
F_Porte
L_Portes
Porte
Les classes dont le nom est prfix par une lettre L reprsentent des classes
dinterface utilisateur spcialises dans la reprsentation de listes dlments. Ces
classes possdent une opration Slection() qui permet de rcuprer
llment slectionn par lutilisateur dans la liste. Les classes de visualisation de
listes sont galement des fentres, comme le montre le diagramme de classe
suivant :
Fentre
Afficher( )
Cacher( )
Liste
Slection( )
L_Portes
L_Personnes
5: Image ( )
6: Valeur ( )
: GroupeDePortes
: L_GroupeDePortes
F_Configuration
F_Porte
F_GroupeDePortes
Porte
GroupeDePortes
Diagramme de collaboration
4: Afficher (Personne slectionne)
: F_Configuration
: F_Personne
1: Afficher ( )
2: Slection ( )
3: Cacher ( )
5: Image ( )
6: Valeur ( )
: Personne
: L_Personnes
F_Personne
L_Personnes
Personne
: Personne
Diagramme de collaboration
4: Afficher (Groupe slectionn)
: F_Configuration
: F_GroupeDePersonnes
1: Afficher ( )
2: Slection ( )
3: Cacher ( )
5: Image ( )
6: Valeur ( )
: GroupeDePersonnes
: L_GroupeDePersonnes
F_GroupeDePersonnes
L_Personnes
GroupeDePersonnes
: Porte
Diagramme de collaboration
4: Afficher (Porte slectionne)
: F_Configuration
: F_GroupeDePortes
1: Afficher ( )
2: Slection ( )
3: Cacher ( )
5: Image ( )
6: Valeur ( )
: GroupeDePortes
: L_GroupeDePortes
F_GroupeDePortes
L_Portes
GroupeDePortes
: Groupe de personnes
: Superviseur
Diagramme de collaboration
: Personne
: F_Configuration
2: Existe ? (Badge)
1: Afficher ( )
: GroupeDePersonnes
: F_RecherchePersonne
: Personne
3: Afficher ( )
: F_Personne
4: Image ( )
5: Valeur ( )
F_RecherchePersonne
GroupeDePersonnes
F_Personne
Personne
: Porte
Figure 441 : Recherche des portes franchissables par une personne donne.
Diagramme de collaboration
8: Afficher ( )
: F_Configuration
9: Image ( )
10: Valeur ( )
4: ListePortes
3: Cacher ( )
2: Slection ( )
1: Afficher ( )
: L_Personnes
: F_Porte
5: Afficher ( )
6: Slection ( )
7: Cacher ( )
: Porte
: L_Portes
: Personne
: Porte
: GroupeDePortes
F_Porte
Porte
L_Personnes
L_Portes
*
1
GroupeDePortes
Personne
: Personne
1: Choisir une personne
: Superviseur
2: Lire les informations
: Groupe de personnes
Figure 444 : Recherche des groupes qui contiennent une personne donne.
Diagramme de collaboration
4: GroupeDePersonnes ( )
: F_Configuration
: Personne
Personne slectionne
1: Afficher ( )
2: Slection ( )
3: Cacher ( )
5: Afficher ( )
: L_GroupeDePersonnes
: L_Personnes
: GroupeDePersonnes
Personne
*
GroupeDePersonnes
*
L_Personnes
L_GroupeDePersonnes
1: Choisir un groupe
: Groupe de personnes
: Superviseur
: Personne
2: Lire les informations
Diagramme de collaboration
4: Afficher ( )
: F_Configuration
: L_Personnes
1: Afficher ( )
2: Slection ( ) Groupe slectionn
3: Cacher ( )
: L_GroupeDePersonnes
: GroupeDePersonnes
L_Personnes
L_GroupeDePersonnes
GroupeDePersonnes
*
: Groupe de personnes
1: Choisir un groupe
2: Lire les informations
: Personne
3: Modifier les informations
: Superviseur
: Accs
4: Modifier les informations
: Calendrier
: Groupe de portes
Figure 450 : Modification des accs dun groupe de personnes un groupe de portes.
Diagramme de collaboration
4: Afficher ( )
5: Accs ( )
: F_GroupeDePersonnes
: F_Configuration
1: Afficher ( )
2: Slection ( )
3: Cacher ( )
Rsultat 2
6: Afficher ( )
: L_GroupeDePersonnes
: GroupeDePersonnes
9: Afficher ( ) : F_Accs
: F_Calendrier
7: Image ( )
8: Valeur ( )
: Accs
10: Image ( )
11: Valeur ( )
: GroupeDePersonnes
: GroupeDePortes
: Calendrier
L_GroupeDePersonnes
F_GroupeDePersonnes
F_Accs
F_Calendrier
*
GroupeDePersonnes
Accs
GroupeDePortes
Calendrier
: Semaine type
: Superviseur
Diagramme de collaboration
4: Afficher ( )
: F_Configuration
3: Cacher ( )
2: Slection ( )
1: Afficher ( )
: L_SemaineType
: F_SemaineType
5: Image ( )
6: Valeur ( )
: Semaine type
F_SemaineType
L_SemaineType
Semaine type
: Porte
1: Choisir une porte
3: Lire les informations
: Calendrier
: Superviseur
: Personne
Figure 456 : Recherche des droits daccs dune personne pour une porte donne.
Diagramme de collaboration
Les liens annots par un numro entre parenthses ont t crs par lopration
dclenche par le message de rang correspondant au numro.
: F_Configuration
3: Cacher ( )
2: Slection ( )
1: Afficher ( )
: L_Portes
4: Afficher ( )
5: Slection ( )
6: Cacher ( )
7: Afficher ( )
(2)
: F_Calendrier
: L_Personnes
(3)
8: Image ( )
9: Valeur ( )
: Porte
: Calendrier
: Personne
: GroupeDePortes
: Accs
: GroupeDePersonnes
L_Portes
F_Calendrier
L_Personnes
Porte
Calendrier
Personne
*
*
1
GroupeDePortes
*
Accs
GroupeDePersonnes
Surveillance
Identification du gardien
2: Login (nom, mot de passe)
: Gardien
Portier
: Utilisateur
Diagramme de collaboration
: F_Login
3: Cacher ( )
2: Lire (Nom, MotDePasse)
1: Afficher ( )
: Login
: F_Configuration
4: Afficher ( )
5: Correct ? ( MotDePasse)
Gardien : Personne
Login
1
1
F_Configuration
Personne
: Evnement
: Gardien
Diagramme de collaboration
: F_Surveillance
1: Afficher ( )
: L_Evnements
: Evnement
F_Surveillance
L_Evnements
Evnement
1: Dtruire (priode)
: Evnement
: Gardien
Diagramme de squence
Linteraction est reprsente ici au moyen dun diagramme de squence qui est
plus expressif quun diagramme de collaboration pour la reprsentation des
structures de contrle.
: F_Surveillance
: F_Purge
: Itrateur
Valeur ( ) :
Evnement
Afficher ( )
Initialiser (Priode )
Fini ( )
Valeur ( )
Dtruire ( )
Suivant ( )
fin
F_Surveillance
F_Purge
Itrateur
Evnement
Alarme : Evnement
: Gardien
Diagramme de collaboration
: F_Configuration
: F_Alarme
1: Afficher ( )
: L_Evnements
2: Image ( )
: Anomalie
F_Configuration
F_Alarme
L_Evnements
Anomalie
: Porte
: Gardien
2: Ouvre la porte
: Porte
Diagramme de collaboration
4: Afficher ( )
: F_Surveillance
3: Cacher ( )
2: Slection ( )
1: Afficher ( )
: L_Portes
: F_Porte
5: Image ( )
6: Ouvrir ( )
: Porte
F_Surveillance
F_Porte
L_Portes
Porte
Incendie
: Porte
: Gardien
Diagramme de squence
: F_Surveillance
: Porte
*
Porte
Contrle daccs
Autorisation de passage
1: Ouvrir (Badge)
Portier
2: Personne ? (Badge)
: Personne
: Porteur de
badge
: Badge
Diagramme de collaboration
: Lecteur de badge
: Personne
2: Badge (Badge)
3: ListeAccs ( )
: GroupeDePortes
: Accs
: GroupeDePersonnes
Lecteur de badge
Badge
Porte
Personne
GroupeDePortes
Accs
GroupeDePersonnes
Analyse
Analyse du domaine
Les cas dutilisation segmentent lespace des besoins selon le point de vue dun
acteur la fois. La description donne par les cas dutilisation est purement
fonctionnelle et il convient de prendre garde ne pas embrayer vers une
dcomposition fonctionnelle plutt que vers une dcomposition objet. Les cas
dutilisation doivent tre vus comme des classes de comportement.
UML ralise les cas dutilisation au moyen de collaborations entre objets issus du
domaine de lapplication. Chaque collaboration regroupe un contexte dobjet et
une interaction entre ces objets. Le contexte des objets est exprim de manire
particulire dans les diagrammes de collaboration et de manire gnrale dans les
diagrammes de classes. Ces diagrammes de classes ont t bauchs dans le
paragraphe prcdent.
Le diagramme de classes suivant est obtenu automatiquement (grce loutil
Rose) partir de ces diffrentes bauches.
Lecteur de badges
Adresse
Anti-retour
Site
Temporisation
1
Type d'vnements
Veille
Porte
Numro de porte
1 Numro de salle
*
0..4000
GroupeDePortes
Nom
Badge
Validit
Numro de site
Numro de badge
*
Accs
1
Personne
Prnom
Nom
GroupeDePersonnes
Nom
Figure 480 : Diagramme de classes obtenu par synthse automatique des diffrentes
bauches.
Lecteur de badges
Adresse
Anti-retour
Site
Temporisation
1
Type d'vnements
Veille
1
Porte
Numro de porte
1 Numro de salle
*
1
0..4000
Badge
Validit
Numro de site
Numro de badge
GroupeDePortes
Nom
*
Accs
Calendrier
*
1
Personne
Prnom
Nom
GroupeDePersonnes
Nom
*
Semaine type
Analyse de lexistant
LEssaim dispose dj dun certain nombre de lecteurs de badges et dsire les
rutiliser dans le nouveau systme de contrle daccs. Ces lecteurs de badges
peuvent fonctionner de manire totalement autonome ; ils sont programmables
sur place au moyen de badges particuliers ou distance via une liaison srie.
Tous les lecteurs sont esclaves du systme de contrle : un lecteur nest jamais
lorigine dune interaction.
une adresse sur le rseau (il peut y avoir jusqu' 64 lecteurs connects au
rseau),
8 plages horaires,
Horloge
1
Plage horaire
8
Lecteur de badges
Adresse
Anti-retour
1
1 Site
Temporisation
Type d'vnements
1 Veille
1
ToutOuRien
1
Evnement
0..100
1
0..4000
Badge
Mise lheure
Chaque lecteur contient une horloge logicielle. En cas de coupure de courant, le
lecteur enregistre un vnement spcial lors de sa remise sous tension et ne gre
plus les plages horaires. Lhorloge doit alors tre remise lheure par le systme
de contrle pour que le lecteur fonctionne nouveau avec les plages horaires. La
diffrence entre lheure de lhorloge et lheure relle donne la dure de la coupure.
Horloge
Jour
Heure
Minute
Plages horaires
Une plage horaire est associe chaque badge ou groupe de badges. Un lecteur
contient la description de 8 plages horaires. Une plage horaire permet de
restreindre les accs en fonction du jour et de l'heure de prsentation du badge.
Les 7 premires plages sont configurables par le superviseur, la dernire plage est
le passe tout temps. Chaque plage horaire comporte 3 sous-plages qui ne doivent
pas se recouvrir.
Les plages se prsentent de la manire suivante :
Sous-plage
LU
MA
ME
JE
VE
SA
DI
00:00-00:00
00:00-00:00
00:00-00:00
Figure 484 : Plage horaire.
SousPlage
PlageHoraire
Dbut
3 Fin
Jour
1
Droit
Evnements
Les vnements sont mmoriss suivant les critres de paramtrage (tous les
vnements ou seulement les anomalies). Chaque lecteur peut enregistrer au
maximum 100 vnements entre 2 interrogations provenant du systme matre.
Aprs interrogation les vnements sont effacs. La mmoire du lecteur est
organise sous la forme dun tampon circulaire. Les plus vieux vnements sont
effacs en cas de dbordement de la mmoire.
Chaque vnement contient les informations suivantes :
la date,
le numro de badge,
Evnement
Date
Numro de carte
Tte
carte accepte,
coupure secteur,
Evnement
Anomalie
Coupure secteur
Anti-retour
Hors plage
Carte refuse
Lecteur en veille
Normal
Carte accepte
Mauvais site
Non programme
Types de messages
La communication entre les lecteurs de badges et le systme matre est effectue
par des messages issus des trois grandes catgories suivantes :
Message
Simple
Fixe
Variable
Messages simples
Les messages simples regroupent des messages de synchronisation, des
requtes de rapport et des commandes.
Message
Simple
Synchronisation
Requte
Commande simple
acquittement,
non acquittement,
requte vnements,
requte horloge,
Synchronisation
Acquittement
Non acquittement
Requte
Req_Evnements
Req_CartesValides
Req_Paramtres
Req_Horloge
Req_CartesInvalides
Req_CodeSite
Commande simple
Cmd_MiseEnVeille
Cmd_FinVeille
Cmd_OuverturePorte
Message
Longueur fixe
Commande fixe
Rapport fixe
Commande fixe
Cmd_Paramtres
Cmd_ValidationCarte
Cmd_ValidationGroupe
Cmd_InvalidationCarte
Cmd_InvalidationGroupe
Cmd_Horloge
Cmd_PlageHoraire
Cmd_CodeSite
rapport horloge,
Rapport fixe
Rpt_Paramtres
Rpt_Horloge
Rpt_PlageHoraire
Rpt_CodeSite
Message
Longueur variable
Rapport variable
rapport vnement,
Rapport variable
Rpt_Evnements
Rpt_CartesValides
Rpt_CartesInvalides
Adresse
Check-sum
Donnes
Fin
1 octet
1 octet
2 octets
0..n octets
2 octets
01H
00H .. 3FH
F1H F2H
Trame
Dbut : Byte : = 01H
Adresse : Byte
Somme1 : Byte
Somme2 : Byte
Fin1 : Byte : = F1H
Fin2 : Byte : = F2H
Donne
* Valeur : Byte
{Ordonne}
Image( )
Valeur( )
Prfixe lu
Attente longueur
Longueur lue
Octet lu[ Cpt < Longueur ]
Architecture
Architecture logicielle
Ces lecteurs de badges peuvent tre reprsents par un acteur. Dans le
diagramme suivant, le lecteur de badges est reprsent par une classe strotype
pour insister sur le fait quil sagit dune classe de dispositifs matriels et non de
personnes.
Superviseur
Lecteur de badge
<<Acteur>>
Porteur de
badge
Gardien
Contrle d'accs
Porteur de badge
Figure 502 : Le cas dutilisation du contrle des accs est dport vers les lecteurs de badges.
Lecteur de badges
Superviseur
<<Acteur>>
Configuration
Identification
Contrle d'accs
Porteur de badge
Surveillance
Gardien
La structure de la vue logique prend la forme suivante. Les objets mtiers sont
regroups dans un paquetage Domaine. Les composants miroirs de ces objets
du domaine sont contenus dans le paquetage IHM. La couche la plus basse
IHM
Domaine
Utilitaires
global
Persistance
Lecteur
physique
Machine
virtuelle
Architecture matrielle
Le systme est constitu dlments logiciels et matriels, interchangeables dans
une large mesure.
Les lecteurs de badges sont interconnects au moyen dun rseau spcifique,
indpendant de lIntranet. Le poste de travail du superviseur et la station de
contrle du gardien sont galement connects ce rseau ddi au contrle
daccs. Il peut y avoir jusqu' 64 lecteurs de badges connects au rseau.
PC
superviseur
PC
gardien
{1}
{1}
1
<<RS422>>
1
Prcdent
Lecteur de
badges
<<RS422>>
1
{64}
1
Suivant
<<RS422>>
Ralisation
Cette tude de cas a pour objectif de prsenter la modlisation objet avec UML,
de sorte que la ralisation nest pas dcrite ici en dtail. Les grandes tapes de la
ralisation comprennent :
Annexes
A1
Les lments standard
Les strotypes, les tiquettes et les contraintes sont les mcanismes mis la
disposition de l'utilisateur pour l'extension d'UML.
Strotypes prdfinis
Les strotypes prdfinis par UML sont prsents par ordre alphabtique dans
le tableau suivant. Les trois colonnes contiennent respectivement le nom du
strotype, llment de modlisation auquel il sapplique et la description
dtaille de sa smantique.
Nom
Sujet
Smantique
acteur
type
ami
dpendance
appel
dpendance
application
composant
besoin
note
bibliothque
composant
contrainte
note
copie
dpendance
Nom
Sujet
Smantique
drive
dpendance
devient
dpendance
document
composant
numration
type primitif
envoi
dpendance
tend
gnralisation
faade
paquetage
fichier
composant
flot
classe active
import
dpendance
instance
dpendance
interface
type
liaison
dpendance
collaboration
mtaclasse
dpendance
type
page
composant
powertype
dpendance
type
processus
classe active
raffinement
dpendance
rle
dpendance
signal
classe
souche
paquetage
sous-classe
gnralisation
sous-type
gnralisation
Nom
Sujet
Smantique
du super-type, et devient un type du super-type
table
composant
trace
dpendance
utilise
dpendance
utilitaire
type
Etiquettes prdfinies
Les tiquettes prdfinies par UML sont prsentes par ordre alphabtique dans
le tableau suivant. Les quatre colonnes contiennent respectivement le nom de
ltiquette, le domaine de dfinition de sa valeur, llment de modlisation auquel
elle sapplique et la description dtaille de sa smantique.
Nom
Valeur
Sujet
Smantique
documentation
chane
lment
commentaire, description ou
explication
invariant
non interprt
type
localisation
composant
lment de
modlisation
nud
composant
numration
type
permanence de l'tat
{transitoire,
persistant}
instance
post-condition
non interprt
opration
pr-condition
non interprt
opration
responsabilit
chane
type
smantique
non interprt
type
spcification de la smantique
persistance
attribut
opration
smantique
spatiale
non interprt
smantique
temporelle
non interprt
type
opration
type
opration
spcification de la complexit
spatiale
spcification de la complexit
temporelle
Contraintes prdfinies
Les contraintes prdfinies par UML sont prsentes par ordre alphabtique dans
le tableau suivant. Les trois colonnes contiennent respectivement le nom de la
contrainte, llment de modlisation auquel elle sapplique et la description
dtaille de sa smantique.
Nom
Sujet
association
rle de lien
chevauchement
gnralisation
complte
gnralisation
diffusion
message
disjointe
gnralisation
global
rle de lien
implicite
association
incomplte
gnralisation
local
rle de lien
ordonne
rle d'association
ou
association
paramtre
rle de lien
self
rle de lien
vote
collection de
messages
inclusif
exclusif
Smantique
A2
Guide de transition de
Booch et OMT vers UML
Ce guide a pour objectif de faciliter la transition des utilisateurs des notations de
Booch93 ou OMT-2 vers la notation UML.
Les notations de Booch, OMT et UML fournissent trois vues diffrentes de
concepts objet trs proches. En fait, les notations de Booch et OMT pourraient
tre utilises pour reprsenter une grande partie des lments de modlisation
dfinis dans le mtamodle dUML.
Graphiquement, UML est plus proche dOMT que de Booch, car les icnes en
forme de nuage ont t abandonnes au profit de rectangles plus faciles
dessiner. Au-del des aspects graphiques, UML peut tre considre comme un
sur-ensemble des deux autres notations.
Les tableaux qui suivent illustrent les diffrences de notations concernant les
principaux concepts objet.
OMT
UML
Notes
En Booch et en UML, les notes se reprsentent par des rectangles, avec un coin
repli. En OMT, les notes se reprsentent comme les contraintes.
En Booch le coin bas-gauche est repli, alors quen UML, le coin haut-droit est
repli.
Booch
OMT
UML
Ceci est
une note
Ceci est
une note
Catgories
En Booch et en OMT, les catgories font partie des lments de modlisation. En
UML, les catgories se ralisent par strotypage des paquetages.
Booch
OMT
Catgorie
Catgorie
UML
<<Catgorie>>
Paquetage
Sous-systmes
En Booch et en OMT, les sous-systmes font partie des lments de
modlisation. En UML, les sous-systmes se ralisent par strotypage des
paquetages.
Booch
OMT
Sous-systme
Sous-systme
UML
<<Sous-systme>>
Paquetage
Les objets
En Booch, les objets se reprsentent par des nuages. En OMT, comme en UML,
les objets se reprsentent par des rectangles. En UML, le nom des objets est
soulign.
Booch
OMT
UML
Nom :
Classe
Nom : Classe
Nom : Classe
Les liens
Dans les trois notations, les liens se reprsentent par une ligne continue, trace
entre les objets.
Booch
:A
OMT
:B
:A
UML
:B
:A
:B
Spcification de ralisation
Booch et UML permettent de prciser la construction retenue pour la ralisation
dun lien, au moyen dun petit carr plac sur le rle. Le symbole plac dans le
carr indique la nature du lien. Un carr noir indique une ralisation par valeur, un
carr blanc indique une ralisation par rfrence.
OMT ne propose pas dattribut graphique particulier, en dehors des contraintes.
Booch
OMT
UML
A association
F membre (field)
F membre (field)
G global
G global
L local
L local
P paramtre
P paramtre
S self
Les messages
Dans les trois notations, les messages se reprsentent au moyen de flches
places proximit des liens.
La forme de synchronisation de lenvoi de message est symbolise par une forme
de flche particulire.
Booch
OMT
UML
Ordre denvoi
Lordre denvoi est reprsent dans les trois notations par une expression place
en tte du message.
Booch
Notation dcimale
OMT
Notation dcimale pointe
UML
Notation dcimale pointe
modifie
caractre flot
chiffre tape dans un
flot
* itration
Flots de donnes
Booch et UML permettent de reprsenter les flots de donnes paralllement aux
flots de contrle (les messages), au moyen de petits cercles accols une flche
dirige dans le sens du flot de donnes. Cette notation est optionnelle, car
redondante avec la reprsentation des paramtres des messages.
Booch
OMT
UML
Les classes
En Booch, les classes se reprsentent par des nuages pointills. En OMT, comme
en UML, les classes se reprsentent par des rectangles.
Classe simple
Booch
Une
classe
OMT
UML
Une classe
Une classe
Attributs et oprations
Dans les trois notations, les attributs et les oprations sont reprsents au sein
de licne de la classe. Certains attributs et certaines oprations peuvent tre
masqus pour ne pas surcharger les diagrammes.
OMT et UML proposent des compartiments pour distinguer les attributs des
oprations.
Booch
OMT
UML
Une classe
Une classe
Attribut
Opration( )
Une classe
Attribut
Attribut
Opration( )
Opration( )
Visibilit
Les trois notations proposent les niveaux public, protg et priv, avec la mme
smantique que celle du langage C++. Booch possde en plus un niveau
implmentation.
Booch
OMT
UML
+ public
+ public
| protg
# protg
# protg
|| priv
- priv
- priv
$ classe
soulign classe
||| implmentation
Mtaclasse classe
A
A
Attribut public
| Attribut protg
|| Attribut priv
Opration publique( )
| Opration protge( )
|| Opration prive( )
+Attribut public
#Attribut protg
-Attribut priv
+Attribut public
#Attribut protg
-Attribut priv
+Opration publique( )
#Opration protge( )
-Opration prive( )
+Opration publique( )
#Opration protge( )
-Opration prive( )
Classe abstraite
En Booch, les classes abstraites sont dsignes par un petit triangle qui contient
la lettre A. En OMT, une classe abstraite possde une multiplicit de valeur nulle.
En UML, le nom des classes abstraites figure en italique.
Booch
OMT
UML
Classe
abstraite
Classe abstraite
0
Classe abstraite
Classe utilitaire
En Booch et en UML, une classe utilitaire se reprsente comme une classe simple,
avec en plus une bordure grise. OMT ne propose pas dattribut graphique
particulier, en dehors des contraintes.
Booch
OMT
UML
Classe
utilitaire
Classe utilitaire
{utilitaire}
Classe utilitaire
<<Utilitaire>>
Classe utilitaire
Classe paramtrable
Booch et UML proposent une notation spciale, drive de la reprsentation des
classes simples, avec en plus un petit rectangle pointill qui contient les
paramtres formels. OMT suffixe le nom des classes paramtrables par les
paramtres formels.
Booch
Param
Classe
paramtrable
OMT
Classe paramtrable
<Param>
UML
Param
Classe paramtrable
Classe paramtre
Linstanciation dune classe paramtrable donne une classe paramtre. Booch
propose une icne spciale, avec un rectangle en trait continu ; le paramtre
effectif peut tre reprsent au moyen dune relation dutilisation. OMT et UML
reprsentent les classes paramtres au moyen dune classe simple en suffixant le
nom de la classe par les valeurs des paramtres effectifs.
Booch
Classe
paramtre
OMT
UML
Classe paramtre
<Paramtre effectif>
Classe paramtre
<Paramtre effectif>
Mtaclasse
Booch reprsente une mtaclasse au moyen dune classe grise. OMT ne
possde pas dattribut graphique particulier, en dehors des contraintes. UML
strotype une classe simple pour obtenir une mtaclasse.
Booch
Mtaclasse
OMT
UML
Mtaclasse
<<Mtaclasse>>
{Mtaclasse}
Mtaclasse
Les relations
Association
Dans les trois notations, les associations se reprsentent par une ligne continue,
trace entre les classes qui participent lassociation.
Booch
A
OMT
B
UML
Rle
Dans les trois notations, les noms de rles sont placs prs des extrmits des
relations.
Booch
A
Rle
OMT
B
UML
Rle
Rle
Multiplicit
Booch et UML sont identiques, part pour la valeur illimite qui se reprsente par
N en Booch et * en UML. OMT propose une reprsentation graphique base de
cercles. Il faut faire attention ne pas confondre ces cercles avec ceux des
relation has et use de Booch, car il ny aucun rapport entre les deux
reprsentations.
Booch
OMT
1 par dfaut
0..N
0..1
N
UML
0..1
1
0..1
*
3..5
3..5, 7, 15
3..5, 7, 15
1+
3..N
3..*
Restriction
La restriction dune association se reprsente en Booch au moyen dune
condition entre crochets. En OMT et en UML, une restriction se reprsente au
moyen dun compartiment rectangulaire.
La cl se reprsente du ct source en OMT et UML, et du ct destination en
Booch.
Booch
OMT
B
UML
B
Cl
Cl
[Cl]
Classe-association
Dans les trois notations, une classe-association se reprsente au moyen dune
classe relie une association.
Booch
OMT
B
UML
B
C
C
C
Agrgation
Il ny a pas dquivalence stricte entre Booch dune part, et OMT et UML dautre
part.
Du point de vue des agrgations, Booch est plus proche de la conception, OMT
est plus proche de lanalyse, et UML couvre la fois lanalyse et la conception.
Le tableau suivant reprsente les deux situations les plus courantes : lagrgation
par rfrence et lagrgation par valeur (la composition en UML). Il faut noter que
dans le cas dOMT, la vue graphique ne distingue pas la forme dagrgation.
Booch
OMT
UML
Dpendance
Booch reprsente la dpendance au moyen dune association dcore dun petit
cercle, plac du ct client. OMT reprsente la dpendance au moyen dune
flche en pointill, tte pleine. UML reprsente la dpendance au moyen dune
flche en pointill, tte ouverte. En OMT et en UML, la flche dsigne le
fournisseur.
Booch
OMT
UML
Hritage
Dans les trois notations, lhritage se reprsente au moyen dune flche qui
pointe de la sous-classe vers la super-classe.
Booch
A
OMT
UML
Instanciation de Mtaclasse
Booch emploie une flche grise pour reprsenter la relation ente une classe et sa
mtaclasse. OMT ne prvoit pas de notation particulire, en dehors des
contraintes. UML strotype une relation de dpendance.
Booch
OMT
UML
<<Mtaclasse>>
Mta A
Mta A
Mta A
{mtaclasse}
<<Mtaclasse>>
Instanciation de gnrique
Booch propose une flche pointille pour reprsenter la relation entre les classes
paramtres et les classes paramtrables. OMT emploie une relation de
dpendance. UML strotype une relation de dpendance.
Booch
OMT
UML
<<Liaison>>
<>
<>
Construction drive
Les associations et les attributs drivs sont prfixs par le caractre / en OMT
comme en UML. Cette notion nexiste pas en Booch.
Booch
OMT
UML
A3
Gnration de code C++
Les exemples de code qui suivent ont t gnrs automatiquement par loutil
Rational Rose 4.0, partir de modles UML. Ces exemples nillustrent pas
lensemble des capacits de gnration de code de Rose, mais dcrivent les
grandes lignes des correspondances entre UML et le langage C++.
Classe
Classe vide
Le gnrateur de code a t configur pour gnrer un constructeur, un
constructeur par copie, un destructeur, un oprateur daffectation et deux
oprateurs dgalit.
Ces oprations ne sont pas reprsentes dans les paragraphes suivants, afin de
ne pas surcharger les exemples.
#ifndef A_h
#define A_h 1
class A
{
public:
//## Constructors (generated)
A();
A(const A &right);
//## Destructor (generated)
~A();
//## Assignment Operation (generated)
const A & operator=(const A &right);
//## Equality Operations (generated)
int operator==(const A &right) const;
int operator!=(const A &right) const;
};
#endif
A
A1 : String
A2 : String
Op1( )
Op2( )
class A
{
public:
...
//## Other Operations (specified)
void Op1();
void Op2();
const String get_A1() const;
void set_A1(const String value);
const String get_A2() const;
void set_A2(const String value);
private:
String A1;
String A2;
};
inline const String A::get_A1() const
{
return A1;
}
inline void A::set_A1(const String value)
{
A1 = value;
}
inline const String A::get_A2() const
{
return A2;
}
inline void A::set_A2(const String value)
{
A2 = value;
}
Classe paramtrable
Att
Classe utilitaire
Toutes les oprations dune classe utilitaire sont prfixes par le mot-cl
static.
F
Op1( )
Op2( )
class F
{
public:
static void Op1();
static void Op2();
};
Association
Association 1 vers 1
Le gnrateur de code ralise lassociation par des pointeurs placs dans les
parties prives des classes qui participent lassociation.
A
Ra
1
...
class A
{
...
Rb
...
class B
{
...
private:
B *Rb;
};
private:
A *Ra;
};
Association N vers 1
A
Ra
0..*
Rb
Le gnrateur de code ralise lassociation par des pointeurs placs dans les
parties prives des classes qui participent lassociation. La multiplicit 0..*
est ralise par un ensemble de taille non contrainte.
...
class B
{
...
const UnboundedSetByReference<A> get_Ra() const;
void set_Ra(const UnboundedSetByReference<A> value);
private:
UnboundedSetByReference<A> Ra;
};
inline const UnboundedSetByReference<A> B::get_Ra() const
{
return Ra;
}
inline void B::set_Ra(const UnboundedSetByReference<A> value)
{
Ra = value;
}
Ra
0..*
{Ordered}
Rb
...
class B
{
...
const UnboundedListByReference<A> get_Ra() const;
void set_Ra(const UnboundedListByReference<A> value);
private:
UnboundedListByReference<A> Ra;
};
Classe-association
B
1
class A; class B;
class C
{
...
const B * get_the_B() const;
void set_the_B(B *const value);
const A * get_the_A() const;
void set_the_A(A *const
value);
private:
A *the_A;
B *the_B;
};
#include "C.h"
class A
{
...
const C * get_the_C() const;
void set_the_C(C *const value);
#include "C.h"
class B
{
...
const C * get_the_C() const;
void set_the_C(C *const value);
private:
C *the_C;
};
private:
C *the_C;
};
Classe-association N vers N
B
0..*
0..*
#include "C.h"
class B
{
...
const UnboundedSetByReference<C> get_the_C() const;
void set_the_C(const UnboundedSetByReference<C> value);
private:
UnboundedSetByReference<C> the_C;
};
Agrgation
Agrgation 1 vers 1
A
Ra
1
B
1
#include "B.h"
class A
{
...
const B * get_the_B() const;
void set_the_B(B *const value);
#include "A.h"
class B
{
...
const A * get_Ra() const;
void set_Ra(A *const value);
private:
B *the_B;
};
private:
A *Ra;
};
Ra
1
class A
{
...
private:
};
B
1
#include "A.h"
class B
{
...
const A * get_Ra() const;
void set_Ra(A *const value);
private:
A *Ra;
};
Ra
1
B
1
#include "B.h"
class A
{
...
const B * get_the_B() const;
void set_the_B(B *const value);
#include "A.h"
class B
{
...
const A get_Ra() const;
void set_Ra(const A value);
private:
B *the_B;
};
private:
A Ra;
};
Ra
0..*
#include "A.h"
class B
B
1
{
...
const UnboundedSetByValue<A> get_Ra() const;
void set_Ra(const UnboundedSetByValue<A> value);
private:
UnboundedSetByValue<A> Ra;
};
Hritage
Hritage simple
#include "A.h"
class B : public A
{
...
};
Hritage multiple
A1
A2
#include "A1.h"
#include "A2.h"
class B : public A2, public A1
{
...
};
A4
Gnration de code Java
Les exemples de code qui suivent ont t gnrs automatiquement par loutil
Rational Rose 4.0, partir de modles UML. Ces exemples nillustrent pas
lensemble des capacits de gnration de code de Rose, mais dcrivent les
grandes lignes des correspondances entre UML et le langage Java.
Classe
Classe vide
Le gnrateur de code a t configur pour gnrer un constructeur et un
destructeur. Ces oprations ne sont pas reprsentes dans les paragraphes
suivants, afin de ne pas surcharger les exemples.
A
A
A1 : String
A2 : String
Op1( )
Op2( )
Classe abstraite
public abstract class A {
...
}
Interface
public interface I_A {
...
}
<<Interface>>
I_A
Association
Association 1 vers 1
A
Ra
1
public class A {
Rb
public class B {
public B m_Rb;
}
public A m_Ra;
}
Association N vers 1
Ra
Rb
-Ra
*
Rb
public class B {
public class B {
-Ra
Rb
public class B {
Agrgation
Agrgation 1 vers 1
Ra
1
public class A {
B
1
public class B {
public B m_B;
}
public A m_Ra;
}
Ra
1
public class A {
...
}
B
1
public class B {
public A m_Ra;
}
Hritage
Hritage simple
<<Interface>>
I_C
<<Interface>>
I_B
<<Interface>>
I_A
<<Interface>>
I_C
<<Interface>>
I_A
A5
Gnration de code IDL
Les exemples de code qui suivent ont t gnrs automatiquement par loutil
Rational Rose 4.0, partir de modles UML. Ces exemples nillustrent pas
lensemble des capacits de gnration de code de Rose, mais dcrivent les
grandes lignes des correspondances entre UML et le langage IDL.
Classe
Classe vide
Une classe est traduite en interface IDL.
A
interface A {
...
};
interface A {
attribute String Att1;
attribute String Att2;
void Op1();
void Op2();
};
Association
Association 1 vers 1
Ra
interface A {
Rb
interface B {
attribute B Rb;
attribute A Ra;
};
};
Association N vers 1
Ra
Rb
interface B {
Association 5 vers 1
-Ra
Rb
interface B {
Agrgation
Agrgation 1 vers 1
A
Ra
1
B
1
interface A {
interface B {
attribute B the_B;
attribute A Ra;
};
};
Ra
1
interface A {
B
1
interface B {
};
attribute A Ra;
};
Hritage
Hritage simple
interface B : A {
};
Hritage multiple
A1
A2
interface B : A1, A2 {
};
A6
Gnration de code
Visual Basic
Les exemples de code qui suivent ont t gnrs automatiquement par loutil
Rational Rose 4.0, partir de modles UML. Ces exemples nillustrent pas
lensemble des capacits de gnration de code de Rose, mais dcrivent les
grandes lignes des correspondances entre UML et le langage Visual Basic.
Classe
Classe vide
Option Base 0
Private Sub Class_Initialize()
End Sub
Private Sub Class_Terminate()
End Sub
Option Base 0
A1 : String
A2 : String
Public A1 As String
Op1( )
Op2( )
Public A2 As String
Private Sub Class_Initialize()
End Sub
Private Sub Class_Terminate()
End Sub
Public Sub Op1()
On Error GoTo Op1Err
...
Exit Sub
Op1Err:
Call RaiseError(MyUnhandledError, "A:Op1
Method")
End Sub
Public Property Get Op2() As Boolean
On Error GoTo Op2Err
...
Exit Property
Op2Err:
Call RaiseError(MyUnhandledError, "A:Op2
Property")
End Property
Classe utilitaire
F
Op1( )
Op2( )
Option Base 0
Private Sub Class_Initialize()
End Sub
Private Sub Class_Terminate()
End Sub
Association
Association 1 vers 1
Ra
Rb
Option Base 0
Option Base 0
Public Rb As B
Public Ra As A
Association N vers 1
A
Ra
*
Rb
Option Base 0
Option Base 0
Public Rb As B
Public Ra As Collection
Hritage
Hritage simple
A
Op1()
Option Base 0
Implements A
Op2()
A7
Gnration de code SQL
Les exemples de code qui suivent ont t gnrs automatiquement par loutil
Rational Rose 4.0, partir de modles UML. Ces exemples nillustrent pas
lensemble des capacits de gnration de code de Rose, mais dcrivent les
grandes lignes des correspondances entre UML et le langage SQL ANSI.
Pour une discussion dtaille sur la gnration de code SQL partir dun
diagramme de classes et les diffrentes stratgies possibles, voir le chapitre 17 du
livre Object-Oriented Modeling and Design48.
Classe
Classe vide
A
48
Rumbaugh J., Blaha M., Premerlani W., Eddy F., Lorensen W. 1991, ObjectOriented Modeling and Design. Prentice Hall.
Association
Association 1 vers 1
Ra
Rb
Association N vers 1
A
Ra
*
Rb
1
Classe-association N vers N
A
B
0..*
0..*
C
CREATE TABLE T_A (
A_Id NUMBER (5),
PRIMARY KEY (A_Id)
)
CREATE TABLE T_B(
B_Id NUMBER (5),
PRIMARY KEY (B_Id)
)
CREATE TABLE T_C (
A_Id NUMBER (5) REFERENCES T_A (A_Id) ON DELETE CASCADE,
B_Id NUMBER (5) REFERENCES T_B (B_Id) ON DELETE CASCADE,
PRIMARY KEY(A_Id, B_Id)
)
Hritage
Dans les exemples suivants chaque classe est ralise par une table. Lidentit
dun objet est prserve dans la hirarchie de classes par lemploi dun identifiant
partag.
Hritage simple
A
B
CREATE TABLE T_A(
A_Id NUMBER(5),
PRIMARY KEY(A_Id)
)
CREATE TABLE T_B(
A_Id NUMBER (5) REFERENCES T_A (A_Id),
PRIMARY KEY(A_Id))
)
Hritage multiple
A1
A2
Glossaire
Abstraction
Abstraite
Acteur
Action
Activit
Agent
Agrgation
Algorithme
Analyse
Analyse du domaine
Anctre
Synonyme de super-classe.
Application
Architecte
Spcialiste de larchitecture.
Architecture
Artefact
Association
Association drive
Asynchrone
Attribut
Attribut de lien
Attribut driv
Automate
Big bang
Cardinalit
Cas dutilisation
Catgorie
Classe
Classe abstraite
Classe active
Classe concrte
Classe de base
Classe paramtrable
Classe paramtre
Classe rsultant
paramtrable.
Classe racine
Classe utilitaire
Classe-association
Classification
Classification
dynamique
Classification
de
la
paramtrisation
dune
classe
Glossaire 411
statique
Cl
Cl naturelle
Cl primaire
Client
Collaboration
Collection
Composant
Composition
Conception
Condition
Constructeur
Construction
Conteneur
Contexte
Contrainte
Contrat
Contrle
Couche
Couplage
CRC
Cycle
Cycle de vie
Dcomposition
Dlgation
Dpendance
Dploiement
Destructeur
Diagramme
Discret
Contraire de continu.
Discriminant
Synonyme de critre.
Documentation
Domaine
Elaboration
Elment
Elment de
modlisation
Elment de
visualisation
Projection graphique
modlisation.
Encapsulation
Entit
Enumration
Erreur
Occurrence anormale.
Espace de nom
Etat
Etend
Etude dopportunit
Evnement
Exception
Export
dune
collection
dlments
de
Glossaire 413
Expression
Extension
Factorisation
Flot dexcution
Flot de contrle
Flot de donnes
Fonction
Framework
Macro-architecture gnrique.
Garde
Gnralisation
Gnralisation
multiple
Gnration
Gnrique
Gestion de versions
Gestion de
configurations
Hritage
Hritage dinterface
Hritage multiple
Hirarchie
Identit
Idiome
Import
Instance
Intgration
Interaction
Interface
Interruption
Invariant
Invocation
Itrateur
Itration
Liaison dynamique
Liaison statique
Lien
Ligne de vie
Livraison
Maintenance
Mcanisme
Membre
Message
Mtaclasse
Glossaire 415
Mtamodle
Mtamodlisation
Mthode
Mthode dinstance
Mthode de classe
Mode
Modle
Modlisation
Modificateur
Modularit
Module
Monomorphisme
Multiplicit
Navigabilit
Niveau de maturit
Nud
Non interprt
Notation
Note
Objet
Objet actif
Occultation
Synonyme dencapsulation.
dinformation
Opration
Opration abstraite
Paquetage
Partie prive
Partie protge
Partie publique
Partition
Pattern
Persistance
Phase
Polymorphisme
Post-condition
Pr-condition
Processus
Projection
Proprit
Prototype
Pseudo-tat
Rcursivit
Rflexive
Rification
Responsabilit
Glossaire 417
Restriction
Rtro-ingnierie
Rutilisation
Revue
Risque
Rle
Scnario
Schme
SEI
Slecteur
Serveur
Signal
Signature
Sous-classe
Classe spcialise, relie une autre classe plus gnrale par une
relation de gnralisation.
Sous-tat
Sous-systme
Spcialisation
Spcification
Strotype
Structure
Structure
Super-classe
Classe gnrale relie une autre classe plus spcialise par une
relation de gnralisation.
Super-tat
Surcharge
Synchrone
Synchronisation
Temps rel
Test
Topologie
Transition
Transition
automatique
Typage
Type
Type de donne
abstrait
Type primitif
Use case
Variable dinstance
Attribut dobjet.
Variable de classe
Visibilit
Vision
Vue
modlisation,
Bibliographie
Bibliographie 421
Rational Rose
Outil de modlisation supportant les notations Booch93, OMT-2 et UML.
http://www.rational.com/pst/products/rosefamily.html
Index
A
abstraction 219
dmarche d 36, 206
hirarchie d 49
niveau d 61, 71, 218, 235
acteur
candidats 127
cas d'utilisation 124
comportement 26
action 168
dclenchement 146, 181
activit 168
diagramme d' 182
priode d' 155
agent 26
agrgation 46, 109
automate 161
composite 141
composition 110
Agrgation
d'tats 173
analyse
des besoins 216, 276
des risques 261
mthode d' 5
objet 205
approche
cognitive 206
fonctionnelle 7, 25
objet 15
structure 136, 204
systmique 206
approches 206
architecture 208, 237
conception 217
macro-~ 234
micro-~ 231
vision de l' 219
Architecture 217, 219
association 44, 99
couplage fort 46
rflexive 107, 139
ternaire 101, 140
asynchrone
communication 166
envoi de message 31, 153
attribut 20, 37, 94
driv 96
automate 161
mmoire 175
agrgation 173
vnement 165
garde 167
Index 425
gnralisation 171
souche 173
transition 164
B
big bang
effet 244
Booch
Grady 9
mthode de 9, 12
C
cas dutilisation 124, 152, 162, 182,
192, 216, 224
diagramme de 126
transition vers l'objet 224
changement de paradigme 7
classe 36
abstraite 57, 118
active 120
contrat de 40
diagramme de 94
paramtrable 98
spcification de 40, 53
utilitaire 99
classification 49
difficult de 59
dynamique 63, 115
multiple 63
proprits des 69
mtamodle 149
ralisation des cas d'utilisation
136, 216, 276
ralisation des patterns 232
reprsentation du comportement
224
collection 40, 71
multiplicit 104
paramtrable 98
complexit
crise du logiciel 200
cycle itratif 250
des besoins 125
des logiciels 201
gestion de la 17, 36, 49, 140, 193,
214
risque 267
transfert de la 210
composant
agrgation 46
diagramme de 187
hritage 64
intgration des 244, 266
mtamodle 120
rutilisable 98, 207, 277
stockage du code 226
topologie des 237
composants
diagramme de 187
cl
naturelle 23
restriction d'association 108
valeur de 142
composition
agrgation 110
automate 173
gnralisation et 114
hritage et 64
collaboration 136
contexte dune 136
diagramme de 33, 142
conception 207
architecture 217
cycle de vie 245, 257, 282
objet 207
pattern 231
retouche de 251
condition
activit 183
automate 164
boucle 159
branchement 147
garde 167, 174
congre
effet 280
constructeur
d'interfaces 135
d'outils 87
message 28, 104, 381
conteneur 89
contexte
de collaboration 136, 149, 224, 232
de diagramme 44, 84, 94
diagramme d'objet 137
interaction 33, 142
contrainte 88
association 100, 106
d'architecture 219
de dveloppement 200
de gnralisation 50, 116
de ralisation 23, 209
d'objet 144
hritage 64, 115
mcanisme commun 86
multiplicit 104
principe de substitution 69, 75
temporelle 152, 158
contrat
de classe 40
de maintenance 201
Index 427
covariante 59
en sous-systmes 192
flot d'excution 220
fonctionnelle 16
gnralisation 116
objet 16
paquetage 90, 227
processus de 16
dcouplage
polymorphisme 71
dlgation 67
agent 27
dpendance
automate 174
composant 188
de compilation 226
import 91, 235
obsolescence 92
relation de 88, 123
dploiement
diagramme de 194
graduel 267
post- 267, 281
vue de 220
Dploiement
du code excutable 226
destructeur
message 28, 381
diagramme
dtats-transitions 161
dobjets 137
d'activits 182
de cas d'utilisation 126
de classes 94
de collaboration 142
de composants 187
de dploiement 194
de squence 151
discriminant
gnralisation 116
documentation 249
cas d'utilisation 128, 135, 152
cycle de vie 247
de l'architecture 223
sous-systme 193
domaine 204
classe du 225
complexit du 201, 250
de dfinition 20, 40, 123
du problme 17
vnement 165
expert du 125, 266
gnralisation 51
modlisation du 205, 216, 275
objet du 36, 94, 136
E
effet
big bang 244, 251
congre 280
laboration
cycle de vie 257, 260
phase d' 275
encapsulation 41
couplage 43
niveau d' 42
paquetage 92
sous-systme 193
envoi de message
asynchrone 31, 153
synchrone 30, 153
erreur
Index 429
de collaboration 149
idiome 233
instance 36
de relation 44
ensemble des 53
intgration
avec les environnements de
dveloppement 193
dmarche d' 17
phase d' 242
schma d' 209
test d' 242
interaction 150
description des 70
diagramme d' 32
entre objets 22
reprsentation des 142, 151
structuration des cas d'utilisation
125
interface 41, 67, 97
de paquetage 92
d'un projet 272
type 97
interruption 28, 153, 176
itrateur 28, 72
itration
clause d' 147
cycle de vie 204, 215, 244
envoi de message 144
valuation d'une 252
J
Jacobson Ivar 9
L
liaison
message 27
catgorie de 28
de cration 154
de destruction 154
dclenchement d'oprations 71, 77
envoi de 142
flot de 128
mode de communication 209
paramtres de 148
rcursif 157
rflexif 154
reprsentation des 146, 370
synchronisation des 29, 146
mtaclasse
reprsentation 374
strotype 95
mtamodle 12, 119, 149, 180
spcialisation du 86
mthode
de dveloppement 213
l'unification des 10
ralisation des oprations 119, 182
mode
de contrle 157
de synchronisation 209
modle 86
CMM (Capability Maturity Model)
214
complexit des 234
de classes 98
des 4 + 1 vues 219
en cascade 241
en tunnel 240
en V 242
enrichissement des 207
organisation des 221
partition des 90
Index 431
caractristiques fondamentales
dun 20
diagramme d' 137
persistant 24
serveur 26
OMT 9, 12
OOSE 12
opration 21, 37, 94
abstraite 118
action 169
automate 168
compartiment de classe 95
de classe 97
dclenchement des 77
dclenchement manuel 75
gnralisation 50
hritage 64
point d'excution 170
propagation des 47, 70
visibilit des 96
optimisation 209
P
paquetage 86, 90, 123, 149
Ada 187
arborescence de 222
gnralisation 114
import 91
interface 92
organisation des vues 227
strotyp en catgorie 220, 235
partie
prive 42, 193
protge 42
publique 42, 193
partition
des besoins 125
des modles 90
d'un ensemble dobjets 56, 112,
122
en sous-systmes 9
pattern 150, 207, 231
persistance 24, 235
polymorphisme 70, 80
ad hoc 80
d'opration 71
thorie des types 70
projection 14, 86, 223
proprit 95
caractristique d'un ensemble 53
classification 69
de navigation 114
drive 96
des objets d'une classe 40
tiquette 88
modlisation des 17
prototype 244, 258
maquette 274
R
rcursive
structure 107, 137
rflexive
association 107, 139
transition 168
rification
dune association 105
dune fonction 39
d'un flot d'excution 120
d'une interaction 39
responsabilit
allocation des 280
chane de 232
restriction
d'une association 108, 142
reprsentation 376
rutilisation 51, 208, 215
pattern 232
taux de 277
revue 241, 246
risque
gestion du 261
rle
association 102
association n-aire 101
attributs de 121
d'une classe 45
nommage des 102
Rumbaugh James 9
S
scnario 128, 245, 263
automate 162
cas d'utilisation 136
schme 150, 231
SEI (Software Engineering Institute)
214
slecteur
expression de navigation 111
message 28
opration 42
squence
diagramme de 151
serveur
comportement 26
de bases de donnes 210
objet 26
ordinateur 195
X 195
signature 80
souche 173
spcialisation 50
critre de 62
dimension de 60
spcification
d'un composant 187
d'un lment 86
d'un vnement 166
d'une classe 40, 53
gnrique 187
pure 99
strotype 87, 123
association ternaire 101
de classe 95, 138
de dpendance 188
de nud 194
de paquetage 87, 90, 235
de processus 189
de support de communication 195
de transition 186
de type 97
d'tat 182
d'objet 138
prdfini 361
structure
approche 136, 204
technique 200
surcharge
des oprations 80, 211
polymorphisme ad hoc 80
synchronisation
barre de 184
Index 433
topologie
d'application 237
transition 158
automate 164
automatique 169
cycle de vie 257
dentre 170
de Booch et OMT vers UML 367
de sortie 169
diagramme d'tats-transitions 161
interne 172
phase de 280
vers l'objet 212
variable
de classe 97
Transition 224
typage
influence du 80
type 40, 119, 123
de donne abstrait 40, 99
des attributs 138
visibilit 84
niveau de 42, 96
rgles de 42
vision
anthropomorphique 19
d'architecture 219
d'un produit 273
vue
d'architecture 219
de dploiement 220
de ralisation 220
des cas d'utilisation 221
des processus 220
logique 219
Contenu du CD-Rom
Tous les efforts ont t faits pour tester avec soin le CD-Rom et les programmes quil
contient. Nanmoins, les Editions EYROLLES ne pourront tre tenues pour
responsables des prjudices ou dommages de quelque nature que ce soit pouvant
rsulter de lutilisation de ces programmes.