La programmation orientée objet

I) definition et origine

La programmation orientée objet (POO), ou programmation par objet, est un paradigme de programmation informatique élaboré par les Norvégiens Ole-Johan Dahl et Kristen Nygaard au début des années 1960 et poursuivi par les travaux d’Alan Kay dans les années 1970. Il consiste en la définition et l’interaction de briques logicielles appelées objets ; 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. Il possède une structure interne et un comportement, et il sait interagir avec ses pairs. Il s’agit donc de représenter ces objets et leurs relations ; l’interaction entre les objets via leurs relations permet de concevoir et réaliser les fonctionnalités attendues, de mieux résoudre le ou les problèmes. Dès lors, l’étape de modélisation revêt une importance majeure et nécessaire pour la POO. C’est elle qui permet de transcrire les éléments du réel sous forme virtuelle.

II) Les principes

A) l’Objet

Concrètement, un objet est une structure de données valuées et cachées 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 celle-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 quelle réponse doit être donnée au message.

Certains attributs et/ou méthodes (ou plus exactement leur représentation informatique) sont cachés : c’est le principe d’encapsulation. Ainsi, le programme peut modifier la structure interne des objets ou leurs méthodes associées sans avoir d’impact sur les utilisateurs de l’objet.

Un exemple avec un objet représentant un nombre complexe : celui-ci peut être représenté sous différentes formes (cartésienne (réel, imaginaire), trigonométrique, exponentielle (module, angle)). Cette représentation reste cachée et est interne à l’objet. L’objet propose des messages permettant 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 affectés lors d’un changement de sa structure interne. Cette dernière n’est accessible que par les méthodes des messages.

B) 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 (« Que fait-il ? ») 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 définir aussi sa sémantique (Eiffel avec sa conception par contrats).

Un objet peut appartenir à plus d’un type : c’est le polymorphisme ; cela permet d’utiliser des objets de types différents là où est attendu un objet d’un certain type. Une façon de réaliser le polymorphisme est le sous-typage (appelé aussi héritage de type) : on raffine un type-père en un autre type (« le sous-type ») par des restrictions sur les valeurs possibles des attributs. Ainsi, les objets de ce sous-type sont conformes avec le type père. Toutefois, le sous-typage est limité et ne permet pas de résoudre le problème des types récursifs (un message qui prend comme paramètre un objet du type de l’appelant). Pour résoudre ce problème, Cook définit en 1995 la sous-classification et le typage du second ordre qui régit la programmation orientée objet : le type est membre d’une famille polymorphique à point fixe de types (appelée classe). Les traits sont une façon de représenter explicitement les classes de types. (La représentation peut aussi être implicite comme avec Smalltalk, Ruby, etc.)

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

le typage dynamique : le type des objets est déterminé à l’exécution lors de la création desdits objets (Smalltalk, CLOS, Python, PHP…),
le typage statique : le type des objets est vérifié à la compilation et est soit explicitement indiqué par le développeur lors de leur déclaration (C++, Java, C#, Pascal…), soit déterminé par le compilateur à partir du contexte (Scala, OCaml…).

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

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *