Un support de cours magistraux de Java

Concepts de la programmation à objets

Pierre Crescenzo

Introduction

Java est un langage de programmation à objets (on dit aussi orienté objets).

Bien que des exemples et des remarques fassent fréquemment le lien avec Java au cours de ce chapitre, le but est bien ici d'introduire les principaux concepts des langages de programmation à objets, indépendamment d'un langage particulier.
Objet

Définition : Un objet est une entité, une chose concrète ou abstraite qui peut être reconnue distinctement.

Exemples d'objet : un crayon, une automobile, une couleur, une fenêtre sur un écran d'ordinateur…

Chaque objet possède une structure. Par exemple :
- Un crayon a une couleur, un prix…
- Une automobile a une couleur, un propriétaire, un numéro d'immatriculation…
- Une couleur a une teinte, une saturation…
- Une fenêtre sur un écran a une position, une taille, un contenu…
Chaque objet possède aussi un comportement. Par exemple :
- Un crayon peut écrire…
- Une automobile peut démarrer, indiquer le remplissage de son réservoir, changer de propriétaire…
- Une couleur peut varier, s'assombrir…
- Une fenêtre sur un écran peut se déplacer, modifier sa taille, s'icônifier…
Type

Définition : Un type est un ensemble de caractéristiques communes à des objets.

En programmation, le type est une notion abstraite mais importante, concrétisée par différents moyens.
Classe

En informatique, nous manipulons souvent de nombreux objets qui possèdent la même structure et le même comportement.

