Recherchez sur tout Techno-Science.net
       
Techno-Science.net : Suivez l'actualité des sciences et des technologies, découvrez, commentez
 A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | +
Programmation orientée objet
Langages à objets
C++ - C# - D
Delphi - Eiffel - Groovy
Java - Python - Ruby
Simula - Smalltalk
Visual Basic - Lisaac - WinDev
Langages impératifs
APL - ASP - Assembleur
BASIC (En programmation, BASIC est un acronyme pour Beginner's All-purpose Symbolic Instruction Code. qui désigne une famille de langages de programmations de haut niveau.) - C - Cobol (COBOL est un langage de programmation de troisième génération créé en 1959 (officiellement le 18 Septembre 1959). Son nom est l'acronyme de COmmon Business Oriented Language qui...)
Forth - Fortran - Limbo
Logo - Pascal - Perl - PHP (PHP (sigle de PHP: Hypertext Preprocessor), est un langage de scripts libre principalement utilisé pour produire des pages Web dynamiques via un serveur HTTP, mais pouvant également fonctionner comme...)
Langages fonctionnels
Haskell - ML/OCaml
Lisp/Common Lisp
Scheme - XSLT
Langages déclaratifs
Clips - Prolog
Langages concurrents
Ada 95 - Erlang
Voir aussi
Conception - Codage (De façon générale un codage permet de passer d'une représentation des données vers une autre.)
Tests - Optimisations

La programmation (La programmation dans le domaine informatique est l'ensemble des activités qui permettent l'écriture des programmes informatiques. C'est une étape...) par objet (De manière générale, le mot objet (du latin objectum, 1361) désigne une entité définie dans un espace à trois dimensions, qui a une fonction précise, et qui peut être...) (du terme anglo-saxon Object-Oriented Programming ou OOP), est un paradigme de programmation, il consiste en la définition et l'assemblage de briques logicielles appelées objets ; un objet représente un concept, une idée ou toute entité du monde (Le mot monde peut désigner :) physique (La physique (du grec φυσις, la nature) est étymologiquement la « science de la nature ». Dans un sens général et ancien, la physique désigne la connaissance de la...), comme une voiture, une personne ou encore une page d'un livre.

Orthogonalement à la programmation par objet, afin de faciliter le processus d'élaboration d'un programme, existent des méthodologies de développement logiciel (En informatique, un logiciel est un ensemble d'informations relatives à des traitements effectués automatiquement par un appareil informatique. Y sont inclus les instructions de traitement, regroupées...) objet dont la plus connue est USDP (Unified Software Development (Development est une revue scientifique bimensuelle à comité de lecture couvrant tous les champs de la génétique évolutive du développement allant de la biologie cellulaire, des cellules souches, la biologie...) Process).

Il est possible de concevoir par objet une application informatique (L´informatique - contraction d´information et automatique - est le domaine d'activité scientifique, technique et industriel en rapport avec le traitement automatique de l'information par des machines telles que les...) sans pour autant utiliser des outils dédiés. Il n'en demeure pas moins que ces derniers facilitent de beaucoup la conception, la maintenance, et la productivité. On en distingue plusieurs sortes :

  • les langages de programmation (Eiffel, Python, C++, Smalltalk...)
  • les outils de modélisation qui permettent de concevoir sous forme de schémas semi-formels la structure d'un programme (Objecteering, UMLDraw, Rapsody…)
  • les bus distribués (COM, CORBA, RMI, Pyro...)
  • les ateliers de génie logiciels (ou AGL) (Rational Rose XDE, Objecteering...)

Des langages à objets, il en existe actuellement deux catégories : les langages à classes et ceux à prototypes, que ceux-ci soient sous forme fonctionnelle (En mathématiques, le terme fonctionnelle se réfère à certaines fonctions. Initialement, le terme désignait les fonctions qui en prennent...) (CLOS, OCaml…) ou impérative (C++, Java…) ou les deux (Python).

Origines

Le langage Simula-67 jette les prémices de la programmation objet, résultat des travaux sur la mise au point (Graphie) de langages de simulation dans les années 1960 et à partir desquels s'inspira aussi la recherche (La recherche scientifique désigne en premier lieu l’ensemble des actions entreprises en vue de produire et de développer les connaissances scientifiques. Par...) sur l’intelligence artificielle (L'intelligence artificielle ou informatique cognitive est la « recherche de moyens susceptibles de doter les systèmes informatiques de capacités intellectuelles comparables à celles des êtres...) dans les années 1970-80. Mais c'est réellement par et avec Smalltalk 72 puis Smalltalk 80, inspiré en partie par Simula, que la programmation par objets débute et que sont posés les concepts de base de celle-ci : objet, messages, encapsulation (L'encapsulation en général est la notion de mettre une chose dans une autre. En imageant, on peut voir que cette chose est mise dans une capsule. En particulier, on peut retrouver ce terme dans plusieurs...), polymorphisme, héritage (sous-typage ou sous-classification), redéfinition, etc. Smalltalk est plus qu'un langage à objets, il est aussi un environnement graphique (Un environnement graphique est, en informatique, ce qui est affiché en mode pixel au moniteur d'ordinateur et sur lequel l’utilisateur peut agir avec différents périphériques...) interactif complet.

