Programmation orientée objet

Infos
La programmation orientée objet (POO) ou programmation par objet, est un paradigme de programmation informatique qui consiste en la définition et l'assemblage de briques logicielles appelées objet ; un objet représente un concept, une idée ou toute entité du monde physique, 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, exist
Programmation orientée objet

La programmation orientée objet (POO) ou programmation par objet, est un paradigme de programmation informatique qui consiste en la définition et l'assemblage de briques logicielles appelées objet ; un objet représente un concept, une idée ou toute entité du monde physique, 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 objet dont la plus connue est USDP (Unified Software Development Process). Il est possible de concevoir par objet une application informatique 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 (Objective C, 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 (CLOS, OCaml…) ou impérative (C++, Java…) ou les deux (Python).

Origines

Le langage Simula-67 jette les prémisses de la programmation objet, résultat des travaux sur la mise au point de langages de simulation dans les années 1960 dont s'inspira aussi la recherche sur l’intelligence artificielle 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, polymorphisme, héritage (sous-typage ou sous-classification), redéfinition, etc. Smalltalk est plus qu'un langage à objets, il est aussi un environnement graphique 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 davantage comme un paradigme, le paradigme objet, que comme une simple technique de programmation. C'est pourquoi, lorsque l'on parle de nos jours de programmation par objets, on désigne avant tout 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 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 sont appelées ses attributs ;
- L'ensemble des messages forme ce que l'on appelle l'interface 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 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 impact sur les utilisateurs des objets. Exemple d'un objet représentant un nombre complexe donné. Celui-ci peut aussi bien être représenté sous forme cartésienne (réel, imaginaire) que sous forme trigonométrique ou exponentielle (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 = et un sous-type Integer Reel et son sous-type Entier Nombre, soit Reel Nombre ou au mieux, avec la covariance simple : 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 = . 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 T Soit Classe_Reel tel que Classe_Reel T . Soit Type_Reel = Classe_Reel(Type_Reel), Type_Reel est le point fixe de Classe_Reel d'où : Type_Reel = On a aussi : Type_Reel < Class_Nombre( Type_Reel
Sujets connexes
Années 1960   Années 1970   Années 1980   Années 1990   Atelier de génie logiciel   Barbara Liskov   Bertrand Meyer   C++   Classe (informatique)   Common Lisp Object System   Common Object Request Broker Architecture   Eiffel (langage)   Encapsulation (programmation)   Grady Booch   Héritage multiple   Inférence de types   Intelligence artificielle   Interface   Intergiciel   Ivar Jacobson   James Rumbaugh   Java (langage)   Java (technologie)   Mise en œuvre   Object Management Group   Object Modeling Technique   Objective C   Objective Caml   Objet (informatique)   Paradigme (programmation)   Polymorphisme (informatique)   Principe de substitution de Liskov   Programmation informatique   Programmation orientée prototype   Python (langage)   Remote method invocation (Java)   Réduction des risques   Simula   Simulation   Smalltalk   Typage dynamique   Typage statique  
#
Accident de Beaune   Amélie Mauresmo   Anisocytose   C3H6O   CA Paris   Carole Richert   Catherinettes   Chaleur massique   Championnat de Tunisie de football D2   Classement mondial des entreprises leader par secteur   Col du Bonhomme (Vosges)   De viris illustribus (Lhomond)   Dolcett   EGP  
^