UML 2 - - PL2/UML/Cours/20XX-XX.cours.complet.uml.pdf · PDF file et permis de developper...

Click here to load reader

  • date post

    06-Mar-2020
  • Category

    Documents

  • view

    3
  • download

    1

Embed Size (px)

Transcript of UML 2 - - PL2/UML/Cours/20XX-XX.cours.complet.uml.pdf · PDF file et permis de developper...

  • UML 2.0 (IUT, département informatique, 1re année)

    Laurent AUDIBERT

    Institut Universitaire de Technologie de Villetaneuse – Département Informatique Avenue Jean-Baptiste Clément 93430 Villetaneuse Adresse électronique : laurent[dot]audibert[at]iutv[dot]univ-paris13[dot]fr Adresse du document : http ://www-lipn.univ-paris13.fr/ audibert/pages/enseignement/cours.htm

  • 2

  • Avant-propos

    Les techniques de programmation n’ont cessé de progrésser depuis l’époque de la programmation en langage binaire (cartes perforées, switch) à nos jours. Cette évolution a toujours été dictée par le besoin de concevoir et de maintenir des applications toujours plus complexes.

    La programmation par cartes perforées, switch ou cablage (de 1800 à 1940) a ainsi fait place à des techniques plus évoluées, comme l’assembleur (1947), avec l’arrivée de l’ordinateur électronique né des besoins de la guerre. Des langages plus évolués ont ensuite vu le jour comme Fortran en 1956 ou Cobol en 1959. Jusque là, les techniques de programmation étaient basées sur le branchement conditionnel et inconditionnel (goto) rendant les programmes importants extrêmement difficiles à developper, à maîtriser et à maintenir.

    La programmation structurée (Pascal en 1970, C en 1972, Modula et Ada en 1979, . . .) a alors vu le jour et permis de developper et de maintenir des applications toujours plus ambitieuses. L’algorithmique ne se suffisant plus à elle seule à la fin des années 1970, le génie logiciel est venu placer la méthodologie au coeur du développement logiciel. Des méthodes comme Merise (1978) se sont alors imposées.

    La taille des applications ne cessant de croître, la programmation structurée a également rencontré ses limites, faisant alors place à la programmation orientée objet (Simula 67 en 1967, Smalltalk en 1976, C++ en 1982, Java en 1995, . . .). La technologie objet est donc la conséquence ultime de la modularisation dictée par la maîtrise de la conception et de la maintenance d’applications toujours plus complexes. Cette nouvelle technique de programmation a nécessité la conception de nouvelles méthodes de modélisation.

    UML (Unified Modeling Language en anglais, soit langage de modélisation objet unifié) est né de la fusion des trois méthodes qui s’imposaient dans le domaine de la modélisation objet au milieu des années 1990 : OMT, Booch et OOSE. D’important acteurs industriels (IBM, Microsoft, Oracle, DEC, HP, Rational, Unisys etc.) s’associent alors à l’effort et proposent UML 1.0 à l’OMG (Object Management Group) qui l’accepte en novembre 1997 dans sa version 1.1. La version d’UML en cours à la fin 2006 est UML 2.0 qui s’impose plus que jamais en tant que langage de modélisation standardisé pour la modélisation des logiciels.

    Ce document constitue le support du cours d’UML 2.0 dispensé aux étudiants du département d’informatique de l’institut universitaire de technologie (IUT) de Villetaneuse en semestre décalé.

    Ce support a été réalisé en utilisant les ouvrages cités en bibliographie. Il est en partie basé sur le livre de Charroux, Osmani et Thierry-Mieg (2005) qui constitue une bonne introduction au langage UML. Aomar Osmani est à l’origine du cours d’UML dans notre IUT.

    Rumbaugh, Jacobson et Booch (2004), Barbier (2005) Roques et Vallée (2003) et Muller et Gaertner (2000) ont également été largement utilisés. Rumbaugh et al.. (2004) est un ouvrage de référence assez complet et contient un dictionnaire détaillé de la terminologie UML 2.0. Muller et Gaertner (2000) est cours d’UML 2.0 bien expliqué et plus complet et détaillé que Charroux et al.. (2005) mais, en contrepartie, moins accessible. Barbier (2005) constitue une approche pratique et critique d’UML très intéressante. Enfin, Roques et Vallée (2003) nous montre une mise en pratique de la version 1.4 d’UML détaillée au travers d’un projet réel. Pascal Roques est probablement l’un des auteurs les plus prolifique (Roques, 2002 ; Roques & Vallée, 2003 ; Roques, 2006a ; Roques, 2006b) et compétant concernant la mise en œuvre d’UML.

    Agréable à lire, Volle (2006) s’intéresse à la place de l’informatique dans notre société et plus particu- lièrement dans l’entreprise.

    Enfin, diverses sources trouvées sur Internet, inépuisable source d’information en perpétuel renou- vellement, m’ont également été d’un grand secours. Parmi ces dernières, certaines sont incontournables, comme le cours de Piechocki (n.d.) ou encore le site Developpez.com (n.d.).

    3

  • 4

  • Table des matières

    1 Introduction à la modélisation objet 11 1.1 Le génie logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

    1.1.1 L’informatisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.1.2 Les logiciels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.1.3 Le génie logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.1.4 Notion de qualité pour un logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

    1.2 Pourquoi et comment modéliser ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.2.1 Notions de modèle et de modélisation . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.2.2 Le cycle de vie d’un logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.2.3 Modèles de cycles de vie d’un logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.2.4 Méthodes d’analyse et de conception . . . . . . . . . . . . . . . . . . . . . . . . . . 17

    1.3 De la programmation structurée à l’approche orientée objet . . . . . . . . . . . . . . . . . . 18 1.3.1 Méthodes fonctionnelles ou structurées . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.3.2 L’approche orientée objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.3.3 Approche fonctionnelle vs. approche objet . . . . . . . . . . . . . . . . . . . . . . . 19 1.3.4 Concepts importants de l’approche objet . . . . . . . . . . . . . . . . . . . . . . . . 19 1.3.5 Historique la programmation par objets . . . . . . . . . . . . . . . . . . . . . . . . . 20

    1.4 UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 1.4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 1.4.2 Histoire des modélisations par objets . . . . . . . . . . . . . . . . . . . . . . . . . . 21 1.4.3 UML en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 1.4.4 Comment présenter un modèle UML ? . . . . . . . . . . . . . . . . . . . . . . . . . . 23

    2 Diagramme de cas d’utilisation 25 2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 2.2 Éléments des diagrammes de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . 25

    2.2.1 Acteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 2.2.2 Cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.2.3 Représentation d’un diagramme de cas d’utilisation . . . . . . . . . . . . . . . . . . 26

    2.3 Relations dans les diagrammes de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . 26 2.3.1 Relations entre acteurs et cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . 26 2.3.2 Relations entre cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 2.3.3 Relations entre acteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

    2.4 Notions générales du langage UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 2.4.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 2.4.2 Stéréotype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 2.4.3 Classeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 2.4.4 Paquetage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 2.4.5 Espace de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

    2.5 Modélisation des besoins avec UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 2.5.1 Comment identifier les acteurs ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 2.5.2 Comment recenser les cas d’utilisation ? . . . . . . . . . . . . . . . . . . . . . . . . . 32 2.5.3 Description textuelle des cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . 32

    5

  • 6 TABLE DES MATIÈRES

    2.5.4 Description avec des diagrammes dynamiques simples . . . . . . . . . . . . . . . . 33 2.5.5 Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 2.5.6 Les Use case Realization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

    3 Diagramme de classes 35 3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 3.2 Les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

    3.2.1 Notions de classe et d’instance de classe . . . . . . . . . . . . . . . . . . . . . . . . . 35 3.2.2 Notions de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3