Définition : Une classe est
- la représentation d'un type de donnée,
- une définition de la structure et du comportement communs à un ensemble d'objets et
- un créateur d'objet.
Par exemple :
- Les automobiles sont de type Automobile, puisque instances de la classe Automobile.
- La classe Automobile décrit la structure et le comportement communs à toutes les automobiles (« automobiles » est donc à prendre au sens d'« objets automobiles »).
- La classe Automobile peut créer des automobiles.
Notez que :
- Chaque objet est dit instance de la classe qui l'a créé.
- Chaque objet définit son état en donnant une valeur aux éléments de la structure de sa classe :
  - La classe Automobile exprime que chaque automobile est constituée, entre autres choses, d'un numéro d'immatriculation.
  - Chaque automobile, instance de la classe Automobile, possède une valeur pour ce numéro d'immatriculation.
- Chaque langage à objets possède ses propres sortes de classe. Elles se ressemblent toutes mais diffèrent néanmoins sur quelques points importants. Par exemple, certains langages (tels Eiffel et C++ mais pas Java) disposent de classes dites génériques. Dans ce cas, la classe représente un ensemble de types et non plus un seul.
Un exemple de classe Java :

class Personne { /* Ceci est la classe Personne. Elle ne contient, pour le moment, qu'un commentaire. */ }
Classifieur

Définition : Un classifieur est une définition et un ensemble d'objets ou de classifieurs.
- La notion de classifieur est un généralisation de celle de classe :
  - Toute classe est un classifieur.
  - Tout ce qui ressemble à une classe (une définition de la structure et du comportement communs à un ensemble d'objets) est un classifieur.
  - Tout ce qui ressemble à un ensemble de classes (ou de classifieurs) est un classifieur.
- Remarque : En Java, les classes, les interfaces, les paquetages… sont des classifieurs.
Le concept de classe est un peu ambigu car ce terme est utilisé avec des acceptions variables dans presque tous les langages à objets. Le concept de classifieur a l'avantage d'être plus général et moins ambigu, je l'utiliserai donc autant que possible.

Attribut, champ

Définition : Un attribut (on dit aussi champ) est un élément de la structure des objets. C'est une variable définie dans le classifieur qui décrit ces objets.

En d'autres termes : les attributs d'un classifieur forment la structure des objets instances de ce classifieur.
Dans son classifieur, chaque attribut possède un nom et un type.
Chaque attribut possède une valeur pour toute instance de son classifieur.

Notre classe Java Personne avec trois attributs :

class Personne {

      

      /* un attribut de nom « nom » et de type « String » (chaîne de caractères) */
      String nom;
      /* un attribut de nom « conjoint » et de type « Personne » */
      Personne conjoint;
      /* un attribut de nom « dateNaissance » et de type « Date » */
      Date dateNaissance;
      

      }

Méthode

Définition : Une méthode est un élément du comportement des objets. C'est une procédure ou une fonction définie dans le classifieur qui décrit ces objets.

En d'autres termes : les méthodes d'un classifieur forment le comportement des objets instances de ce classifieur.
Rappel : Une fonction est un ensemble d'instructions qui réalise un travail et rend un résultat. Par exemple, la fonction multiplier réalise la multiplication de deux nombres et rend comme résultat le produit trouvé. Une procédure est un ensemble d'instructions qui réalise un travail sans rendre de résultat. Par exemple, la procédure dessinerSurÉcran réalise le dessin et n'a rien à rendre.
Chaque méthode possède un nom et une liste de paramètres.
Chaque fonction possède en plus un type de résultat.

Notre classe Java Personne avec ses trois attributs et deux méthodes :

class Personne {

      

      String nom;
      Personne conjoint;
      Date dateNaissance;
      

      /* une procédure (« void » signifie : pas de résultat) de nom « setConjoint », avec un paramètre de nom « c » et de type « Personne », qui permet de changer le conjoint */
      void setConjoint(Personne c) {
      /* Ici, le code de la méthode nous importe peu. */
      }
      

      /* une fonction de nom « âge », sans paramètre, avec un résultat de type « int » (entier), qui calcule l'âge */
      int âge() {
      /* Ici, le code de la méthode nous importe peu. */
      }
      

      }

Constructeur

Définition : Un constructeur est une fonction particulière dont le rôle est de créer un nouvel objet.

Les constructeurs ont principalement trois tâches :

réserver un emplacement en mémoire pour le nouvel objet,
initialiser les attributs de cet objet, c'est-à-dire leur donner une valeur initiale, et
rendre cet objet.

Remarque : Contrairement aux attributs et méthodes, les constructeurs diffèrent de manière très significative entre langages à objets. En Java, comme c'est le cas dans d'autres langages mais pas dans tous, les constructeurs portent exactement le nom de la classe qui les contient. Java dispose aussi d'initialiseurs qui ne sont pas des constructeurs.

Chaque constructeur possède une liste de paramètres.

Notre classe Java Personne avec ses trois attributs, ses deux méthodes et un constructeur (par convention, mais sans obligation, on déclare souvent en Java d'abord les attributs puis les constructeurs et enfin les méthodes) :

class Personne {

      

      String nom;
      Personne conjoint;
      Date dateNaissance;
      

      /* un constructeur, avec un paramètre de nom « n » et de type « String » */
      Personne(String n) {
      /* Ici, le code du constructeur nous importe peu. */
      }
      

      void setConjoint(Personne c) {
      …
      }
      

      int âge() {
      …
      }
      

      }

Destructeur

Définition : Un destructeur est une procédure particulière dont le rôle est de détruire un objet existant.

Les destructeurs ont principalement deux tâches :
1. libérer les ressources utilisées par l'objet (par exemple, fermer un fichier ou une connexion réseau) et
2. libérer l'emplacement réservé en mémoire pour l'objet.
Remarque : Comme les constructeurs, les destructeurs diffèrent de manière très significative entre langages à objets. En Java, comme dans beaucoup de langages à objets, il n'existe pas de destructeur car la libération de la mémoire est gérée automatiquement. Pour la libération des ressources, Java dispose de finaliseurs qui sont d'un usage assez rare.
Ramasse-miettes

Définition : Un ramasse-miettes (en anglais : garbage collector) est un dispositif qui libère automatiquement la mémoire des objets qui ne sont plus accessibles.

Remarque : Java dispose d'un ramasse-miettes intégré, d'où l'inutilité des destructeurs.
Accesseur

Définition : Un accesseur est une méthode qui permet d'accéder en lecture ou en écriture à la valeur d'un attribut.
- Par convention, le rôle des accesseurs se limite à rendre, pour ceux en lecture, ou à modifier, pour ceux en écriture, la valeur de l'attribut concerné, et rien de plus.
- Remarque : Les accesseurs sont des méthodes comme les autres en Java. On les distingue cependant assez aisément car, par habitude, ils portent le nom de get ou set suivi du nom de l'attribut concerné. Par exemple, l'accesseur en lecture de l'attribut prix se nomme généralement getPrix, celui en écriture setPrix.
Membre, primitive, propriété

Définition : Un membre (on dit aussi primitive ou propriété) d'un classifieur est un élément constitutif de celui-ci : un attribut ou une méthode ou un constructeur…, c'est-à-dire une entité déclarée dans le classifieur.

Remarque : Pour Java, les membres d'une classe, par exemple, sont ses attributs, méthodes, constructeurs, initialiseurs, finaliseurs…
Surcharge

Définition : La surcharge est la capacité que possède un classifieur d'avoir plusieurs membres portant le même nom.

Tous les langages à objets n'autorisent pas la surcharge, considérée comme très pratique par certains et source de problèmes par d'autres.

Remarque : Java dispose de la surcharge notamment pour les méthodes et les constructeurs : lorsque deux méthodes ou deux constructeurs portent le même nom, c'est le nombre et le type de leurs paramètres qui permettent alors de les différencier. Rappelons que les constructeurs d'un classifieur portent tous forcément le même nom, puisqu'ils portent tous le nom du classifieur.
Envoi de message

Définition : L'envoi de message est une technique qui consiste pour un objet à demander à un autre objet de réaliser une tâche.

Par exemple, un utilisateur peut demander à un objet fenêtre de se redimensionner ou de se fermer ou un objet bouton peut demander à un objet dessin de s'afficher.

Remarque : En Java, comme généralement dans les langages à objets, l'envoi de message se concrétise par un accès à un attribut ou un appel de méthode.
Encapsulation

Définition : L'encapsulation est une technique essentielle des langages à objets. Elle consiste à réunir au sein d'un classifieur la structure (attributs) et le comportement (méthodes) d'un type de donnée.
- On dit alors que le classifieur encapsule la structure et le comportement.
- L'encapsulation est une évolution de la notion de module que l'on trouve dans des langages tels Pascal ou C.
Les avantages de l'encapsulation sont :
- Elle cache les détails de programmation au sein de chaque classifieur. Donc, les programmeurs, à l'exception de celui du classifieur, n'ont pas à se préoccuper de la manière dont celui-ci est programmé.
- Inversement, les détails étant cachés, les autres programmeurs ne peuvent les prendre en compte et le programmeur du classifieur est ainsi libre de modifier sans risque ces détails.
- L'encapsulation améliore la cohérence : tous les membres d'un classifieur s'appliquent à un type de donnée particulier et sont les seuls à le faire.
- Elle améliore aussi la facilité de modification et de maintenance des programmes : tout ce qui concerne un type de donnée particulier est regroupé dans son classifieur et non plus disséminé dans tout le programme.
Agrégation, composition

Définition : L'agrégation (on dit aussi composition) est la capacité d'un objet à être constitué de manière concrète ou abstraite par d'autres objets ou à faire référence à d'autres objets.
- Par exemple, un objet automobile est constitué d'un objet carrosserie, d'un objet moteur et d'un objet numéroImmatriculation.
- On parle plutôt de composition quand la durée de vie du constituant dépend de celle du constitué : l'objet carrosserie doit être détruit en même temps que l'objet automobile.
- Sinon, on parle plutôt d'agrégation : l'objet numéroImmatriculation doit continuer d'exister même quand ce n'est plus le cas de l'objet automobile.
- Dans les langages à objets, l'agrégation et la composition sont matérialisées par des attributs.
- L'agrégation et la composition sont des relations interclassifieurs.
Héritage

Définition : L'héritage est une technique essentielle des langages à objets. Il permet de définir un nouveau classifieur en fonction d'un classifieur existant.
- L'héritage est propre aux langages à objets. C'est-à-dire que, dans les autres langages, il n'y a pas de moyen qui permette de profiter de la même manière des entités déjà définies.
- L'héritage est bien adapté à la spécialisation : on dit alors que le classifieur héritier spécialise le classifieur hérité. Par exemple, le classifieur Employé spécialise le classifieur Personne : un employé est une personne spécialisée, il dispose en plus d'un employeur et d'un salaire.
- L'héritage peut être simple (chaque classifieur hérite d'un seul classifieur) comme en Java ou multiple (chaque classifieur peut hériter d'un ou plusieurs classifieurs) comme en Eiffel et C++. Chaque choix a ses avantages et inconvénients.
- L'héritage est une évolution de la notion d'importation que l'on trouve dans des langages tels Pascal ou C.
- L'héritage est une relation interclassifieur.
Les avantages de l'héritage sont :
- Il permet de réutiliser facilement du code déjà écrit : le classifieur héritier dispose automatiquement des membres du classifieur hérité.
- Il permet d'organiser les classifieurs selon un arbre d'héritage ou un graphe d'héritage dans lequel un classifieur particulier, la racine, représente le type le plus général et les feuilles figurent les types les plus spécialisés.
- Il est le support du polymorphisme (cf. ci-dessous).
Redéfinition

Définition : La redéfinition est une technique qui permet, dans un classifieur héritier, de donner une nouvelle définition d'un membre déjà présent dans un classifieur hérité.
- La redéfinition est souvent confondue avec la surcharge, alors que ce sont deux choses totalement différentes.
- La redéfinition permet notamment de donner une implémentation plus précise des méthodes dans les classifieurs spécialisés. Par exemple, si on a un classifieur Parallélogramme qui définit une méthode aire, alors le classifieur Carré, qui hérite de Parallélogramme, peut redéfinir aire pour lui donner un code plus adapté.
Polymorphisme

Définition : Le polymorphisme est la capacité d'un objet à prendre plusieurs formes, c'est-à-dire à être manipulé en fonction de son classifieur, mais aussi en fonction d'autres classifieurs compatibles avec le sien.
- Le polymorphisme est, avec l'encapsulation et l'héritage, le troisième point fort spécifique aux langages à objets.
- De manière générale dans les langages à objets, tout objet peut être manipulé en fonction de son classifieur et en fonction de tous les classifieurs dont hérite, directement ou indirectement, son classifieur. Par exemple, un objet de type Employé peut être manipulé comme instance du classifieur Employé bien sûr, mais aussi comme instance (indirecte) de Personne ou encore comme un très général Objet.