À partir des années 1980, commence l'effervescence des langages à objets : Objective C (début des années 1980), C++ (C with classes) en 1983, Eiffel en 1984, Common lisp object system dans les années 1980, etc. Les années 1990 voient l'âge d'or de l'extension de la programmation par objet dans les différents secteurs du développement logiciel.

Depuis, la programmation par objet n'a cessé d'évoluer aussi bien dans son aspect théorique que pratique et différents « métiers » et « discours mercatiques » à son sujet ont vu le jour :

  • l’analyse objet (AOO ou OOA en anglais),
  • la conception objet (COO ou OOD en anglais),
  • les banques de données objet (SGBDOO),
  • les langages objets avec les langages à prototypes,
  • ou encore la méthodologie avec MDA (Model Driven Architecture).

Aujourd’hui, la programmation par objet est vue (La vue est le sens qui permet d'observer et d'analyser l'environnement par la réception et l'interprétation des rayonnements lumineux.) davantage comme un paradigme, le paradigme objet, que comme une simple technique de programmation. C'est pourquoi, lorsque l'on parle de nos jours (Le jour ou la journée est l'intervalle qui sépare le lever du coucher du Soleil ; c'est la période entre deux nuits, pendant laquelle les rayons du Soleil éclairent le ciel. Son début...) de programmation par objets, on désigne avant tout (Le tout compris comme ensemble de ce qui existe est souvent interprété comme le monde ou l'univers.) la partie codage d’un modèle à objets obtenu par AOO et COO.

Les principes de bases

L'objet (attribut et méthodes)

Concrètement, un objet est une structure de données valuées et qui répond à un ensemble (En théorie des ensembles, un ensemble désigne intuitivement une collection d’objets (les éléments de l'ensemble), « une multitude qui peut être comprise comme un tout », comme...) de messages. Cette structure de données définit son état tandis que l'ensemble des messages qu'il comprend décrit son comportement :

  • Les données ou champs qui décrivent sa structure interne (En France, ce nom désigne un médecin, un pharmacien ou un chirurgien-dentiste, à la fois en activité et en formation à l'hôpital ou en cabinet pendant une durée variable selon le "Diplôme...) sont appelées ses attributs ;
  • L'ensemble des messages forme ce que l'on appelle l'interface (Une interface est une zone, réelle ou virtuelle qui sépare deux éléments. L’interface désigne ainsi ce que chaque...) de l'objet ; c'est seulement au travers de celui-ci que les objets interagissent entre eux. La réponse à la réception d'un message (La théorie de l'information fut mise au point pour déterminer mathématiquement le taux d’information transmis dans la communication d’un...) par un objet est appelée une méthode (méthode de mise en œuvre du message) ; elle décrit comment est réalisé le message.

Les attributs (ou plus exactement leur représentation informatique) et les méthodes sont cachés ; ils forment une boîte noire. C'est le principe d'encapsulation. Son avantage principal réside dans la capacité à pouvoir modifier la structure interne des objets ou les méthodes associées aux messages sans en impacter les utilisateurs des objets.

Exemple d'un objet représentant un nombre (La notion de nombre en linguistique est traitée à l’article « Nombre grammatical ».) complexe donné. Celui-ci peut aussi bien être représenté sous forme cartésienne (réel, image) que sous forme trigonométrique ou exponentielle (La fonction exponentielle est l'une des applications les plus importantes en analyse, ou plus généralement en mathématiques et dans ses domaines d'applications. Il...) (module, angle). Cette représentation, quelle qu'elle soit, est cachée et est interne à l'objet sous forme d'une structure de données. Toutefois, celui-ci peut proposer deux messages permettant chacun de lire une représentation différente du nombre complexe. En utilisant les seuls messages que comprend notre nombre complexe, les objets appelants sont assurés de ne pas être impactés lors d'un changement de sa structure interne. Cette dernière n'est accessible que par (et donc aussi au travers) les méthodes des messages.

Le typage et le polymorphisme

Dans la programmation par objet, chaque objet est typé. Le type définit la syntaxe (comment l'appeler ?) et la sémantique (qu'est ce qu'il fait ?) des messages auxquels peut répondre un objet. Il correspond donc, à peu de chose près, à l'interface de l'objet. Toutefois, la plupart des langages objets ne proposent que la définition syntaxique d'un type (C++, Java, C#, ...) et rares sont ceux qui fournissent aussi la possibilité de le définir sémantiquement (Eiffel avec sa conception par contrats), pourtant nécessaire pour profiter au mieux des avantages de la conception objet.

Un objet peut appartenir à plus d'un type. C'est ce que l'on appelle le polymorphisme. Ceci permet d'utiliser des objets de types différents là où est attendue une valeur d'un type précis, dès que ceux-ci satisfont le type requis. Une façon de réaliser le polymorphisme est le sous-typage (appelé aussi héritage de type) : mécanisme par lequel est raffiné un type père en un autre type, le sous-type ; c'est un mécanisme de restrictions des espaces de valeurs du type. Les objets de ce sous-type sont conformes aussi au type père, ces objets sont donc d'au moins deux types. De ceci découle le principe de substitution de Liskov.

Exemples : soit un type Real = {plus: Real x Real -> Real}
et un sous-type Integer <: Real,
soit r: Real et i: Integer, alors r plus i est valide.

On distingue dans les langages objets trois mécanismes du typage :

  • le typage dynamique : le type des objets est implicite et déterminé à l’exécution lors de la création des dits objets (Smalltalk, CLOS, Python, PHP…),
  • le typage statique : le type des objets est spécifié explicitement par le développeur lors de leur déclaration (C++, Java, C#…),
  • le typage par inférence : le type est déterminé par le compilateur ou par l'interpréteur à partir du contexte (Le contexte d'un évènement inclut les circonstances et conditions qui l'entourent; le contexte d'un mot, d'une phrase ou d'un texte inclut les mots qui...), de l'expression dans laquelle il apparait (OCaml).

De même, deux mécanismes du sous-typage existent : l’héritage de type simple (Smalltalk, Java) et multiple (C++, Python, CLOS, Eiffel).

Attention : le polymorphisme n'est pas à confondre avec le sous-typage ou avec l’attachement dynamique (Le mot dynamique est souvent employé désigner ou qualifier ce qui est relatif au mouvement. Il peut être employé comme :) (dynamic binding en anglais).

La redéfinition

La programmation objet permet à un sous-type de raffiner la mise en œuvre d'un message défini dans le type père, autrement dit de redéfinir la méthode associée au message : c'est le principe de redéfinition des messages (ou overriding en anglais).

Or, dans une définition stricte du typage (typage du premier ordre), l'opération résultant d'un appel de message doit être la même quel que soit le type exact de l'objet référé. Ceci signifie donc que, dans le cas où l'objet référé est de type exact un sous-type du type considéré dans l'appel, seule la méthode du type père est exécutée :
Soit le type Reel = { plus: Reel x Reel -> Reel}
et son sous-type Entier <: Reel,
alors si i: Entier et r: Reel, l'appel
i plus r
conduit à l'exécution de la méthode associée au message plus dans le type Reel, et non à celle associée au même message dans le sous-type Entier dans le cas d'une redéfinition.

Pour réaliser alors la redéfinition, deux solutions existent :

  • le typage du premier ordre associé à l'attachement dynamique (c'est le cas de C++, Java, C#, ...). Cette solution induit (L'induit est un organe généralement électromagnétique utilisé en électrotechnique chargé de recevoir l'induction de...) une faiblesse dans le typage et peut conduire à des erreurs. Les relations entre type sont définies par le sous-typage (théorie de Liskov) ;
  • le typage du second ordre (duquel découle naturellement le polymorphisme et l'appel de la bonne méthode en fonction du type exact de l'objet). Ceci est possible avec Smalltalk et Eiffel. Les relations entre types sont définies par la sous-classification (théorie F-Bound de Cook).

Classe et prototype

La structure interne des objets et les messages auxquels ils répondent sont définis, explicités, par des modules logiciels. C'est aussi par ces mêmes modules que sont créés les objets, via des opérations dédiées. Deux représentations existent de ces modules : la classe et le prototype.

La classe est une structure informatique particulière dans le langage objet. Elle décrit la structure interne des données et elle définit les méthodes qui s'appliqueront aux objets de même famille (même classe) ou type. Elle propose des méthodes de création des objets dont la représentation sera donc celle donnée par la classe génératrice. Les objets sont dits alors instances de la classe. C'est pourquoi les attributs d'un objet sont aussi appelés variables d'instance et les messages opération d'instance ou encore méthodes d'instance. L'interface de la classe (l'ensemble des opérations visibles) forme les types des objets. Selon le langage de programmation (Un langage de programmation est un langage informatique, permettant à un être humain d'écrire un code source qui sera analysé par une machine, généralement un...), une classe est soit considérée comme une structure particulière du langage, soit elle même comme un objet (objet non-terminal). Dans ce dernier cas, la classe a besoin (Les besoins se situent au niveau de l'interaction entre l'individu et l'environnement. Il est souvent fait un classement des besoins humains en trois grandes...) elle aussi d'être créée et définie par une classe : ce sont les méta-classes. L'introspection des objets ou la méta-programmation est définie alors dans ces méta-classes. Sinon, elle est définie dans le runtime au travers des objets ou des classes. La classe peut donc aussi être décrite par des attributs et des messages. Ces derniers sont alors appelés, par opposition aux attributs et messages d'un objet, variables de classe et opération ou méthodes de classe. Parmi les langages à classes on retrouve Smalltalk, C++, C#, Java, etc.

Le prototype est un objet à part entière et qui sert de prototype de définition de la structure interne et des messages. De ce prototype, par le mécanisme de clonage (Le clonage désigne principalement deux processus. C'est d'une part la multiplication naturelle ou artificielle à l'identique d'un être vivant c'est-à-dire avec conservation exacte du...), sont créés les autres objets de mêmes types. Dans ce modèle, il n'y a plus de distinction entre attributs et messages : ce sont tous des slots. Un slot est un label de l'objet, privé ou public, auquel est attachée une définition : ce peut être une valeur ou une opération. Cet attachement peut être modifié à l'exécution. Chaque modification d'un slot est locale à l'objet concerné et n'impacte pas ses clones. Chaque ajout d'un slot impacte l'objet et l'ensemble de ses clones. Pour modifier globalement un slot, autrement dit pour impacter l'objet et tous ses clones, le concept de trait a été introduit. Un trait est un ensemble d'opérations de même catégorie (clonage, persistance ( Persistance (statistiques) Persistance (informatique) en peinture : La Persistance de la mémoire (1931) en médecine : la persistance du canal artériel la Persistance...), etc.) transverse aux objets. Il peut-être représenté soit comme une structure particulière du langage, comme un slot dédié ou encore comme un prototype. L'association d'un objet à un trait fait que l'objet et ses clones sont capables de répondre à toutes les opérations du trait. Un objet est toujours associé à au moins un trait, et les traits sont les parents des objets (selon une relation d'héritage). Un trait est donc un mixin (Un mixin, aussi appelé sous-classe abstraite, est une classe abstraite. C'est un cas de réutilisation d'implémentation. Chaque mixin...) doté d'une parenté. Parmi les langages à prototype on trouve Javascript (JavaScript est un langage de programmation de scripts principalement utilisé dans les pages web interactives mais aussi coté serveur. C'est un langage orienté objets à...), Self, Io, Slater, Lisaac, etc.

Voir l'article dédié : Programmation orientée prototype.

Le typage et la classification

Dans la programmation par objet, chaque objet est d'un ou plusieurs types. Le mécanisme adopté par lequel un objet peut être de plusieurs types est le sous-typage. Il existe deux grandes théories sur le sous-typage. Celle, initiale, de Liskov et celle, plus actuelle, de Cook. Dans chacune, deux concepts sont définis : celui du typage et celui de classification.

Le typage selon Liskov

Les types, dans la théorie des types de Liskov, et dont une définition sémantique a été donnée par Cardelli, sont dits types de premier ordre. Chaque objet est d'un type exact et ce type décrit syntaxiquement et sémantiquement les messages auxquels l'objet peut répondre. Ce type peut-être obtenu par sous-typage. L'objet est alors conforme à tous les types de l'arbre (Un arbre est une plante terrestre capable de se développer par elle-même en hauteur, en général au delà de sept mètres. Les arbres acquièrent une structure rigide composée d'un tronc qui peut...) de raffinement (En informatique, le raffinement consiste à avoir une approche de conception où on affine à chaque étape le niveau de détails ;...) (appelé aussi arbre d'héritage) d'un type de base jusqu'au type exact de l'objet. Dans cette approche, seule l'opération définie la première fois dans un type père est exécutée même si l'objet référant est d'un sous-type. Pour permettre la redéfinition, le mécanisme d'attachement dynamique est alors nécessaire. Dans le typage du premier ordre, les classes fournissent la représentation de la structure interne du type et les méthodes attachées à chaque message. Elles définissent une famille de mises en œuvre du type. L'interface de la classe représente alors le type des instances de cette classe. C'est une relation 1 classe - 1 type et 1 type - plusieurs classes ; on a une dualité type/classe. Dans cette démarche, il existe au moins deux mécanismes d'héritage:

  • le sous-typage ou l'héritage d'interface, et
  • la sous-classification ou l'héritage de mise en œuvre.

L’héritage est la faculté d’une sous-classe ou d’un sous-type d’hériter des propriétés de son parent et de les affiner. Le sous-typage est donc le processus par lequel on restreint l’espace des valeurs du type parent, et la sous-classification est le processus par lequel on récupère et on spécialise la mise en œuvre (redéfinition).

Le typage du premier ordre inclut des langages comme Java, C++ ou encore C#. Certains langages objets tentent d'offrir une séparation entre le type et la classe (Objective-C et Java), tandis que d'autres mixent la classe avec le type qu'elle met en œuvre (C++, Python).

Le typage selon Cook

Toutefois, la théorie des types de Liskov se heurte au problème du sous-typage des types récursifs (les types avec au moins une opération qui accepte un objet de même type).

En effet :
soit le type Nombre = {plus: Nombre x Nombre -> Nombre},
soit Reel <: Nombre.
Selon le sous-typage du premier ordre, on aurait :
Reel = {plus: Nombre x Nombre -> Nombre}
ou au mieux, avec la covariance (Pour le principe physique, voir Principe de covariance générale.) simple :
Reel = {plus: Nombre x Nombre -> Reel}
Or, mathématiquement, ceci est faux, et du point de vue objet implique une coercition, voire conduit à une erreur de typage ! Ce qui est correct c'est :
Reel = {plus: Reel x Reel -> Reel}. La covariance multiple permet de résoudre ce problème, toutefois, avec un typage de premier ordre, les types des arguments d'entrée du message plus ne peuvent pas être affinés mais seulement généralisés pour garder un typage correct.

La théorie des types de Cook (la théorie F-Bound) permet de résoudre ce problème en redéfinissant ce qu’est un type et ce qu’est une classe, ou plus exactement le sous-typage. Elle définit ce que l’on appelle le typage du second ordre.

Dans cette approche, les concepts de classe et de type ne sont plus distincts mais imbriqués. Une classe ne définit plus la mise en œuvre d’un ou de plusieurs types. Si le type définit toujours l’interface des objets, la classe définit la mise en œuvre d’une famille polymorphique finie et liée de types. Le type est devenu un élément d’une classe. L’accent n’est alors plus mis sur le sous-typage comme dans celle de Liskov, mais sur la sous-classification ; un héritage va décrire l’arborescence entre classes (et donc implicitement entre types). La sous-classification permet de restreindre l’espace des types.

Ainsi, selon cette théorie, une classe est un générateur de types et chaque type est généré en résolvant le paramètre d'entrée du générateur.

Ainsi, selon notre exemple précédent :
Soit Classe_Nombre ( T <: Classe_Nombre(T) ) = { plus: T x T -> T }
Soit Classe_Reel tel que Classe_Reel <: Classe_Nombre.
On a :
Classe_Reel ( T <:Classe_Reel(T) ) = { plus: T x T -> T, moins: T x T -> T }.
Soit Type_Reel = Classe_Reel(Type_Reel), Type_Reel est le point fixe (En mathématiques, pour une application f d’un ensemble E dans lui-même, un élément x de E est un point fixe de f si f(x) = x.) de Classe_Reel
d'où :
Type_Reel = { plus: Reel x Reel -> Reel, moins: Reel x Reel -> Reel }
On a aussi :
Type_Reel < Class_Nombre( Type_Reel <: Classe_Nombre(Type_Reel) ) puisque
Classe_Reel <: Classe_Nombre, soit implicitement
Type_Reel <: Type_Nombre tel que Type_Nombre est le point fixe de Classe_Nombre.
Donc Type_Reel est un type de la classe des nombres.

Des langages comme Smalltalk et Eiffel permettent le typage du second ordre.

Modélisation objet

La modélisation objet consiste à créer un modèle informatique du système de l’utilisateur (un système informatique). Ce modèle peut rassembler aussi bien des éléments du monde réel que des concepts ou des idées propres au métier ou au domaine duquel fera partie le système. La modélisation Objet consiste à définir, à qualifier dans un premier temps (Le temps est un concept développé par l'être humain pour appréhender le changement dans le monde.) ces élements sous forme de types, donc indépendamment de la mise en œuvre. C’est ce que l’on appelle l'analyse orientée objet ou OOA (Object-Oriented Analysis).

Puis, on propose une ou des solutions techniques pour représenter les éléments définis dans le système informatique. C’est ce que l’on appelle la conception orientée objet ou OOD (Object-Oriented Design). Une fois un modèle de conception établi, il est possible au développeur de leur donner corps dans un langage de programmation. C’est ce que l’on appelle la programmation orientée objet ou OOP (Object-Oriented Programming). À un modèle d’analyse peuvent correspondre plusieurs modèles de conception.

Pour écrire ces différents modèles, différents langages et méthodes ont été mis au point, dont OMT de Rumbaugh, BOOCH (La méthode Booch est, avec OMT et OOSE, l'une des méthodes d'analyse et de conception orientées objet à l'origine d'UML. Son nom vient de celui de son concepteur, Grady Booch, qui...)'93 de Booch et OOSE de Jacobson. Toutefois, ces méthodes ne permettaient de modéliser que certains types d’applications et se trouvaient limitées dans d’autres contextes. La méthode OMT prévalait sur l’ensemble des autres méthodes dans la première partie de la décennie 1990.

À partir de 1994, Rumbaugh, Booch et Jacobson ont décidé de s’unir dans l’élaboration d’une nouvelle méthode, suffisamment générique, pour pouvoir s’appliquer à quasiment tous les contextes applicatifs. Ils ont commencé d’abord par définir un langage de modélisation fortement inspiré de celles des méthodes des trois auteurs : UML (Unified Modeling Language). Une fois celui-ci pris en charge (La charge utile (payload en anglais ; la charge payante) représente ce qui est effectivement transporté par un moyen de transport donné, et qui donne lieu à un...) par l’OMG (Object Management Group), un organisme destiné à standardiser des technologies objet, comme CORBA (Common Object Request Broker Architecture), un intergiciel (En informatique, un intergiciel (en anglais middleware) est un logiciel servant d'intermédiaire de communication entre plusieurs applications, généralement complexes ou distribuées sur un réseau...) (middleware en anglais) objet réparti, Rumbaugh, Booch et Jacobson se sont attaqués à la méthode proprement dite: USDP (Unified Software Development Process). Cette méthode définit un cadre générique de développement objet avec UML comme langage de modélisation. USDP (généralement raccourci en UP) est une méthode itérative et incrémentale, centrée sur l’architecture (L’architecture peut se définir comme l’art de bâtir des édifices.) et guidée par les cas d’utilisation et la réduction des risques. C’est aux concepteurs de s’attribuer cette méthode en l’instanciant à leur métier et à leur domaine. Dans l'industrie, deux grandes instances d'USDP existent : RUP (Rational Unified Process) et 2TUP (2TUP (2 track unified process, prononcez "toutiyoupi") est un processus de développement logiciel qui implémente le Processus Unifié.) (2 Tracks Unified Process).

Néanmoins pour un certain nombre de concepteurs objet, dont Bertrand Meyer (Bertrand Meyer (né en 1950 en France) est le créateur du langage de programmation orienté objet Eiffel.), l’inventeur du langage orienté objet Eiffel, guider une modélisation objet par des cas d’utilisations est une erreur de méthode qui n’a rien d’objet et qui est plus proche d’une méthode fonctionnelle. Pour eux, les cas d’utilisations sont relégués à des utilisations plutôt annexes comme la validation d’un modèle par exemple.

Sujets liés

  • Modèles de conception
  • Simula

Bibliographie

  • Brad J. Cox, Andrew J. Novobilski (1986). Object-Oriented Programming: An Evolutionary Approach, ISBN 0201548348.
  • Bertrand Meyer (2000). Conception et programmation orientées objet, ISBN 2-212-09111-7.
  • Grady Booch (Grady Booch (né le 27 février 1955) est le créateur d'une approche d'analyse et de conception orientée objet portant son nom : la méthode booch ; en collaboration avec James Rumbaugh, créateur...), James Rumbaugh (James Rumbaugh est le créateur du langage de modélisation objet OMT. Il est également l'un des trois pères du langage UML, avec Grady Booch (fondateur du langage...), Ivar Jacobson (Ivar Jacobson (né le 2 septembre 1939 à Ystad en Suède) est un informaticien suédois. Il est principalement connu pour être l'un des concepteurs du langage de modélisation UML.) (2000). Le processus unifié de développement logiciel, ISBN 2-212-09142-7.
  • Grady Booch, James Rumbaugh, Ivar Jacobson (2000). Le guide de l’utilisateur UML, ISBN 2-2120-9103-6
  • G. Masini, A. Napoli, D. Colnet, D. Léonard, K. Tombre (1997). Les langages à Objets, Langages de classes, langages de frames, langages d’acteurs, Interéditions, 584 p., ISBN 2729602755
  • De Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1999). Design Patterns, ISBN 2-7117-8644-7.
  • Hugues Bersini (2004). L'Orienté Objet, ISBN 978-2-212-12084-4.
Source: Wikipédia publiée sous licence CC-BY-SA 3.0.

Vous pouvez soumettre une modification à cette définition sur cette page. La liste des auteurs de cet article est disponible ici.