ou

---

qui peuvent interférer avec la mise en forme du document. INFO Si vos commentaires contiennent des liens vers d’autres fichiers comme des images (par exemple des diagrammes ou des images de composants de l’interface utilisateur), placez ces fichiers dans des sous-répertoires appelés doc-files. L’utilitaire javadoc copiera ces répertoires et les fichiers qu’ils contiennent vers le répertoire documentation.

Commentaires de classe Un commentaire de classe doit être placé après les instructions import, juste avant la définition class. Voici un exemple : /** Un objet Card représente une carte à jouer, telle que "Dame de coeur". Une carte a une couleur (Pique, Coeur, Trèfle ou Carreau) et une valeur (1 = As, 2 . . . 10, 11 = Valet, 12 = Dame, 13 = Roi).

Livre Java .book Page 169 Jeudi, 25. novembre 2004 3:04 15

Chapitre 4

Objets et classes

169

*/ public class Card { . . . }

INFO De nombreux programmeurs commencent chaque ligne de documentation par un astérisque, comme ci-après : /** * Un objet Card représente une carte à jouer, telle * que "Dame de cœur". Une carte a une couleur (Pique, Cœur, * Trèfle ou Carreau) et une valeur (1 = As, 2 . . . 10, 11 = Valet, * 12 = Dame, 13 = Roi) */

Cette méthode n’est pas recommandée, car elle décourage les programmeurs de mettre à jour les commentaires. Il est fastidieux de réorganiser les * si la longueur de la ligne change. Certains éditeurs de texte prennent en charge cette corvée. Si vous savez que les futurs mainteneurs de votre code vont utiliser un tel éditeur de texte, vous pouvez ajouter ce style de détail qui délimite bien les commentaires.

Commentaires de méthode Chaque commentaire de méthode doit immédiatement précéder la méthode qu’il décrit. En plus des balises générales, vous pouvez utiliser les balises suivantes : @param description de variable

Cette balise ajoute une entrée à la section des paramètres (parameters) de la méthode courante. La description peut occuper plusieurs lignes et avoir recours aux balises HTML. Toutes les balises @param pour une méthode doivent être regroupées : @return description

Cette balise ajoute une section de renvoi (returns) à la méthode courante. La description peut occuper plusieurs lignes et avoir recours aux balises HTML : @throws description de classe

Cette balise ajoute une note concernant le déclenchement possible d’une exception par la méthode. Les exceptions sont traitées au Chapitre 11. Voici un exemple de commentaire de méthode : /** Augmente le salaire d’un employé. @param byPercent le pourcentage d’augmentation du salaire (par ex. 10 = 10%) @return le montant de l’augmentation */ public double raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; return raise; }

Livre Java .book Page 170 Jeudi, 25. novembre 2004 3:04 15

170

Au cœur de Java 2 - Notions fondamentales

Commentaires de champ Seuls les champs publics doivent être documentés — c’est-à-dire généralement des constantes statiques. Par exemple : /** La couleur "Coeur" */ public static final int HEARTS = 1;

Commentaires généraux Les balises suivantes peuvent être employées dans les commentaires de documentation de classe : @author nom

Cette balise crée une mention d’auteur (author). Il peut y avoir plusieurs balises @author, une pour chaque auteur : @version texte

Cette balise crée une entrée "version". Le texte décrit la version courante. Les balises suivantes peuvent être employées dans tous les commentaires de documentation : @since texte

Cette balise crée une entrée "depuis" (since). Le texte peut être toute description de la version ayant introduit cette fonctionnalité. Par exemple, @since version 1.7.1 : @deprecated texte

Cette balise ajoute un commentaire signalant que la classe, la méthode ou la variable est dépréciée et ne doit plus être utilisée. Le texte doit suggérer une solution de remplacement. Par exemple : @deprecated Utiliser setVisible(true) à la place

Vous pouvez ajouter des liens hypertexte vers d’autres parties connexes de la documentation javadoc, ou vers d’autres documents externes, à l’aide des balises @see et @link : @see référence

Cette balise ajoute un lien hypertexte dans la section "see also" (voir aussi). Elle peut être employée avec les classes et les méthodes. Ici, référence peut être l’un des choix suivants : package.classe#fonctionnalité label label "texte"

La première possibilité est la plus utile. Vous fournissez le nom d’une classe, d’une méthode ou d’une variable, et javadoc insère un lien hypertexte vers la documentation. Par exemple, @see com.horstmann.corejava.Employee#raiseSalary(double)

crée un lien vers la méthode raiseSalary(double) dans la classe com.horstmann.corejava.Employee. Vous pouvez omettre le nom du package ou à la fois les noms de package et de classe. La fonctionnalité est alors recherchée dans le package ou la classe courants. Notez que vous devez utiliser un #, et non un point, pour séparer la classe du nom de la méthode ou de la variable. Le compilateur Java lui-même est assez futé pour déterminer la signification du caractère point, comme séparateur entre les packages, les sous-packages, les classes, les classes internes, et les méthodes ou variables. L’utilitaire javadoc, lui, n’est pas aussi pointu, et vous devez l’aider.

Livre Java .book Page 171 Jeudi, 25. novembre 2004 3:04 15

Chapitre 4

Objets et classes

171

Si la balise @see est suivie d’un caractère <, vous devez spécifier un lien hypertexte. Le lien peut concerner n’importe quelle adresse URL. Par exemple : @see The Core Java home page

Dans chaque cas, vous pouvez spécifier un label facultatif, qui apparaîtra en tant qu’ancre du lien. Si vous omettez le label, le nom du code cible ou l’URL apparaîtront à l’utilisateur en tant qu’ancre. Si la balise @see est suivie d’un caractère ", le texte s’affiche dans la section "see also". Par exemple : @see "Core Java 2 volume 2"

Vous pouvez ajouter plusieurs balises @see pour une fonctionnalité, mais vous devez les regrouper ensemble. Vous pouvez aussi placer les liens hypertexte vers d’autres classes ou méthodes, n’importe où dans vos commentaires. Vous insérez une balise spéciale sous la forme {@link package.classe#fonctionnalité label} n’importe où dans un commentaire. La description de la fonctionnalité suit les mêmes règles que pour la balise @see.

Commentaires de package et d’ensemble Vous placez les commentaires de classe, de méthode et de variable directement dans les fichiers source Java, délimités par les commentaires de documentation /** . . . */. Toutefois, pour générer des commentaires de package, vous devez ajouter un fichier appelé package.html dans chaque répertoire de package. Tout texte entre les balises ... est extrait. Vous pouvez aussi fournir un commentaire d’ensemble pour tous les fichiers source. Placez-le dans un fichier appelé overview.html, situé dans le répertoire parent qui contient tous les fichiers source. Tout le texte entre les balises ... est extrait. Ce commentaire de vue d’ensemble s’affiche lorsque l’utilisateur sélectionne "Overview" dans la barre de navigation.

Extraction des commentaires Ici, docDirectory est le nom du répertoire où vous voulez stocker les fichiers HTML. Voici les étapes à suivre : 1. Positionnez-vous dans le répertoire contenant les fichiers source à documenter. Si vous devez documenter des packages imbriqués, tels que com.horstmann.corejava, vous devez vous trouver dans le répertoire qui contient le sous-répertoire com (le répertoire qui contient le fichier overview.html, le cas échéant). 2. Exécutez la commande javadoc -d docDirectory nomDuPackage

pour un package simple. Ou exécutez javadoc -d docDirectory nomDuPackage1 nomDuPackage2...

pour documenter plusieurs packages. Si vos fichiers se trouvent dans le package par défaut, exécutez javadoc -d docDirectory *.java

à la place.

Livre Java .book Page 172 Jeudi, 25. novembre 2004 3:04 15

172

Au cœur de Java 2 - Notions fondamentales

Si vous avez omis l’option -d docDirectory, les fichiers HTML sont extraits du répertoire courant. Cela peut devenir compliqué et n’est pas recommandé. Le programme javadoc peut être personnalisé par de nombreuses options de ligne de commande. Vous pouvez, par exemple, employer les options -author et -version pour inclure les balises @author et @version dans la documentation (elles sont omises par défaut). Une autre option utile est -link, pour inclure des liens hypertexte vers les classes standard. Par exemple, si vous utilisez la commande javadoc –link http://java.sun.com/j2se/5.0/docs/api *.java

toutes les classes de la bibliothèque standard sont automatiquement liées à la documentation du site Web de Sun. Pour découvrir d’autres options, vous pouvez consulter la documentation en ligne de l’utilitaire javadoc à l’adresse http://java.sun.com/j2se/javadoc/. INFO Si vous avez besoin de personnalisation supplémentaire, par exemple pour produire une documentation sous un format autre que HTML, vous pouvez fournir votre propre doclet pour générer la sortie sous la forme que vous voulez. Il s’agit là d’une requête très particulière, et vous devez vous reporter à la documentation en ligne spécifique à l’adresse suivante : http://java.sun.com/j2se/javadoc

ASTUCE DocCheck est un doclet utile disponible à l’adresse http://java.sun.com/j2se/javadoc/doccheck/. Il analyse un jeu de fichiers source à la recherche des commentaires de documentation manquants.

Conseils pour la conception de classes Sans vouloir être exhaustif ou ennuyeux, nous allons terminer ce chapitre par quelques conseils qui permettront à vos classes de faire bonne figure dans les cercles élégants de la POO. 1. Les données doivent être privées. C’est une règle absolue : toute exception viole le principe d’encapsulation. Vous pouvez écrire en cas de besoin une méthode d’accès ou une méthode d’altération, mais les champs proprement dits doivent rester privés. L’expérience a montré que la représentation des données peut changer, mais que la manière dont on les utilise change plus rarement. Lorsque les données sont privées, une modification de leur représentation n’affecte pas l’utilisateur de la classe, et les bogues sont plus facilement détectables. 2. Initialisez toujours les données. Java n’initialise pas les variables locales à votre place, mais il initialise les champs d’instance des objets. Ne vous fiez pas aveuglément aux valeurs par défaut ; initialisez explicitement les variables en spécifiant leur valeur par défaut, soit dans la classe, soit dans tous les constructeurs.

Livre Java .book Page 173 Jeudi, 25. novembre 2004 3:04 15

Chapitre 4

Objets et classes

173

3. N’abusez pas des types de base dans une classe. Le principe consiste à remplacer plusieurs champs (apparentés) par une autre classe. Vos classes seront ainsi plus aisées à comprendre et à modifier. Par exemple, dans une classe Customer, remplacez private private private private

String String String String

street; city; state; zip;

par une nouvelle classe nommée Address. De cette manière, vous pourrez facilement faire face à une éventuelle modification de la présentation des adresses (pour le courrier international, par exemple). 4. Tous les champs n’ont pas besoin de méthodes d’accès et de méthodes d’altération. Vous pouvez avoir besoin de connaître et de modifier le salaire d’un employé. En revanche, une fois l’objet construit, il n’est pas nécessaire de modifier sa date d’embauche. Bien souvent, les objets contiennent des champs d’instance qui ne doivent pas être lus ni modifiés par d’autres — par exemple, le tableau des codes postaux dans une classe Address. 5. Utilisez un format standard pour la définition de vos classes. Nous présentons toujours le contenu des classes dans l’ordre suivant : – éléments publics ; – éléments accessibles au package ; – éléments privés. Chaque section est organisée ainsi : – méthodes d’instance ; – méthodes statiques ; – champs d’instance ; – champs statiques. Après tout, les utilisateurs de votre classe sont davantage concernés par l’interface publique que par les détails de l’implémentation privée. Et ils s’intéressent plus aux méthodes qu’aux données. En fait, il n’existe pas de convention universelle concernant le meilleur style. Le guide Sun du langage de programmation Java recommande de lister d’abord les champs, puis les méthodes. Quel que soit le style que vous adopterez, l’essentiel est de rester cohérent. 6. Subdivisez les classes ayant trop de responsabilités. Ce conseil peut sembler vague, car le terme "trop" est relatif. En bref, chaque fois qu’il existe une possibilité manifeste de diviser une classe complexe en deux classes conceptuellement plus simples, profitez de l’occasion (mais n’exagérez pas, la complexité renaîtra si vous créez trop de petites sous-classes).

Livre Java .book Page 174 Jeudi, 25. novembre 2004 3:04 15

174

Au cœur de Java 2 - Notions fondamentales

Voici un exemple de conception maladroite : public class CardDeck // conception maladroite { public    public    public public    public

CardDeck() { . . . } void shuffle() { . . . } int getTopValue() { . . . } int getTopSuit() { . . . } void draw() { . . . }

private int[] value; private int[] suit; }

Cette classe implémente en réalité deux concepts séparés : un jeu de cartes avec ses méthodes shuffle et draw, et une carte avec les méthodes permettant d’inspecter la valeur et la couleur d’une carte. Il est logique ici d’introduire une classe Card représentant une carte individuelle. Vous avez maintenant deux classes, avec chacune ses propres responsabilités : public class CardDeck { public CardDeck() { . . . }    public void shuffle() { . . . }    public Card getTop() { . . . }    public void draw() { . . . } private Card[] cards; } public class Card { public Card(int aValue, int aSuit) { . . . } public int getValue() { . . . } public int getSuit() { . . . } private int value; private int suit; }

7. Donnez des noms significatifs à vos classes et à vos méthodes. Les variables doivent toujours avoir un nom représentatif de leur contenu. Il en va de même pour les classes (il est vrai que la bibliothèque standard contient quelques exemples contestables, comme la classe Date qui concerne l’heure). Un bon principe consiste à nommer les classes avec un substantif (Order) ou un substantif associé à un adjectif (RushOrder). Pour les méthodes, respectez la convention standard en faisant débuter leur nom par un préfixe en minuscules : get pour les méthodes d’accès (getSalary) et set pour les méthodes d’altération (setSalary).

Livre Java .book Page 175 Jeudi, 25. novembre 2004 3:04 15

5 L’héritage Au sommaire de ce chapitre

✔ Classes, superclasses et sous-classes ✔ Object : la superclasse cosmique ✔ Listes de tableaux génériques ✔ Enveloppes d’objets et autoboxing ✔ Réflexion ✔ Enumération de classes ✔ Conseils pour l’utilisation de l’héritage Le chapitre précédent étudiait les classes et les objets. Celui-ci traite de l’héritage, essentiel dans la programmation orientée objet. L’idée qui sous-tend ce concept est que vous pouvez créer de nouvelles classes basées sur des classes existantes. Lorsque vous héritez d’une classe, vous réutilisez (ou héritez de) ses méthodes et champs, et ajoutez de nouveaux champs pour adapter votre classe à de nouvelles situations. Cette technique est essentielle en programmation Java. Si votre expérience concerne essentiellement les langages procéduraux, comme C, Visual Basic ou COBOL, nous vous conseillons de lire attentivement ce chapitre. Les programmeurs C++ chevronnés, ainsi que ceux qui ont déjà expérimenté un langage orienté objet comme Smalltalk, seront ici en territoire connu ; il existe néanmoins de nombreuses différences entre l’implémentation de l’héritage en Java et son implémentation dans les autres langages orientés objet. La dernière partie de ce chapitre couvre la réflexion, la capacité d’en savoir plus au sujet des classes et de leurs propriétés dans un programme en cours d’exécution. La réflexion est une fonctionnalité puissante, mais indéniablement complexe. Elle concerne plus les concepteurs d’outils que les programmeurs d’application, et vous pouvez donc vous contenter de survoler cette section dans un premier temps, pour y revenir plus tard.

Livre Java .book Page 176 Jeudi, 25. novembre 2004 3:04 15

176

Au cœur de Java 2 - Notions fondamentales

Classes, superclasses et sous-classes Revenons à la classe Employee, déjà présentée au Chapitre 4. Supposons que vous travailliez pour une entreprise au sein de laquelle les directeurs (managers) sont traités différemment des autres employés. Les directeurs sont aussi des employés sous bien des aspects. Tout comme les employés, ils reçoivent un salaire. Toutefois, tandis que les employés sont censés exécuter leurs tâches en échange de leur salaire, les dirigeants reçoivent un bonus s’ils atteignent leurs objectifs. C’est le genre de situation qui appelle fortement l’héritage. Pour quelle raison ? Parce qu’il faut définir une nouvelle classe, Manager, et y ajouter des fonctionnalités. Vous pouvez cependant conserver une partie de ce que vous avez déjà programmé dans la classe Employee, et tous les champs de la classe d’origine seront préservés. D’une façon plus abstraite, disons qu’il existe une relation "est" entre Manager et Employee. Tout directeur est un employé : cette relation d’état (ou d’appartenance) est le flambeau de l’héritage. Voici comment définir une classe Manager qui hérite de la classe Employee. Le mot clé extends est employé en Java pour signifier l’héritage. class Manager extends Employee { méthodes et champs ajoutés }

INFO C++ L’héritage est comparable en Java et en C++. Java utilise le mot clé extends au lieu de :. Tout héritage en Java est public ; il n’existe pas d’analogie avec les fonctionnalités C++ d’héritage privé et protégé.

Le mot clé extends signifie que vous créez une nouvelle classe qui dérive d’une classe existante. La classe existante est appelée superclasse, classe de base ou encore classe parent (voire classe ancêtre). La nouvelle classe est appelée sous-classe, classe dérivée ou classe enfant. Les termes superclasse et sous-classe sont les plus courants en programmation Java, bien que certains programmeurs préfèrent l’analogie parent/enfant, qui convient bien à la notion d’héritage. La classe Employee est une superclasse, mais ce n’est pas parce qu’elle serait supérieure à une sousclasse ou contiendrait plus de fonctionnalités. En fait, c’est le contraire : les sous-classes offrent plus de fonctionnalités que leur superclasse. Par exemple, comme vous le verrez lors de l’examen du reste de la classe Manager, cette dernière encapsule plus de données et possède plus de fonctionnalités que sa superclasse Employee. INFO En anglais, les préfixes super et sub (sous) sont issus du langage des ensembles employé en informatique théorique et en mathématiques. L’ensemble de tous les employés contient l’ensemble de tous les directeurs ; on dit qu’il s’agit d’un superensemble de l’ensemble des directeurs. En d’autres termes, l’ensemble de tous les directeurs est un sousensemble de l’ensemble de tous les employés.

Livre Java .book Page 177 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

177

Notre classe Manager a un nouveau champ pour stocker le bonus, et une nouvelle méthode pour le définir : class Manager extends Employee { . . . public void setBonus(double b) { bonus = b; } private double bonus; }

Ces méthodes et champs n’ont rien de particulier. Si vous avez un objet Manager, vous pouvez simplement appliquer la méthode setBonus : Manager boss = . . .; boss.setBonus(5000);

Vous ne pouvez pas appliquer la méthode setBonus à un objet Employee, elle ne fait pas partie des méthodes définies dans la classe Employee. Vous pouvez cependant utiliser des méthodes telles que getName et getHireDay avec les objets Manager. Même si ces méthodes ne sont pas explicitement définies dans la classe Manager, celle-ci en hérite automatiquement de la superclasse Employee. De même, les champs name, salary et hireDay sont hérités de la superclasse. Chaque objet Manager a quatre champs : name, salary, hireDay et bonus. Lors de la définition d’une sous-classe par extension de sa superclasse, il vous suffit d’indiquer les différences entre les sous-classes et la superclasse. Lors de la conception de classes, vous placez les méthodes les plus générales dans la superclasse, et celles plus spécialisées dans la sous-classe. La mise en commun de fonctionnalités dans une superclasse est très fréquente en programmation orientée objet. Cependant, certaines des méthodes de la superclasse ne conviennent pas pour la sous-classe Manager. En particulier, la méthode getSalary, qui doit renvoyer la somme du salaire de base et du bonus. Vous devez fournir une nouvelle méthode pour remplacer celle de la superclasse : class Manager extends Employee { . . . public double getSalary() { . . . } . . . }

Comment pouvez-vous implémenter cette méthode ? Au premier abord, cela paraît simple : renvoyez simplement la somme des champs salary et bonus : public double getSalary() { return salary + bonus; // ne marche pas }

Livre Java .book Page 178 Jeudi, 25. novembre 2004 3:04 15

178

Au cœur de Java 2 - Notions fondamentales

Cela ne peut pas marcher. La méthode getSalary de la classe Manager n’a pas d’accès direct aux champs privés de la superclasse. Cela signifie que la méthode getSalary de la classe Manager ne peut pas accéder directement au champ salary, même si chaque objet Manager a un champ appelé salary. Seules les méthodes de la classe Employee ont accès aux champs privés. Si les méthodes de Manager veulent accéder à ces champs privés, elles doivent procéder comme les autres méthodes : utiliser l’interface publique, c’est-à-dire la méthode publique getSalary de la classe Employee. Essayons à nouveau. Nous voulons donc appeler getSalary au lieu d’accéder simplement au champ salary : public double getSalary() { double baseSalary = getSalary(); // ne marche toujours pas return baseSalary + bonus; }

Le problème est que l’appel à getSalary réalise simplement un appel à lui-même, puisque la classe Manager a une méthode getSalary (précisément la méthode que nous essayons d’implémenter). Il s’ensuit une série infinie d’appels à la même méthode, ce qui entraîne un plantage du programme. Nous devons préciser que nous voulons appeler la méthode getSalary de la superclasse Employee, et non celle de la classe courante. Vous devez pour cela utiliser le mot clé super, l’appel super.getSalary()

appelle la méthode getSalary de la classe Employee. Voici la version correcte de la méthode getSalary pour la classe Manager : public double getSalary() { double baseSalary = super.getSalary(); return baseSalary + bonus; }

INFO Certains pensent que super est analogue à la référence à this. Cette analogie n’est toutefois pas exacte — super n’est pas une référence à un objet. Par exemple, vous ne pouvez pas affecter la valeur super à une autre variable objet. super est un mot clé spécial qui demande au compilateur d’invoquer la méthode de la superclasse.

Vous avez vu qu’une sous-classe pouvait ajouter des champs et qu’elle pouvait ajouter ou remplacer des méthodes de la superclasse. Cependant, l’héritage ne peut pas ôter des champs ou des méthodes. INFO C++ Java utilise le mot clé super pour appeler une méthode de superclasse. En C++, vous utilisez le nom de la superclasse avec l’opérateur ::. Par exemple, la méthode getSalary de la classe Manager appellera Employee::getSalary au lieu de super.getSalary.

Livre Java .book Page 179 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

179

Enfin, nous allons fournir un constructeur : public Manager(String n, double s, int year, int month, int day) { super(n, s, year, month, day); bonus = 0; }

Ici, le mot clé super a une signification différente. L’instruction super(n, s, year, month, day);

est un raccourci pour dire "appeler le constructeur de la superclasse Employee avec n, s, year, month et day comme paramètres". Puisque le constructeur de Manager ne peut pas accéder aux champs privés de la classe Employee, ils doivent être initialisés par l’intermédiaire d’un constructeur. Le constructeur est invoqué à l’aide de la syntaxe spéciale super. L’appel utilisant super doit être la première instruction dans le constructeur pour la sous-classe. Si le constructeur de la sous-classe n’appelle pas explicitement un constructeur de la superclasse, le constructeur par défaut est appelé (sans paramètre). Au cas où la superclasse ne posséderait pas de constructeur par défaut — et où aucun autre constructeur n’est appelé explicitement à partir du constructeur de la sous-classe — le compilateur Java indique une erreur. INFO Souvenez-vous que le mot clé this a deux significations : définir une référence au paramètre implicite, et appeler un autre constructeur de la même classe. Le mot clé super a également deux significations : invoquer une méthode de superclasse, et invoquer un constructeur de superclasse. Lorsqu’ils sont utilisés pour invoquer des constructeurs, les mots clés this et super sont très proches. Les appels de constructeur ne peuvent qu’être la première instruction dans un autre constructeur. Les paramètres de construction sont passés, soit à un autre constructeur de la même classe (this), soit à un constructeur de la superclasse (super).

INFO C++ Dans un constructeur C++, vous n’appelez pas super, mais vous utilisez la syntaxe de liste d’initialisation pour construire la superclasse. Le constructeur Manager a l’aspect suivant en C++ : Manager::Manager(String n, double s, int year, int month, int day) // C++ { bonus = 0; }

La conséquence de la redéfinition de la méthode getSalary pour les objets Manager, est que pour les directeurs, le bonus est automatiquement ajouté au salaire. Pour comprendre ce fonctionnement, créons un nouveau directeur et définissons son bonus : Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15); boss.setBonus(5000);

Livre Java .book Page 180 Jeudi, 25. novembre 2004 3:04 15

180

Au cœur de Java 2 - Notions fondamentales

Créons un tableau de trois employés : Employee[] staff = new Employee[3];

Affectons à ce tableau le personnel de l’entreprise (employés et directeurs) : staff[0] staff[1] 1989, staff[2] 1990,

= boss; = new Employee("Harry Hacker", 50000, 10, 1); = new Employee("Tony Tester", 40000, 3, 15);

Affichons le salaire de chacun : for (Employee e : staff) System.out.println(e.getName() + " "  + e.getSalary());;

Cette boucle affiche les données suivantes : Carl Cracker 85000.0 Harry Hacker 50000.0 Tommy Tester 40000.0

staff[1] et staff[2] affichent leur salaire de base, car ce sont des objets de la classe Employee. En revanche, staff[0] est un objet Manager et sa méthode getSalary ajoute le bonus au salaire de base. Ce qui est important, c’est que l’appel e.getSalary()

sélectionne la méthode getSalary correcte. Notez que le type déclaré de e est Employee, mais que le type réel de l’objet auquel e fait référence peut être soit Employee (si i vaut 1 ou 2), soit Manager (si i vaut 0). Lorsque e fait référence à un objet Employee, l’appel e.getSalary() appelle la méthode getSalary de la classe Employee. Si toutefois, e fait référence à un objet Manager, c’est la méthode getSalary de la classe Manager qui est appelée à la place. La machine virtuelle connaît le type réel de l’objet auquel e fait référence et invoque par conséquent la méthode qui convient. Cette possibilité pour une variable objet (comme la variable e) de pouvoir faire référence à plusieurs types est appelée polymorphisme. La sélection automatique de la méthode appropriée lors de l’exécution est appelée liaison dynamique. Nous reviendrons sur ces deux concepts plus en détail dans ce chapitre. INFO C++ En Java, vous n’avez pas besoin de déclarer une méthode comme virtuelle. La liaison dynamique est le comportement par défaut. Si vous ne voulez pas qu’une méthode soit virtuelle, attribuez-lui le mot clé final (nous y reviendrons dans ce chapitre).

L’Exemple 5.1 contient un programme qui montre la façon dont diffère le calcul du salaire pour les objets Employee et Manager.

Livre Java .book Page 181 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

Exemple 5.1 : ManagerTest.java import java.util.*; public class ManagerTest { public static void main(String[] args) { // construire un objet Manager Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15); boss.setBonus(5000); Employee[] staff = new Employee[3]; // remplir le tableau staff avec des objets Manager et Employee staff[0] staff[1] 1989, staff[2] 1990,

= boss; = new Employee("Harry Hacker", 50000, 10, 1); = new Employee("Tommy Tester", 40000, 3, 15);

// imprimer les infos concernant tous les objets Employee for (Employee e : staff) System.out.println("name=" + e.getName()  + ",salary=" + e.getSalary()); } } class Employee { public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); hireDay = calendar.getTime(); } public String getName() { return name; } public double getSalary() { return salary; } public Date getHireDay() { return hireDay; }

181

Livre Java .book Page 182 Jeudi, 25. novembre 2004 3:04 15

182

Au cœur de Java 2 - Notions fondamentales

public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } private String name; private double salary; private Date hireDay; } class Manager extends Employee { /** @param n Nom de l’employé @param s Le salaire @param year L’année d’embauche @param month Le mois d’embauche @param day Le jour d’embauche */ public Manager(String n, double s, int year, int month, int day) { super(n, s, year, month, day); bonus = 0; } public double getSalary() { double baseSalary = super.getSalary(); return baseSalary + bonus; } public void setBonus(double b) { bonus = b; } private double bonus; }

Hiérarchie d’héritage L’héritage n’est pas obligé de se limiter à une seule couche de classes dérivées. Nous pourrions, par exemple, créer une classe Executive (Cadre) qui prolonge Manager. L’ensemble de toutes les classes dérivées d’une superclasse commune est appelé hiérarchie d’héritage ou hiérarchie des classes, (voir Figure 5.1). Le chemin d’accès à une classe particulière vers ses ancêtres, dans la hiérarchie d’héritage, se nomme la chaîne d’héritage. Il existe généralement plusieurs chaînes descendant d’une même classe ancêtre. Vous pouvez former une sous-classe Programmer ou Secretary qui prolonge la classe Employee : elles n’auront aucune relation avec la classe Manager (ni entre elles). Le processus de création de classes dérivées n’est pas limité.

Livre Java .book Page 183 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

183

INFO C++ Java ne prend pas en charge l’héritage multiple (pour savoir comment récupérer la majeure partie des fonctionnalités de l’héritage multiple, voir la section sur les interfaces au prochain chapitre).

Figure 5.1 Hiérarchie d’héritage de Employee.

Employee

Manager

Secretary

Programmer

Executive

Polymorphisme Il existe une règle simple pour savoir si l’héritage est ou non le concept à envisager pour vos données. La relation "est" dit que tout objet de la sous-classe est un objet de la superclasse. Par exemple, chaque directeur est un employé. Il est par conséquent logique que la classe Manager soit une sous-classe de la classe Employee. La réciproque n’est évidemment pas vraie — chaque employé n’est pas un directeur. Une autre façon de formuler cette relation est le principe de substitution. Il précise que vous pouvez utiliser un objet d’une sous-classe chaque fois que le programme attend un objet d’une superclasse. Vous pouvez ainsi affecter un objet d’une sous-classe à une variable de la superclasse : Employee e; e = new Employee(. . .); // objet Employee attendu e = new Manager(. . .); // OK, Manager peut aussi être utilisé

Dans le langage Java, les variables objet sont polymorphes. Une variable du type Employee peut faire référence à un objet du type Employee ou à un objet de toute sous-classe de la classe Employee (tel que Manager, Executive, Secretary, etc.). Nous tirons parti de ce principe dans l’Exemple 5.1 : Manager boss = new Manager(. . .); Employee[] staff = new Employee[3]; staff[0] = boss;

Dans ce cas, les variables staff[0] et boss font référence au même objet. Cependant, staff[0] est considéré par le compilateur comme seulement un objet Employee. Cela signifie que vous pouvez appeler boss.setBonus(5000); // OK

Livre Java .book Page 184 Jeudi, 25. novembre 2004 3:04 15

184

Au cœur de Java 2 - Notions fondamentales

mais pas staff[0].setBonus(5000); // ERREUR

Le type déclaré de staff[0] est Employee, et la méthode setBonus n’est pas une méthode de la classe Employee. Vous ne pouvez toutefois pas affecter une référence de superclasse à une variable de sous-classe. Par exemple, l’affectation suivante est incorrecte : Manager m = staff[i]; // ERREUR

La raison de cette interdiction est simple : tous les employés ne sont pas directeurs. Si cette affectation réussissait et que m puisse faire référence à un objet Employee qui ne soit pas un directeur, il serait possible d’appeler ultérieurement m.setBonus(...), et une erreur d’exécution s’ensuivrait. ATTENTION En Java, il est possible de transformer des tableaux de références de sous-classes en tableaux de références de superclasses, sans transtypage. Envisageons par exemple un tableau de directeurs Manager[] managers = new Manager[10];

La conversion de ce tableau en tableau Employee[] est autorisée : Employee[] staff = managers; // OK

Pourquoi pas, après tout ? Si manager[i] est un objet Manager, c’est également un objet Employee. En fait, un événement surprenant survient. N’oubliez pas que les managers et staff font référence au même tableau. Etudiez maintenant l’instruction staff[0] = new Employee("Harry Hacker", ...);

Le compilateur autorisera cette instruction avec plaisir. Mais staff[0] et manager[0] constituent la même référence, on dirait donc que nous avons réussi à faire passer clandestinement un employé dans les rangs de la direction. Ceci serait très déconseillé : l’appel à managers[0].setBonus(1000) tenterait d’accéder à une instance inexistante et corromprait la mémoire voisine. Pour éviter toute corruption, tous les tableaux se souviennent du type d’élément créé, et ils surveillent que seules les références compatibles y soient stockées. Par exemple, le tableau créé sous la forme new Manager[10] se souvient qu’il s’agit uniquement d’un tableau de directeurs. Tenter de stocker une référence Employee entraîne une exception de type ArrayStoreException.

Liaison dynamique Il importe de bien comprendre ce qui se passe lorsqu’un appel de méthode est appliqué à un objet. Voici les détails : 1. Le compilateur examine le type déclaré de l’objet et le nom de la méthode. Supposons que nous appelions x.f(param), et que le paramètre implicite x soit déclaré comme étant un objet de la classe C. Notez qu’il peut y avoir plusieurs méthodes, toutes avec le même nom f, mais avec des types de paramètres différents. Il peut, par exemple, y avoir une méthode f(int) et une méthode f(String). Le compilateur énumère toutes les méthodes appelées f dans la classe C et toutes les méthodes public appelées f dans les superclasses de C. Maintenant, le compilateur connaît tous les candidats possibles pour la méthode à appeler.

Livre Java .book Page 185 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

185

2. Le compilateur détermine ensuite les types des paramètres qui sont fournis dans l’appel de la méthode. Si, parmi toutes les méthodes nommées f, il en existe une seule dont les types de paramètres correspondent exactement aux paramètres fournis, cette méthode est choisie pour l’appel. Ce processus est appelé résolution de surcharge. Par exemple, dans un appel x.f("Hello"), le compilateur choisira f(String) et non f(int). La situation peut devenir complexe du fait des conversions de type (int vers double, Manager vers Employee, etc.). Si le compilateur ne peut pas trouver de méthode avec les types de paramètres qui correspondent, ou s’il existe plusieurs méthodes pouvant convenir après application des conversions, le compilateur renvoie une erreur. Maintenant, le compilateur connaît le nom et le type des paramètres de la méthode devant être appelée. INFO Souvenez-vous que le nom et la liste des types de paramètres pour une méthode sont appelés signature de la méthode. Par exemple, f(int) et f(String) sont deux méthodes de même nom, mais présentant des signatures différentes. Si vous définissez une méthode dans une sous-classe avec la même signature qu’une méthode d’une superclasse, vous remplacez cette méthode. Le type renvoyé ne fait pas partie de la signature. Toutefois, lorsque vous remplacez une méthode, vous devez conserver un type de retour compatible. Avant le JDK 5.0, les types de retours devaient être identiques. Mais la sous-classe peut maintenant modifier le type de retour d’une méthode remplacée en sous-type du type d’origine. Supposons par exemple que la classe Employee ait un public Employee getBuddy() { ... }

la sous-classe Manager peut alors remplacer cette méthode par public Manager getBuddy() { ... } // OK avec JDK 5.0

On dit que les deux méthodes getBuddy ont des types de retours covariants.

3. Si la méthode est private, static, final ou un constructeur, le compilateur sait exactement quelle méthode appeler (le modificateur final est expliqué dans la section suivante). Cela s’appelle une liaison statique. Sinon, la méthode à appeler dépend du type réel du paramètre implicite, et la liaison dynamique doit être utilisée au moment de l’exécution. Dans notre exemple, le compilateur générerait une instruction pour appeler f(String) avec liaison dynamique. 4. Lorsque le programme s’exécute et qu’il utilise la liaison dynamique pour appeler une méthode, la machine virtuelle doit appeler la version de la méthode appropriée pour le type réel de l’objet auquel x fait référence. Supposons que le type réel soit D, une sous-classe de C. Si la classe D définit une méthode f(String), celle-ci est appelée. Sinon, la superclasse de D est examinée pour rechercher une méthode f(String), etc. Exécuter cette recherche chaque fois qu’une méthode est appelée serait une perte de temps. La machine virtuelle précalcule pour chaque classe une table de méthodes, qui liste toutes les signatures de méthodes et les méthodes réelles à appeler. Lorsqu’une méthode est réellement appelée, la machine virtuelle fait une simple recherche dans la table. Dans notre exemple, la machine virtuelle consulte la table de méthodes pour la classe D et recherche la méthode à appeler pour f(String). Il peut s’agir de D.f(String) ou de X.f(String), où X est une superclasse quelconque de D. Il existe une variante à ce scénario. Si l’appel est super.f(param), le compilateur consulte la table des méthodes de la superclasse du paramètre implicite.

Livre Java .book Page 186 Jeudi, 25. novembre 2004 3:04 15

186

Au cœur de Java 2 - Notions fondamentales

Nous allons examiner ce processus en détail dans l’appel e.getSalary() de l’Exemple 5.1. Le type déclaré de e est Employee. La classe Employee possède une seule méthode appelée getSalary, et elle n’a pas de paramètre. Dans ce cas, nous n’allons pas nous préoccuper de résolution de surcharge. Puisque la méthode getSalary n’est pas private, static ni final, elle est liée dynamiquement. La machine virtuelle produit des tables de méthodes pour les classes Employee et Manager. La table Employee montre que toutes les méthodes sont définies dans la classe Employee elle-même : Employee: getName() -> Employee.getName() getSalary() -> Employee.getSalary() getHireDay() -> Employee.getHireDay() raiseSalary(double) -> Employee.raiseSalary(double)

En réalité, ce n’est pas tout ; comme vous verrez plus loin dans ce chapitre, la classe Employee a une superclasse Object de laquelle elle hérite un certain nombre de méthodes. Les méthodes de Object sont ignorées pour l’instant. La table de méthodes Manager est légèrement différente. Trois méthodes font partie de l’héritage, une est redéfinie et une est ajoutée : Manager: getName() -> Employee.getName() getSalary() -> Manager.getSalary() getHireDay() -> Employee.getHireDay() raiseSalary(double) -> Employee.raiseSalary(double) setBonus(double) -> Manager.setBonus(double)

A l’exécution, l’appel e.getSalary() est résolu de la façon suivante : 1. Tout d’abord, la machine virtuelle consulte la table de méthodes pour le type réel de e. Il peut s’agir de la table des méthodes pour Employee, Manager ou une autre sous-classe de Employee. 2. Puis, la machine virtuelle recherche dans la classe déterminée la signature de getSalary(). Elle sait maintenant quelle méthode appeler. 3. Enfin, la machine virtuelle appelle la méthode. La liaison dynamique possède une propriété très importante : elle rend les programmes extensibles sans qu’il soit nécessaire de modifier le code existant. Supposons qu’une nouvelle classe Executive soit ajoutée, et qu’il soit possible que la variable e fasse référence à un objet de cette classe. Le code contenant l’appel e.getSalary() n’a pas besoin d’être recompilé. La méthode Executive.getSalary() est appelée automatiquement si e fait référence à un objet du type Executive. ATTENTION Lorsque vous remplacez une méthode, la méthode de la sous-classe doit être au moins aussi visible que celle de la superclasse. En particulier, si la méthode de la superclasse est public, la méthode de la sous-classe doit aussi être déclarée comme public. Il est courant d’omettre accidentellement le spécificateur public pour la méthode de la sous-classe. Le compilateur proteste alors et signale que vous essayez de fournir un privilège d’accès plus faible.

Livre Java .book Page 187 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

187

Empêcher l’héritage : les classes et les méthodes final Dans certaines circonstances, vous souhaiterez interdire à d’autres programmeurs de former une sous-classe à partir d’une des classes que vous avez créées. On emploie le modificateur final pour spécifier qu’une classe ne peut pas être étendue (une telle classe est aussi appelée classe final). Supposons que nous voulions empêcher la création de sous-classes à partir de la classe Executive. Il suffit pour cela d’utiliser le modificateur final dans sa déclaration, de la façon suivante : final class Executive extends Manager { . . . }

Une méthode peut également être déclarée final. Dans ce cas, aucune sous-classe ne pourra remplacer cette méthode (toutes les méthodes d’une classe final sont automatiquement des méthodes final). Par exemple : class Employee { . . . public final String getName() { return name; } . . . }

INFO Souvenez-vous que les champs peuvent également être qualifiés de final. Un champ final ne peut pas être modifié une fois que l’objet a été construit. Toutefois, si une classe est déclarée comme final, seules les méthodes, et non les champs, sont automatiquement final.

Il n’existe qu’une bonne raison de rendre une méthode ou une classe final : vérifier que la sémantique ne peut pas être transformée en sous-classe. Par exemple, les méthodes getTime et setTime de la classe Calendar sont final. Ceci montre que les concepteurs de la classe Calendar ont pris la responsabilité de la conversion entre la classe Date et l’état du calendrier. Aucune sous-classe ne doit être autorisée à bouleverser cet arrangement. De même, la classe String est une classe final. Cela signifie que personne ne peut définir de sous-classe de String. En d’autres termes, si vous voyez une référence String, vous savez qu’elle fait référence à une chaîne et à rien d’autre. Certains programmeurs considèrent que vous devez déclarer toutes les méthodes sous la forme final, à moins d’avoir une bonne raison pour vouloir utiliser le polymorphisme. En fait, en C++ et C#, les méthodes n’utilisent le polymorphisme que si vous le demandez précisément. Ceci peut vous sembler un peu extrême, mais il vaut certainement mieux penser soigneusement aux méthodes et aux classes final lorsque vous concevez une hiérarchie de classe. Aux premiers temps de Java, certains programmeurs utilisaient le mot clé final dans l’espoir d’éviter les liaisons dynamiques. Lorsqu’une méthode n’est pas remplacée et qu’elle est courte, un compilateur peut optimiser l’appel de méthode, une procédure appelée inlining. Par exemple, appliquer l’inlining à l’appel e.getName() le remplace par l’accès de champ e.name. Cette amélioration est valable : les unités centrales détestent la dérivation, qui interfère avec leur stratégie de prélecture

Livre Java .book Page 188 Jeudi, 25. novembre 2004 3:04 15

188

Au cœur de Java 2 - Notions fondamentales

des instructions lors du traitement de l’instruction actuelle. Toutefois, si getName peut être remplacé dans une autre classe, le compilateur ne peut pas procéder à l’inlining car il ne sait pas ce que peut faire le code de remplacement. Heureusement, le compilateur JIT de la machine virtuelle peut se révéler bien meilleur qu’un compilateur traditionnel. Il connaît exactement les classes qui étendent une classe donnée et peut vérifier si une classe remplace réellement une méthode donnée. Si une méthode est courte, fréquemment appelée et qu’elle n’est pas réellement remplacée, le compilateur JIT peut procéder à l’inlining de la méthode. Que se passe-t-il si la machine virtuelle charge une autre sous-classe qui surcharge une méthode en ligne ? L’optimiseur doit annuler l’inlining. L’opération est lente mais n’arrive que rarement. INFO C++ En C++, une méthode n’est pas liée dynamiquement par défaut ; de plus, il est possible de spécifier la directive inline pour que les appels à la méthode soient remplacés par le code source de la méthode. Cependant, aucun mécanisme n’empêche une sous-classe de remplacer une méthode de superclasse. On peut écrire des classes C++ incapables d’avoir de descendance, mais cela exige une ruse complexe qui se justifie très rarement (cette astuce mystérieuse est laissée au lecteur en guise d’exercice. Indice : utilisez une classe de base virtuelle).

Transtypage Nous avons appris, au Chapitre 3, que la conversion forcée d’un type en un autre s’appelle le transtypage, et que Java utilise une syntaxe spécifique pour désigner ce mécanisme. Par exemple, double x = 3.405; int nx = (int)x;

convertit la valeur de l’expression x en un entier (int), en supprimant la partie décimale. Il est parfois nécessaire de convertir un nombre réel en nombre entier. Il peut aussi être nécessaire de convertir un objet d’une classe en objet d’une autre classe. Pour effectuer un transtypage d’une référence d’objet, on emploie une syntaxe comparable à celle du transtypage d’une expression numérique. Le nom de classe cible est mis entre parenthèses et placé devant la référence d’objet que l’on souhaite convertir. Voici un exemple : Manager boss = (Manager)staff[0];

Il n’y a qu’une seule raison d’effectuer un transtypage d’objet — utiliser ce dernier à pleine capacité lorsque son type réel a été temporairement occulté. Par exemple, dans la classe ManagerTest, le tableau staff devait être un tableau d’objets Employee, car certains des éléments du tableau étaient des employés réguliers (de type Employee). Les objets directeurs de ce tableau doivent être transtypés en Manager (leur type réel) si l’on souhaite accéder à leurs variables spécifiques. Remarquez que dans l’exemple de la première section, nous nous sommes efforcés d’éviter le transtypage. Nous avons initialisé la variable boss avec un objet Manager avant de la stocker dans le tableau. Il nous fallait utiliser le type correct pour définir le bonus du directeur. En Java, comme vous le savez, chaque variable objet appartient à un type donné, qui décrit le genre d’objet auquel se réfère la variable et en détermine les capacités. Par exemple, staff[i] fait référence à un objet Employee (et peut donc référencer un objet Manager).

Livre Java .book Page 189 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

189

Le compilateur s’assure que l’on ne promet pas plus que l’on ne peut tenir lorsque vous stockez une valeur dans une variable. Si vous affectez une référence d’une sous-classe à une variable de la superclasse, vous promettez moins, et le compilateur vous laisse faire. En revanche, si vous affectez une référence de la superclasse à une variable d’une sous-classe, vous promettez plus. Vous devez donc utiliser un transtypage pour que votre intention puisse être vérifiée au moment de l’exécution. Que se passe-t-il si vous tentez de transtyper un objet dans un type dérivé et que vous mentiez par conséquent sur le contenu de cet objet ? Manager boss = (Manager)staff[1]; // ERREUR

Lorsque le programme s’exécute, Java remarque que le type est inapproprié et génère une exception de type ClassCastException. Si vous n’interceptez pas cette exception, le programme se termine. Il est par conséquent souhaitable de déterminer si un transtypage réussira avant de l’entreprendre. A cette fin, employez l’opérateur instanceof, de la façon suivante : if (staff[1] instanceof Manager) { boss = (Manager) staff[1]; . . . }

Précisons que le compilateur ne vous laissera pas effectuer un transtypage si celui-ci est inévitablement voué à l’échec. A titre d’exemple, le transtypage Date c = (Date)staff[1];

provoque une erreur de compilation, car Date n’est pas une sous-classe de Employee. En résumé : m

Un transtypage d’objet ne peut s’appliquer qu’à des objets de la même hiérarchie de classes.

m

Utilisez instanceof avant de procéder à un transtypage d’une superclasse vers une sous-classe. INFO

Le test : x instanceof C ne génère pas d’exception si x vaut null. Il renvoie simplement la valeur false. Cela est logique, car null ne fait pas référence à un objet, en tout cas pas à un objet du type C.

En règle générale, il est préférable de ne pas convertir le type d’un objet par transtypage. Dans nos exemples, il est rarement nécessaire de transtyper un objet Employee en objet Manager. La méthode getSalary fonctionnera correctement avec les deux objets des deux classes. La répartition dynamique permet de sélectionner automatiquement la méthode correcte (par polymorphisme). L’unique raison d’avoir recours au transtypage est l’emploi d’une méthode spécifique aux directeurs, comme setBonus. Si, pour quelque raison que ce soit, il apparaît important d’appeler setBonus pour un objet de type Employee, demandez-vous si cela révèle une faille dans la conception de la superclasse. Il peut être indiqué de revoir la conception de la superclasse et d’ajouter une méthode setBonus. N’oubliez pas ceci : il suffit d’une exception ClassCastException non détournée pour interrompre l’exécution du programme. En général, il est préférable de limiter autant que possible l’utilisation de transtypages et de l’opérateur instanceof.

Livre Java .book Page 190 Jeudi, 25. novembre 2004 3:04 15

190

Au cœur de Java 2 - Notions fondamentales

INFO C++ Java emploie une syntaxe de transtypage issue du C, mais elle s’utilise comme l’opération dynamic_cast de C++. Par exemple : Manager boss = (Manager)staff[1]; // Java

correspond à : Manager* boss = dynamic_cast(staff[1]); // C++

avec néanmoins une différence importante : si le transtypage échoue, il ne produit pas un objet null, mais déclenche une exception. Dans ce sens, il ressemble à un transtypage de références en C++. C’est dommage, car en C++ vous pouvez effectuer la vérification de type et le transtypage en une seule opération. Manager* boss = dynamic_cast(staff[1]); // C++ if (boss != NULL) . . .

En Java, il faut employer une combinaison de l’opérateur instanceof et du transtypage : if (staff[1] instanceof Manager) { Manager boss = (Manager)staff[1]; . . . }

Classes abstraites A mesure que l’on remonte dans la hiérarchie des classes, celles-ci deviennent plus générales et souvent plus abstraites. A un certain moment, la classe ancêtre devient tellement générale qu’on la considère surtout comme un moule pour des classes dérivées et non plus comme une véritable classe dotée d’instances. Prenons l’exemple d’une extension de la hiérarchie de notre classe Employee. Un employé est une personne, tout comme l’est un étudiant. Etendons notre hiérarchie de classe pour inclure les classes Person et Student. La Figure 5.2 montre les relations d’héritage entre ces classes. Figure 5.2 Schéma de l’héritage pour Person et ses sous-classes.

Person

Employee

Student

Pourquoi construire une classe dotée d’un tel niveau d’abstraction ? Certains attributs, comme le nom, concernent tout le monde. Les étudiants et les employés ont un nom, et le fait d’introduire une superclasse commune permet de "factoriser" la méthode getName à un plus haut niveau dans la hiérarchie d’héritage.

Livre Java .book Page 191 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

191

Ajoutons à présent une autre méthode, getDescription, dont le but est de renvoyer une brève description de la personne, par exemple : an employee with a salary of $50,000.00 a student majoring in computer science

Il est facile d’implémenter cette méthode pour les classes Employee et Student. Mais quelle information pouvez-vous fournir dans la classe Person ? Cette classe ne sait rien de la personne, excepté son nom. Bien entendu, vous pouvez implémenter Person.getDescription() pour renvoyer une chaîne vide. Mais il existe un meilleur moyen. Si vous employez le mot clé abstract, vous n’avez pas besoin d’implémenter la méthode du tout : public abstract String getDescription(); // aucune implémentation requise

Pour plus de clarté, une classe possédant une ou plusieurs méthodes abstraites doit elle-même être déclarée abstraite : abstract class Person { . . . public abstract String getDescription(); }

En plus des méthodes abstraites, les classes abstraites peuvent posséder des données et des méthodes concrètes. Par exemple, la classe Person peut stocker le nom de la personne et disposer d’une méthode qui renvoie ce nom : Person { public Person(String n) { name = n; } public abstract String getDescription(); public String getName() { return name; } private String name; }

ASTUCE De nombreux programmeurs pensent que les classes abstraites ne doivent avoir que des méthodes abstraites. Cette vision est erronée. Il est toujours préférable de placer autant de fonctionnalités que possible dans une superclasse, qu’elle soit ou non abstraite. En particulier, placez les méthodes et les champs communs (abstraits ou non) dans la superclasse abstraite.

Les méthodes abstraites représentent en quelque sorte des emplacements pour les méthodes qui seront implémentées dans les sous-classes. Lorsque vous étendez une classe abstraite, vous avez deux possibilités. Vous pouvez laisser certaines ou toutes les méthodes abstraites indéfinies.

Livre Java .book Page 192 Jeudi, 25. novembre 2004 3:04 15

192

Au cœur de Java 2 - Notions fondamentales

La sous-classe doit ensuite être qualifiée d’abstraite également. Vous pouvez aussi définir toutes les méthodes, la sous-classe n’est alors plus abstraite. Nous allons par exemple, définir une classe Student qui étend la classe abstraite Person et implémente la méthode getDescription. Puisque aucune des méthodes de la classe Student n’est abstraite, il n’est pas nécessaire de la déclarer comme classe abstraite. Une classe peut être déclarée abstract même si elle ne possède pas de méthodes abstraites. Les classes abstraites ne peuvent pas être instanciées. Autrement dit, si une classe est déclarée abstract, il est impossible de créer un objet de cette classe. Par exemple, l’expression new Person("Vince Vu")

est une erreur. Vous pouvez néanmoins créer des objets de sous-classes concrètes. Notez cependant que vous pouvez toujours créer une variable objet d’une classe abstraite, mais cette variable doit référencer un objet d’une sous-classe non abstraite. Par exemple : Person p = new Student("Vince Vu", "Economics");

La variable p est ici une variable du type abstrait Person qui fait référence à une instance de la sousclasse non abstraite Student. INFO C++ En C++, une méthode abstraite est appelée "fonction virtuelle pure" (pure virtual function) et sa déclaration est terminée par = 0, de la façon suivante : class Person // C++ { public: virtual string getDescription() = 0; . . . };

Une classe C++ est abstraite si elle possède au moins une fonction virtuelle pure. Il n’existe pas de mot clé particulier en C++ pour désigner une classe abstraite.

Nous allons définir une sous-classe concrète Student qui étend la classe abstraite Person : class Student extends Person { public Student(String n, String m) { super(n); major = m; } public String getDescription() { return "a student majoring in " + major; } private String major; }

Livre Java .book Page 193 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

193

La classe Student définit la méthode getDescription. Toutes les méthodes de la classe Student sont donc concrètes, et la classe n’est plus désormais abstraite. Le programme de l’Exemple 5.2 définit la superclasse abstraite Person et deux sous-classes concrètes Employee et Student. Un tableau de références Person est rempli avec les objets employé et étudiant : Person[] people = new Person[2]; people[0] = new Employee(. . .); people[1] = new Student(. . .);

Nous affichons ensuite les noms et les descriptions de ces objets : for (Person p = people) System.out.println(p.getName() + ", " + p.getDescription());

Certains sont déconcertés par l’appel : p.getDescription()

N’est-ce pas là un appel de méthode indéfinie ? N’oubliez pas que la variable p ne fait jamais référence à un objet Person puisqu’il est impossible de construire un objet de la classe abstraite Person. La variable p fait toujours référence à un objet d’une sous-classe concrète comme Employee ou Student. Pour ces objets, la méthode getDescription est définie. Auriez-vous pu omettre totalement la méthode abstraite pour la superclasse Person et simplement définir les méthodes getDescription dans les sous-classes Employee et Student ? Si vous l’aviez fait, vous n’auriez alors pas pu invoquer la méthode getDescription sur la variable p. Le compilateur s’assure que vous n’invoquez que les méthodes qui sont déclarées dans la classe. Les méthodes abstraites sont un concept important dans le langage de programmation Java. Vous les rencontrerez le plus souvent au sein des interfaces. Pour plus d’informations concernant les interfaces, reportez-vous au Chapitre 6. Exemple 5.2 : PersonTest.java import java.text.*; import java.util.*; public class PersonTest { public static void main(String[] args) { Person[] people = new Person[2]; // remplir le tableau people avec des objets Student et Employee people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1); people[1] = new Student("Maria Morris", "computer science"); // afficher les noms et descriptions de tous les objets Person for (Person p : people) System.out.println(p.getName() + ", "  + p.getDescription()); } }

Livre Java .book Page 194 Jeudi, 25. novembre 2004 3:04 15

194

Au cœur de Java 2 - Notions fondamentales

abstract class Person { public Person(String n) { name = n; } public abstract String getDescription(); public String getName() { return name; } private String name; } class Employee extends Person { public Employee(String n, double s, int year, int month, int day) { super(n); salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); hireDay = calendar.getTime(); } public double getSalary() { return salary; } public Date getHireDay() { return hireDay; } public String getDescription() { return String.format("an employee with a salary of $%.2f, salary); } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } private double salary; private Date hireDay; } class Student extends Person {

Livre Java .book Page 195 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

195

/** @param n Nom de l’étudiant @param m La spécialité de l’étudiant */ public Student(String n, String m) { // passer n au constructeur de la superclasse super(n); major = m; } public String getDescription() { return "a student majoring in " + major; } private String major; }

Accès protégé Comme vous le savez, les champs d’une classe sont généralement déclarés private et les méthodes public. Tout élément private est invisible pour les autres classes. Nous avons expliqué au début de ce chapitre que cette cécité sélective s’applique également aux sous-classes : une sous-classe n’a pas accès aux champs privés de sa superclasse. Il existe néanmoins des circonstances dans lesquelles vous voudrez limiter une méthode aux sousclasses seulement ou, plus généralement, permettre aux méthodes d’une sous-classe d’avoir accès à un champ de superclasse. Dans ce cas, il faut déclarer cet élément protected (protégé). Par exemple, si la superclasse Employee déclare le champ hireDay comme protected plutôt que private, les méthodes de la classe Manager pourront y accéder directement. Cependant, les méthodes de la classe Manager ne pourront qu’accéder au champ hireDay des objets Manager, et non des autres objets Employee. Cette restriction évite la violation du mécanisme de protection et le risque que des sous-classes soient simplement créées pour obtenir l’accès aux champs protégés. Dans la pratique, le modificateur protected doit être utilisé avec une grande prudence. Supposons que votre classe soit utilisée par d’autres programmeurs et que vous l’ayez dotée de champs protégés. A votre insu, d’autres programmeurs peuvent faire hériter de votre classe des sous-classes qui accéderont à vos champs protégés. Ils risquent donc d’être contrariés si vous modifiez ensuite l’implémentation de votre classe. Tout cela va à l’encontre de l’esprit de la programmation orientée objet, qui recommande l’encapsulation des données. En revanche, les méthodes protégées sont plus courantes. Une classe peut déclarer une méthode protected si celle-ci est d’un usage délicat. Cela autorise les sous-classes (qui, a priori, connaissent bien leur ancêtre) à utiliser cette méthode délicate, mais les autres classes sans lien de parenté n’en ont pas le droit. Un bon exemple de ce genre de méthode est la méthode clone de la classe Object — voir le Chapitre 6 pour plus de détails.

Livre Java .book Page 196 Jeudi, 25. novembre 2004 3:04 15

196

Au cœur de Java 2 - Notions fondamentales

INFO C++ En fait, les éléments protected de Java sont visibles par toutes les sous-classes, mais aussi par toutes les autres classes qui se trouvent dans le même package. La signification de protected est légèrement différente en C++, et la notion de protection en Java est encore moins sûre qu’en C++.

Résumons les caractéristiques des quatre modificateurs de visibilité de Java : 1. Private (privé). Visible uniquement par la classe. 2. Public. Visible par toutes les classes. 3. Protected (protégé). Visible par le package et toutes les sous-classes. 4. Par défaut (hélas !) — aucun modificateur n’est spécifié. Visible par tout le package.

Object : la superclasse cosmique La classe Object représente l’ancêtre ultime — toutes les classes Java héritent de Object. Néanmoins, vous n’avez jamais à écrire : class Employee extends Object

La superclasse Object est prise en compte par défaut si aucune superclasse n’est explicitement spécifiée. Comme chaque classe Java dérive de Object, il importe de se familiariser avec les fonctionnalités de cette classe ancêtre. Nous en examinerons ici les caractéristiques de base ; les autres aspects sont traités aux chapitres suivants et dans la documentation en ligne (plusieurs méthodes de Object sont dédiées aux threads — voir le Chapitre 1 du Volume 2 pour plus d’informations sur les threads). Une variable de type Object peut référencer un objet de n’importe quel type : Object obj = new Employee("Harry Hacker", 35000);

Bien entendu, une variable de type Object n’est utile qu’en tant que conteneur générique pour des valeurs arbitraires. Pour pouvoir réellement en utiliser la valeur courante, il faut connaître le type original (effectif) et appliquer un transtypage : Employee e = (Employee)obj;

En Java, seuls les types primitifs (nombres, caractères et valeurs booléennes) ne sont pas des objets. Tous les types de tableaux, qu’ils soient d’objets ou de types primitifs, sont des types de classes qui étendent la classe Object : Employee[] staff = new Employee[10]; obj = staff; // OK obj = new int[10]; // OK

INFO C++ Il n’existe pas de classe racine cosmique en C++. Toutefois, en C++, tout pointeur peut être converti en pointeur void*.

Livre Java .book Page 197 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

197

La méthode equals La méthode equals de la classe Object détermine si deux objets sont égaux ou non. Telle qu’elle est implémentée dans la classe Object, cette méthode vérifie que les deux références d’objet sont identiques. C’est un défaut assez raisonnable : si deux objets sont identiques, ils doivent certainement être égaux. Cela suffit pour certaines classes. Il est peu logique, par exemple, de comparer deux objets PrintStream à des fins d’égalité. Vous voudrez pourtant souvent implémenter le test d’égalité dans lequel deux objets sont considérés égaux lorsqu’ils ont le même état. Envisageons par exemple deux employés égaux s’ils ont le même nom, le même salaire et la même date d’embauche (dans une vraie base de données d’employés, il serait plus logique de comparer les identifiants. Nous prenons cet exemple pour montrer le mécanisme de la mise en place de la méthode equals) : class Employee { // . . . public boolean equals(Object otherObject) { // tester rapidement si les objets sont identiques if (this == otherObject) return true; // doit renvoyer false si le paramètre explicite vaut null if (otherObject == null) return false; /* si les classes ne correspondent pas, elles ne peuvent pas être égales */ if (getClass() != otherObject.getClass()) return false; /* nous savons maintenant que otherObject est un objet Employee non null */ Employee other = (Employee)otherObject; // tester si les champs ont des valeurs identiques return name.equals(other.name) && salary == other.salary && hireDay.equals(other.hireDay); } }

La méthode getClass renvoie la classe d’un objet — nous verrons cette méthode en détail plus loin dans ce chapitre. Dans notre test, deux objets ne peuvent être égaux que s’ils sont de la même classe. Lorsque vous définissez la méthode equals pour une sous-classe, appelez d’abord equals sur la superclasse. Si ce test ne réussit pas, les objets ne peuvent pas être égaux. Si les champs de superclasse sont égaux, vous êtes prêt à comparer les champs d’instance de la sous-classe : class Manager extends Employee{ . . . public boolean equals(Object otherObject) { if (!super.equals(otherObject)) return false; // super.equals vérifie que this et otherObject appartiennent à // la même classe Manager other = (Manager) otherObject; return bonus == other.bonus; } }

Livre Java .book Page 198 Jeudi, 25. novembre 2004 3:04 15

198

Au cœur de Java 2 - Notions fondamentales

Test d’égalité et héritage Comment devrait se comporter la méthode equals si les paramètres implicites et explicites n’appartiennent pas à la même classe ? Ce domaine a fait l’objet d’une certaine controverse. Dans l’exemple précédent, la méthode equals renvoie false si les classes ne correspondent pas exactement. Mais de nombreux programmeurs utilisent plutôt un test instanceof : if (!(otherObject instanceof Employee)) return false;

Cela autorise l’éventualité que otherObject puisse appartenir à une sous-classe. Toutefois, cette approche peut vous poser problème. Voici pourquoi. La spécification du langage Java requiert que la méthode equals ait les propriétés suivantes : 1. Qu’elle soit réflective : pour toute référence x non nulle, x.equals(x) doit renvoyer true. 2. Qu’elle soit symétrique : pour toutes références x et y, x.equals(y) doit renvoyer true, si et seulement si y.equals(x) renvoie true. 3. Qu’elle soit transitive : pour toutes références x, y et z, si x.equals(y) renvoie true et y.equals(z) renvoie true, alors x.equals(z) doit renvoyer true. 4. Qu’elle soit cohérente : si les objets auxquels x et y font référence n’ont pas changé, des appels successifs à x.equals(y) renvoient la même valeur. 5. Pour toute référence x non nulle, x.equals(null) doit renvoyer false. Ces règles sont certainement raisonnables. Vous ne voudriez pas qu’un implémenteur de bibliothèque pondère s’il faut appeler x.equals(y) ou y.equals(x) lorsque vous localisez un élément dans une structure de données. Toutefois, la règle de symétrie implique des conséquences subtiles lorsque les paramètres appartiennent à différentes classes. Envisageons un appel e.equals(m)

où e est un objet Employee et m, un objet Manager, tous les deux se trouvant avoir le même nom, salary et hireDate. Si Employee.equals utilise un test instanceof, cet appel renvoie true. Mais cela signifie que l’appel inverse m.equals(e)

doit aussi renvoyer true — la règle de symétrie ne permet pas de renvoyer false ni de lancer une exception. La classe Manager est ennuyée. Sa méthode equals doit être prête à se comparer à tout Employee, sans prendre en compte les informations spécifiques aux directeurs ! Tout à coup, le test instanceof apparaît moins attirant ! Certains auteurs ont prétendu que le test getClass était inadapté car il viole le principe de substitution. On cite souvent à cet égard la méthode equals de la classe AbstractSet, qui teste si deux ensembles possèdent les mêmes éléments, dans le même ordre. La classe AbstractSet possède deux sous-classes concrètes, TreeSet et HashSet, qui utilisent différents algorithmes pour localiser des éléments de l’ensemble. Il est important de pouvoir comparer deux ensembles, quelle que soit leur implémentation.

Livre Java .book Page 199 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

199

Toutefois, l’exemple des ensembles est plutôt spécialisé. Il serait logique de déclarer AbstractSet.equals sous la forme final, car personne ne doit redéfinir la sémantique de l’égalité du jeu (la méthode n’est pas réellement final. Ceci permet à une sous-classe d’implémenter un algorithme plus efficace pour le test d’égalité). Comme nous le voyons, il existe deux scénarios distincts : m

Si les sous-classes peuvent avoir leur propre notion de l’égalité, l’exigence de symétrie vous oblige à utiliser le test getClass.

m

Si la notion d’égalité est fixée dans la superclasse, vous pouvez utiliser le test instanceof et permettre aux objets de différentes sous-classes d’être égaux entre eux.

Dans l’exemple des employés et des directeurs, nous considérons que deux objets sont égaux lorsqu’ils ont des champs concordants. Si nous avons deux objets Manager avec le même nom, salaire et date d’embauche, mais avec des bonus différents, ils doivent donc être différents. Nous avons par conséquent utilisé le test getClass. Mais supposons que nous ayons utilisé un ID d’employé pour le test d’égalité. Cette notion de l’égalité est logique pour toutes les sous-classes. Nous pourrions alors utiliser le test instanceof, et nous déclarerions Employee.equals sous la forme final. Notre recette pour l’écriture d’une méthode equals parfaite : 1. Nommez le paramètre explicite otherObject — vous devrez ultérieurement le transtyper en une autre variable que vous appellerez other. 2. Vérifiez si this se trouve être identique à otherObject : if (this == otherObject) return true;

Cette instruction est une simple optimisation. Dans la pratique, c’est très courant. Il est plus économique de vérifier l’identité que de comparer les champs. 3. Testez si otherObject vaut null et renvoyez false dans ce cas. Ce test est obligatoire. if (otherObject == null) return false;

Comparez les classes de this et otherObject. Si la sémantique de equals risque de changer dans les sous-classes, utilisez le test getClass : if (getClass() != otherObject.getClass()) return false;

Si la même sémantique vaut pour toutes les sous-classes, vous pouvez utiliser un test instanceof : if (!(otherObject instanceof NomClasse)) return false;

4. Convertissez otherObject en une variable du type de votre classe : nomDeClasse other = (nomDeClasse)otherObject

5. Comparez maintenant les champs, comme l’exige votre notion d’égalité. Utilisez == pour les champs de type primitif, equals pour les champs d’objet. Renvoyez true si tous les champs correspondent, false sinon : return champ1 == other.champ1 && champ2.equals(other.champ2) && . . .;

Livre Java .book Page 200 Jeudi, 25. novembre 2004 3:04 15

200

Au cœur de Java 2 - Notions fondamentales

Si vous redéfinissez equals dans une sous-classe, incluez un appel à super.equals(other). INFO La bibliothèque standard de Java contient plus de 150 implémentations des méthodes equals, avec une disparité d’utilisations de instanceof, d’appels de getClass, de récupérations des exceptions ClassCastException ou ne faisant rien du tout. Dès lors, il ne semble pas que tous les programmeurs comprennent bien les subtilités de la méthode equals. Rectangle, par exemple, est une sous-classe de Rectangle2D. Ces deux classes définissent une méthode equals avec un test instanceof. Si l’on compare un Rectangle2D avec un Rectangle ayant les mêmes coordonnées, cela renvoie true ; échanger les paramètres renvoie false.

ATTENTION Il arrive souvent de se méprendre sur le moment où implémenter la méthode equals. Retrouverez-vous le problème ? public class Employee { public boolean equals(Employee other) { return name.equals(other.name) && salary == other.salary && hireDay.equals(other.hireDay); } ... }

Cette méthode déclare le type de paramètre explicite sous la forme Employee. En conséquence, il ne remplace pas la méthode equals de la classe Object mais définit une méthode n’ayant aucun rapport. Depuis le JDK 5.0, vous pouvez vous protéger de ce type d’erreur en balisant les méthodes qui remplacent les méthodes de la superclasse avec @Override : @Override public boolean equals(Object other)

Si vous avez fait une erreur et que vous définissiez une nouvelle méthode, le compilateur signale l’erreur. Supposons par exemple que vous ajoutiez la déclaration suivante à la classe Employee. @Override public boolean equals(Employee other)

L’erreur signalée car cette méthode ne remplace aucune méthode de la superclasse Object. La balise @Override est une balise de métadonnées. Le mécanisme des métadonnées est très général et extensible, il permet aux compilateurs et aux outils de réaliser des actions arbitraires. L’avenir nous dira si les concepteurs d’outils en profiteront. Dans le JDK 5.0, les implémenteurs du compilateur ont décidé de se frayer un chemin à l’aide de la balise @Override.

La méthode hashCode Un code de hachage est un entier dérivé d’un objet. Les codes de hachage doivent être brouillés : si x et y sont deux objets distincts, la probabilité devrait être forte que x.hashCode() et y.hashCode()

Livre Java .book Page 201 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

201

soient différents. Le Tableau 5.1 reprend quelques exemples de codes de hachage tirés de la méthode hashCode de la classe String. Tableau 5.1 : Codes de hachage tirés de la fonction hashCode

Chaîne

Code de hachage

Hello

140207504

Harry

140013338

Hacker

884756206

La classe String utilise l’algorithme suivant pour calculer le code de hachage : int hash = 0; for (int i = 0; i < length(); i++) hash = 31 * hash + charAt(i);

La méthode hashCode est définie dans la classe Object. Chaque objet possède donc un code de hachage par défaut, extrait de l’adresse mémoire de l’objet. Etudiez l’exemple suivant : String s = "Ok"; StringBuffer sb = new StringBuffer(s); System.out.println(s.hashCode() + " " + sb.hashCode()); String t = new String("Ok"); StringBuffer tb = new StringBuffer(t); System.out.println(t.hashCode() + " " + tb.hashCode());

Le Tableau 5.2 en présente le résultat. Tableau 5.2 : Codes de hachage des chaînes et tampons des chaînes

Objet

Code de hachage

s

3030

sb

20526976

t

3030

tb

20527144

Sachez que les chaînes s et t présentent le même code de hachage car, pour les chaînes, ces codes sont dérivés de leur contenu. Les tampons de chaînes sb et tb disposent de codes de hachage différents car aucune méthode hashCode n’a été définie pour la classe StringBuffer et la méthode hashCode par défaut de la classe Object dérive le code de hachage de l’adresse mémoire de l’objet. Si vous redéfinissez la méthode equals, vous devrez aussi redéfinir la méthode hashCode pour les objets que les utilisateurs pourraient insérer dans une table de hachage (nous avons traité des tables de hachage au Chapitre 2 du Volume 2).

Livre Java .book Page 202 Jeudi, 25. novembre 2004 3:04 15

202

Au cœur de Java 2 - Notions fondamentales

La méthode hashCode devrait renvoyer un entier (qui peut être négatif). Associez simplement les codes de hachage des champs d’instance, de sorte que les codes des différents objets soient plus largement répartis. Il existe, par exemple, une méthode hashCode pour la classe Employee : class Employee { public int hashCode() { return 7 * name.hashCode() + 11 * new Double(salary).hashCode() + 13 * hireDay.hashCode(); } . . . }

Vos définitions de equals et hashCode doivent être compatibles : si x.equals(y) est vrai, alors x.hashCode() doit avoir la même valeur que y.hashCode(). Si, par exemple, vous définissez Employee.equals, de manière à comparer les ID des employés, la méthode hashCode devra hacher les ID, et non les noms des employés ou les adresses mémoire. java.lang.Object 1.0

•

int hashCode()

Renvoie un code de hachage pour cet objet. Il peut s’agir d’un entier, positif ou négatif. Les objets égaux doivent renvoyer des codes de hachage identiques.

La méthode toString Une autre méthode importante de la classe Object est toString, qui renvoie une chaîne représentant la valeur de l’objet. Voici un exemple typique. La méthode toString de la classe Point renvoie une chaîne comme celle-ci : java.awt.Point[x=10,y=20]

La plupart (mais pas toutes) des méthodes toString ont ce format : le nom de la classe, suivi des valeurs de champs incluses entre crochets. Voici une implémentation de la méthode toString pour la classe Employee : public String toString() { return "Employee[name=" + name  + ",salary=" + salary  + ",hireDay=" + hireDay  + "]"; }

En réalité, vous pouvez faire mieux. Au lieu de coder en dur le nom de la classe dans la méthode toString, appelez getClass().getName() pour obtenir une chaîne avec le nom de la classe : public String toString() { return getClass().getName()  + "[name=" + name  + ",salary=" + salary

Livre Java .book Page 203 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

203

 + ",hireDay=" + hireDay  + "]"; }

La méthode toString s’applique alors également aux sous-classes. Bien entendu, le programmeur de la sous-classe doit définir sa propre méthode toString et ajouter les champs de la sous-classe. Si la superclasse utilise getClass().getName(), la sous-classe peut simplement appeler super.toString(). Voici, par exemple, une méthode toString pour la classe Manager : class Manager extends Employee { . . . public String toString() { return super.toString()  + "[bonus=" + bonus  + "]"; } }

Maintenant, un objet Manager s’affiche de la façon suivante : Manager[name=...,salary=...,hireDay=...][bonus=...]

La méthode toString est omniprésente pour une raison essentielle : chaque fois qu’un objet est concaténé avec une chaîne à l’aide de l’opérateur "+", le compilateur Java invoque automatiquement la méthode toString pour obtenir une représentation de l’objet sous forme de chaîne. Voici un exemple : Point p = new Point(10, 20); String message = "La position actuelle est " + p; // invoque automatiquement p.toString()

ASTUCE Au lieu d’écrire x.toString(), vous pouvez écrire "" + x. Cette instruction concatène la chaîne vide avec la représentation textuelle de x, qui correspond exactement à la représentation obtenue par x.toString(). A la différence de toString, cette instruction fonctionne, même si x est de type primitif.

Si x est un objet quelconque et que vous appeliez System.out.println(x);

la méthode println appelle simplement x.toString() et affiche la chaîne résultante. La classe Object définit la méthode toString pour afficher le nom de classe et le code de hachage de l’objet. Par exemple, l’appel System.out.println(System.out)

produit une sortie ressemblant à ceci : java.io.PrintStream@2f6684

La raison en est que l’implémenteur de la classe PrintStream n’a pas pris la peine de remplacer la méthode toString.

Livre Java .book Page 204 Jeudi, 25. novembre 2004 3:04 15

204

Au cœur de Java 2 - Notions fondamentales

La méthode toString est un outil précieux de consignation. De nombreuses classes de la bibliothèque de classes standard définissent la méthode toString comme fournisseur d’informations utiles sur l’état d’un objet. Ceci est particulièrement utile pour consigner des messages, par exemple : System.out.println("Current position = " + position);

Comme nous l’expliquons au Chapitre 11, une solution encore meilleure consisterait à indiquer : Logger.global.info("Current position = " + position);

ASTUCE Il est fortement recommandé d’ajouter une méthode toString à chacune des classes que vous écrivez. Vous et tous les programmeurs utilisant vos classes apprécierez le support de consignation.

Le programme de l’Exemple 5.3 implémente les méthodes equals, hashCode et toString pour les classes Employee et Manager. Exemple 5.3 : EqualsTest.java import java.util.*; public class EqualsTest { public static void main(String[] args) { Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); Employee alice2 = alice1; Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15); Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1); System.out.println("alice1 == alice2: "  + (alice1 == alice2)); System.out.println("alice1 == alice3: "  + (alice1 == alice3)); System.out.println("alice1.equals(alice3): "  + alice1.equals(alice3)); System.out.println("alice1.equals(bob): "  + alice1.equals(bob)); System.out.println("bob.toString(): " + bob); Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15); Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15); boss.setBonus(5000); System.out.println("boss.toString(): " + boss); System.out.println("carl.equals(boss): "  + carl.equals(boss));

Livre Java .book Page 205 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

System.out.println("alice1.hashCode(): " + alice1.hashCode()); System.out.println("alice3.hashCode(): " + alice3.hashCode()); System.out.println("bob.hashCode(): " + bob.hashCode()); System.out.println("carl.hashCode(): " + carl.hashCode()); } } class Employee { public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); hireDay = calendar.getTime(); } public String getName() { return name; } public double getSalary() { return salary; } public Date getHireDay() { return hireDay; } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } public boolean equals(Object otherObject) { // test pour vérifier si les objets sont identiques if (this == otherObject) return true; // doit renvoyer false si le paramètre explicite vaut null if (otherObject == null) return false; /* si les classes ne correspondent pas, elles ne peuvent pas être égales */ if (getClass() != otherObject.getClass()) return false; /* nous savons maintenant que otherObject est un objet Employee non null */ Employee other = (Employee)otherObject;

205

Livre Java .book Page 206 Jeudi, 25. novembre 2004 3:04 15

206

Au cœur de Java 2 - Notions fondamentales

// tester si les valeurs de champs sont identiques return name.equals(other.name) && salary == other.salary && hireDay.equals(other.hireDay); } public int hashCode() { return 7 * name.hashCode() + 11 * new Double(salary).hashCode() + 13 * hireDay.hashCode(); } public String toString() { return getClass().getName()  + "[name=" + name  + ",salary=" + salary  + ",hireDay=" + hireDay  + "]"; } private String name; private double salary; private Date hireDay; } class Manager extends Employee { public Manager(String n, double s, int year, int month, int day) { super(n, s, year, month, day); bonus = 0; } public double getSalary() { double baseSalary = super.getSalary(); return baseSalary + bonus; } public void setBonus(double b) { bonus = b; } public boolean equals(Object otherObject) { if (!super.equals(otherObject)) return false; Manager other = (Manager)otherObject; /* super.equals a vérifié que this et other appartenaient à la même classe */ return bonus == other.bonus; }

Livre Java .book Page 207 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

207

public int hashCode() { return super.hashCode() + 17 * new Double(bonus).hashCode(); } public String toString() { return super.toString()  + "[bonus=" + bonus  + "]"; } private double bonus; } java.lang.Object 1.0

•

Class getClass()

Renvoie un objet class contenant des informations sur l’objet. Comme vous le verrez dans ce chapitre, la représentation des classes à l’exécution est encapsulée dans la classe Class. •

boolean equals(Object otherObject)

Compare deux objets ; renvoie true si les objets pointent vers la même zone mémoire, et false dans le cas contraire. Vous devez remplacer cette méthode dans vos propres classes. •

String toString()

Renvoie une chaîne décrivant la valeur de l’objet. Vous devez remplacer cette méthode dans vos propres classes. •

Object clone()

Crée un clone de l’objet. Le système d’exécution de Java alloue de la mémoire pour la nouvelle instance et y recopie la mémoire allouée à l’objet courant. INFO Le clonage constitue une opération importante, mais il s’agit aussi d’un processus assez délicat qui peut réserver de mauvaises surprises aux imprudents. Nous y reviendrons lors de l’examen de la méthode clone, au Chapitre 6.

java.lang.Class 1.0

•

String getName()

Renvoie le nom de cette classe. •

Class getSuperclass()

Renvoie la superclasse de cette classe en tant qu’objet Class.

Listes de tableaux génériques Dans de nombreux langages de programmation — en particulier C —, la taille des tableaux doit être fixée au moment de la compilation. Les programmeurs détestent cette contrainte : elle les oblige à de pénibles acrobaties de conception. Combien d’employés y aura-t-il dans un service ? Probablement

Livre Java .book Page 208 Jeudi, 25. novembre 2004 3:04 15

208

Au cœur de Java 2 - Notions fondamentales

pas plus de 100. Et si un service important a 150 employés ? Allons-nous gâcher 90 entrées pour chaque service n’ayant que 10 employés ? La situation est bien plus simple en Java, car il est possible de spécifier la taille d’un tableau au moment de l’exécution : int actualSize = . . .; Employee[] staff = new Employee[actualSize];

Bien entendu, ce genre de code ne résout pas complètement le problème de la modification dynamique des tableaux. Une fois que la taille d’un tableau est spécifiée, il n’est pas facile de la changer. La manière la plus simple de gérer cette situation courante consiste à utiliser une autre classe Java, classée ArrayList. La classe ArrayList est semblable à un tableau, mais elle ajuste automatiquement sa capacité à mesure que vous ajoutez et supprimez des éléments, sans que vous n’ayez rien à faire. Depuis le JDK 5.0, ArrayList est une classe générique avec un paramètre de type. Pour spécifier le type des objets d’éléments inclus dans la liste de tableau, vous annexez un nom de classe entre les signes supérieur à et inférieur à, sous la forme ArrayList. Vous verrez au Chapitre 13 comment définir votre propre classe générique, mais il est inutile de connaître les caractéristiques techniques du type ArrayList pour l’utiliser. Nous déclarons et construisons ici une liste de tableau qui contient des objets Employee : ArrayList staff = new ArrayList();

INFO Les classes génériques n’existaient pas avant le JDK 5.0. Il n’y avait qu’une seule classe ArrayList, une collection "fourre-tout" dont les éléments étaient de type Object. Si vous devez utiliser une ancienne version de Java, abandonnez simplement tous les suffixes de type <...>. Vous pouvez continuer à utiliser ArrayList sans suffixe <...> dans JDK 5.0 et versions ultérieures. On le considère comme un type "brut", dont le paramètre de type est effacé.

INFO Dans les versions encore antérieures du langage Java, les programmeurs utilisaient la classe Vector pour les tableaux dynamiques. La classe ArrayList est toutefois plus efficace, et il n’existe plus de raison valable d’utiliser la classe Vector.

Employez la méthode add pour ajouter de nouveaux éléments à une liste de tableaux. Voici par exemple comment remplir une liste de tableaux avec des objets Employee : staff.add(new Employee("Harry Hacker", . . .)); staff.add(new Employee("Tony Tester", ...));

La classe ArrayList gère un tableau interne de références Object. Ce tableau finira par être saturé. C’est là que les listes de tableaux sont magiques : si vous appelez add et que le tableau interne soit plein, la liste de tableaux crée automatiquement un tableau plus grand et recopie tous les objets du plus petit tableau vers le plus grand. Si vous connaissez déjà le nombre d’éléments que contiendra le tableau, ou que vous puissiez l’évaluer assez précisément, appelez la méthode ensureCapacity avant de remplir la liste de tableaux : staff.ensureCapacity(100);

Livre Java .book Page 209 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

209

Cet appel alloue un tableau interne de 100 objets. Les 100 premiers appels à add n’impliquent aucun repositionnement coûteux. Vous pouvez aussi passer une capacité initiale au constructeur de ArrayList : ArrayList staff = new ArrayList(100);

ATTENTION L’allocation d’une liste de tableaux de la façon suivante : new ArrayList(100) // la capacité est de 100

n’est pas la même chose que l’allocation d’un nouveau tableau : new Employee[100] // la taille est de 100

Il faut établir une distinction entre la capacité d’une liste de tableaux et la taille d’un tableau. Si vous allouez un tableau de 100 éléments, le tableau disposera de 100 emplacements, prêts à l’emploi. Une liste de tableaux dont la capacité est de 100 éléments peut potentiellement contenir 100 éléments (et, en réalité, plus de 100, au prix d’allocations supplémentaires). Mais au départ, juste après sa construction, une liste de tableaux ne contient en fait aucun élément. La méthode size renvoie le nombre réel d’éléments dans la liste de tableaux. Par exemple, staff.size()

renvoie le nombre actuel d’éléments dans la liste de tableaux staff. Ce qui est l’équivalent de a.length

pour un tableau a. Une fois que vous êtes quasiment certain que la liste de tableaux a atteint sa taille définitive, vous pouvez appeler la méthode trimToSize. Elle ajuste la taille du bloc de mémoire pour que la quantité exacte nécessaire pour le nombre actuel d’éléments soit réservée. Le "ramasse-miettes" récupérera toute mémoire en excès. Une fois que vous avez ajusté la taille d’une liste de tableaux, l’ajout de nouveaux éléments va déplacer de nouveau le bloc, ce qui prend du temps. N’utilisez trimToSize que si vous êtes certain de ne plus ajouter d’éléments à la liste de tableaux. INFO C++ La classe ArrayList est identique au modèle de vecteur C++. ArrayList et vector sont tous deux des types génériques. Mais le modèle vector de C++ surcharge l’opérateur [] pour faciliter l’accès aux éléments. Comme Java n’autorise pas la surcharge des opérateurs, une opération équivalente exige un appel de méthode explicite. De plus, les vecteurs de C++ sont copiés par valeur. Si a et b sont deux vecteurs, l’affectation a = b; fait de a un nouveau vecteur, de la même longueur que b, et tous les éléments de b sont copiés vers a. En Java, la même affectation amènera a et b à référencer la même liste de tableaux.

java.util.ArrayList 1.2

•

ArrayList()

Construit une liste de tableaux vide.

Livre Java .book Page 210 Jeudi, 25. novembre 2004 3:04 15

210

•

Au cœur de Java 2 - Notions fondamentales

ArrayList(int initialCapacity)

Construit une liste de tableaux vide ayant la capacité spécifiée. Paramètres : •

initialCapacity La capacité de stockage initiale de la liste de tableaux.

boolean add(T obj)

Ajoute un élément à la fin de la liste de tableaux. Renvoie toujours true. Paramètres : •

obj

L’élément à ajouter.

int size()

Renvoie le nombre d’éléments actuellement contenus dans la liste de tableaux (cette valeur est différente de la capacité. Bien entendu, elle est toujours inférieure ou égale à la capacité de la liste de tableaux). •

void ensureCapacity(int capacity)

Vérifie que la liste de tableaux a la capacité nécessaire pour contenir le nombre d’éléments donné, sans nécessiter la réallocation de son tableau de stockage interne. Paramètres : •

capacity

La capacité de stockage souhaitée.

void trimToSize()

Réduit la capacité de stockage de la liste de tableaux à sa taille actuelle.

Accéder aux éléments d’une liste de tableaux Malheureusement, rien n’est gratuit ; les avantages que procure l’accroissement automatique de la taille d’une liste de tableaux exigent une syntaxe plus complexe pour accéder aux éléments, car la classe ArrayList ne fait pas partie du langage Java ; il s’agit d’une classe utilitaire tiers ajoutée à la bibliothèque standard. Au lieu d’employer la syntaxe [], bien pratique pour accéder à un élément d’un tableau ou le modifier, il faut appeler les méthodes get et set. Par exemple, pour définir le ième élément, écrivez staff.set(i, harry);

ce qui est équivalent à a[i] = harry;

pour un tableau a (comme pour les tableaux, les valeurs d’index sont basées sur zéro). Pour obtenir un élément de liste de tableau, utilisez Employee e = staff.get(i);

ce qui est équivalent à : Employee e = a[i];

Depuis le JDK 5.0, vous pouvez utiliser la boucle "for each" pour les listes de tableaux : for (Employee e : staff) // faire quelque chose avec e

Dans le code existant, la même boucle s’écrirait : for (int i = 0; i < staff.size(); i++) {

Livre Java .book Page 211 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

211

Employee e = (Employee) staff.get(i); faire quelque chose avec e }

INFO Avant le JDK 5.0, les classes génériques n’existaient pas et la méthode get de la classe brute ArrayList n’avait d’autre choix que de renvoyer un Object. Les éléments qui appelaient get devaient donc transtyper la valeur renvoyée sur le type souhaité : Employee e = (Employee) staff.get(i);

Le ArrayList brut est aussi un peu dangereux. Ses méthodes add et set acceptent des objets de n’importe quel type. Un appel staff.set(i, new Date());

se compile quasiment sans aucun avertissement et ne vous pose problème que lorsque vous récupérez l’objet et que vous essayez de le transtyper. Si vous utilisez plutôt un ArrayList, le compilateur détecte cette erreur.

ASTUCE Une petite astuce permet de profiter d’un double avantage — une croissance flexible et un accès pratique aux éléments. Créez d’abord une liste de tableaux et ajoutez-y tous ses éléments : ArrayList list = new ArrayList(); while (. . .) { x = . . .; list.add(x); }

Utilisez ensuite la méthode toArray pour copier les éléments dans un tableau : X[] a = new X[list.size()]; list.toArray(a);

ATTENTION N’appelez pas list.set(i, x) tant que la taille de la liste de tableaux n’est pas supérieure à i. L’exemple suivant est incorrect : ArrayList list = new ArrayList(100); // capacité 100, taille 0 list.set(0, x); // pas encore d’élément 0

Appelez la méthode add au lieu de set pour remplir un tableau, et n’employez set que pour remplacer un élément déjà ajouté.

Au lieu d’ajouter des éléments à la fin d’une liste de tableaux, vous pouvez aussi les insérer au milieu : int n = staff.size() / 2; staff.add(n, e);

Livre Java .book Page 212 Jeudi, 25. novembre 2004 3:04 15

212

Au cœur de Java 2 - Notions fondamentales

Les éléments situés aux emplacements n et supérieurs sont décalés pour faire place au nouvel élément. Si la nouvelle taille de la liste de tableaux après l’insertion excède la capacité, il est procédé à une réallocation. Il est également possible de supprimer un élément au milieu d’une liste de tableaux : Employee e = staff.remove(n);

Les éléments situés au-dessus de l’élément supprimé sont décalés vers le bas, et la taille du tableau est réduite de 1. L’insertion et la suppression d’éléments ne sont pas très efficaces. On ne s’en préoccupe guère dans le cas de petites listes de tableaux. Si vous devez ajouter ou supprimer fréquemment des éléments au milieu d’une collection, il est préférable d’utiliser une liste liée. La programmation avec les listes liées est étudiée au Chapitre 2 du Volume 2. L’Exemple 5.4 est une modification du programme EmployeeTest du Chapitre 4. Le Tableau Employee[] est remplacé par un ArrayList. Remarquez les changements suivants : m

Il n’est pas nécessaire de spécifier la taille du tableau.

m

Vous appelez add pour ajouter autant d’éléments que vous voulez.

m

Vous utilisez size() au lieu de length pour compter le nombre d’éléments.

m

Vous accédez à un élément à l’aide de a.get(i) au lieu de a[i].

Exemple 5.4 : ArrayListTest.java import java.util.*; public class ArrayListTest { public static void main(String[] args) { // remplir le tableau staff avec trois objets Employee ArrayList staff = new ArrayList(); staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15)); staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1)); staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15)); // augmenter le salaire de tout le monde de 5% for (Employee e : staff) e.raiseSalary(5); // afficher les informations concernant tous les objets Employee for (Employee e : staff) System.out.println("name=" + e.getName()  + ",salary=" + e.getSalary()  + ",hireDay=" + e.getHireDay()); } }

Livre Java .book Page 213 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

213

class Employee { public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); hireDay = calendar.getTime(); } public String getName() { return name; } public double getSalary() { return salary; } public Date getHireDay() { return hireDay; } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } private String name; private double salary; private Date hireDay; } java.util.ArrayList 1.2

•

void set(int index, T obj)

Place une valeur dans la liste de tableau à l’index spécifié, ce qui remplace le contenu précédent. Paramètres : size() -1. •

index

La position d’insertion, qui doit être comprise entre 0 et

obj

La nouvelle valeur

T get(int index)

Récupère la valeur stockée à l’index spécifié. Paramètres :

index

L’index de l’élément à récupérer, qui doit être compris entre 0 et size() -1.

Livre Java .book Page 214 Jeudi, 25. novembre 2004 3:04 15

214

•

Au cœur de Java 2 - Notions fondamentales

void add(int index, T obj)

Place un nouvel élément à la position spécifiée, en décalant les autres éléments vers le haut. Paramètres :

•

index

La position d’insertion, qui doit être comprise entre 0 et size() -1.

obj

Le nouvel élément.

T remove(int index)

Supprime un élément et décale vers le bas les éléments d’indice supérieur. L’élément supprimé est renvoyé. Paramètres :

index

L’indice de l’élément à supprimer. Il doit être compris entre 0 et size() -1.

Compatibilité entre les listes de tableaux brutes et tapées Lorsque vous écrivez un nouveau code avec JDK 5.0 et versions ultérieures, utilisez des paramètres de type, comme ArrayList, pour les listes de tableau. Vous pouvez toutefois avoir besoin d’interagir avec le code existant, qui utilise le type ArrayList brut. Supposons que vous disposiez de la classe existante suivante : public class EmployeeDB { public void update(ArrayList list) { ... } public ArrayList find(String query) { ... } }

Vous pouvez transférer une liste de tableau tapée à la méthode update sans autre transtypage : ArrayList staff = ...; employeeDB.update(staff);

L’objet staff est simplement transféré à la méthode update. ATTENTION Même si vous ne recevez pas d’erreur ou d’avertissement du compilateur, cet appel n’est pas tout à fait sûr. La méthode update pourrait ajouter des éléments dans la liste de tableau de type Employee. Une exception survient lors de la récupération de ces éléments. Ceci peut paraître effrayant mais, en y réfléchissant bien, le comportement est simplement le même que celui avant le JDK 5.0. L’intégrité de la machine n’est donc jamais remise en cause. Dans ce cas, vous ne perdez pas en sécurité, mais vous ne profitez pas non plus des vérifications de compilation.

A l’inverse, lorsque vous attribuez un ArrayList brut à un ArrayList tapé, vous obtenez un avertissement : ArrayList result = employeeDB.find(query); // produit un avertissement

INFO Pour voir le texte de l’avertissement, vous devez procéder à la compilation avec l’option -Xlint:unchecked.

Livre Java .book Page 215 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

215

Utiliser un transtypage ne permet pas de se débarrasser de l’avertissement : ArrayList result = (ArrayList) employeeDB.find(query); ➥// produit un autre avertissement

Vous obtenez un autre avertissement, vous indiquant que le transtypage est erroné. Ceci est la conséquence d’une limitation assez malheureuse des types avec paramètres dans Java. Pour des raisons de compatibilité, le compilateur traduit toutes les listes de tableaux tapées en objets ArrayList bruts, après avoir vérifié que les règles de type n’ont pas été violées. Dans un programme en cours d’exécution, toutes les listes de tableaux sont identiques, il n’y a pas de paramètres de types dans la machine virtuelle. Ainsi, les transtypages (ArrayList) et (ArrayList) transportent des vérifications d’exécution identiques. Vous ne pouvez pas faire grand-chose face à cette situation. Lorsque vous interagissez avec du code existant, étudiez les avertissements du compilateur et persuadez-vous que les avertissements ne sont pas sérieux.

Enveloppes d’objets et autoboxing Il est parfois nécessaire de convertir un type primitif — comme int — en un objet. Tous les types primitifs ont une contrepartie sous forme de classe. Par exemple, il existe une classe Integer correspondant au type primitif int. Une classe de cette catégorie est généralement appelée classe enveloppe (object wrapper). Les classes enveloppes portent des noms correspondant aux types (en anglais) : Integer, Long, Float, Double, Short, Byte, Character, Void et Boolean (les six premières héritent de la superclasse Number). Les classes enveloppes sont inaltérables : vous ne pouvez pas modifier une valeur enveloppée, une fois l’enveloppe construite. Elles sont aussi final, vous ne pouvez donc pas en faire des sous-classes. Supposons que nous voulions travailler sur une liste d’entiers. Malheureusement, le paramètre de type entre les signes ne peut pas être un type primitif. Il n’est pas possible de former un ArrayList. C’est ici que la classe enveloppe Integer fait son apparition. Vous pouvez déclarer une liste de tableaux d’objets Integer : ArrayList list = new ArrayList();

ATTENTION Un ArrayList est bien moins efficace qu’un tableau int[] car chaque valeur est enveloppée séparément dans un objet. Vous ne voudriez utiliser cette construction que pour les petites collections lorsque la commodité du programmeur est plus importante que l’efficacité.

Une autre innovation du JDK 5.0 facilite l’ajout et la récupération d’éléments de tableau. L’appel list.add(3);

est automatiquement traduit en list.add(new Integer(3));

Cette conversion est appelée autoboxing.

Livre Java .book Page 216 Jeudi, 25. novembre 2004 3:04 15

216

Au cœur de Java 2 - Notions fondamentales

INFO Vous pourriez penser que l’enveloppement automatique est plus cohérent, mais la métaphore "boxing" (emballage) provient du C#.

A l’inverse, lorsque vous attribuez un objet Integer à une valeur int, il est automatiquement déballé (unboxing). En fait, le compilateur traduit int n = list.get(i);

en int n = list.get(i).intValue();

Les opérations d’autoboxing et d’unboxing fonctionnent même avec les expressions arithmétiques. Vous pouvez par exemple appliquer l’opération d’incrémentation en une référence d’enveloppe : Integer n = 3; n++;

Le compilateur insère automatiquement des instructions pour déballer l’objet, augmenter la valeur du résultat et le remballer. Dans la plupart des cas, vous avez l’illusion que les types primitifs et leurs enveloppes ne sont qu’un seul et même élément. Ils ne diffèrent considérablement qu’en un seul point : l’identité. Comme vous le savez, l’opérateur ==, appliqué à des objets d’enveloppe, ne teste que si les objets ont des emplacements mémoire identiques. La comparaison suivante échouerait donc probablement : Integer a = 1000; Integer b = 1000; if (a == b) ...

Toutefois, une implémentation Java pourrait, si elle le choisit, envelopper des valeurs communes dans des objets identiques, et la comparaison pourrait donc réussir. Cette ambiguïté n’est pas souhaitable. La solution consiste à appeler la méthode equals lorsque l’on compare des objets d’enveloppe. INFO La caractéristique d’autoboxing exige que boolean, byte, char = 127 et que short et int compris entre −128 et 127 soient enveloppés dans des objets fixes. Par exemple, si a et b avaient été initialisés avec 100 dans l’exemple précédent, la comparaison aurait réussi.

Enfin, soulignons que le boxing et l’unboxing sont proposés par le compilateur et non par la machine virtuelle. Le compilateur insère les appels nécessaires lorsqu’il génère les bytecodes d’une classe. La machine virtuelle exécute simplement ces bytecodes. Les classes enveloppe existent depuis le JDK 1.0 mais, avant le JDK 5.0, vous deviez insérer à la main le code pour le boxing et l’unboxing. Vous verrez souvent les enveloppes de nombres pour une autre raison. Les concepteurs de Java ont découvert que les enveloppes constituent un endroit pratique pour y stocker certaines méthodes de base, comme celles qui permettent de convertir des chaînes de chiffres en nombres.

Livre Java .book Page 217 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

217

Pour transformer une chaîne en entier, vous devez utiliser l’instruction suivante : int x = Integer.parseInt(s);

Ceci n’a rien à voir avec les objets Integer ; parseInt est une méthode statique. Mais la classe Integer constitue un bon endroit pour l’y placer. Les notes API montrent quelques méthodes parmi les plus importantes de la classe Integer. Les autres classes de nombre implémentent les méthodes correspondantes. ATTENTION Certains pensent, à tort, que les classes enveloppes peuvent être employées pour implémenter des méthodes capables de modifier les paramètres numériques. Nous avons vu au Chapitre 4 qu’il était impossible d’écrire une méthode Java qui incrémente un paramètre entier, car les paramètres des méthodes Java sont toujours passés par valeur. public static void triple(int x) // ne marchera pas { X = 3 * x; // modifie la variable locale }

Mais ne pourrait-on pas contourner ce problème en substituant un Integer à un int ? public static void triple(Integer x) // ne marchera pas { . . . }

Le problème vient du fait que les objets Integer sont inaltérables : l’information contenue dans l’enveloppe ne peut pas changer. Vous ne pouvez pas employer les classes enveloppes pour créer une méthode qui modifie les paramètres numériques.

INFO Si vous désirez écrire une méthode qui modifie des paramètres numériques, vous pouvez utiliser un des types holder définis dans le package org.omg.CORBA. Il existe des types IntegerHolder, BooleanHolder, etc. Chaque type holder a un champ public value grâce auquel vous pouvez accéder à la valeur stockée : public static void triple(IntHolder x) { x.value = 3 * x.value; }

java.lang.Integer 1.0

•

int intValue()

Renvoie la valeur de cet objet Integer dans un résultat de type int (surcharge la méthode intValue de la classe Number). •

static String toString(int i)

Renvoie un nouvel objet chaîne représentant le nombre, en base 10. •

static String toString(int i, int radix)

Permet de renvoyer une représentation du nombre i dans la base spécifiée par le paramètre radix.

Livre Java .book Page 218 Jeudi, 25. novembre 2004 3:04 15

218

•

Au cœur de Java 2 - Notions fondamentales

static int parseInt(String s)

Renvoie la valeur d’entier de la chaîne s, si elle représente un nombre entier en base 10. •

static int parseInt(String s, int radix)

Renvoie la valeur d’entier de la chaîne s, si elle représente un nombre entier exprimé dans la base spécifiée par le paramètre radix. •

static Integer valueOf(String s)

Renvoie un nouvel objet Integer initialisé avec la valeur de la chaîne spécifiée, si celle-ci représente un nombre entier en base 10. •

static Integer valueOf(String s, int radix)

Renvoie un nouvel objet Integer initialisé avec la valeur de la chaîne s, si celle-ci représente un nombre entier exprimé dans la base spécifiée par le paramètre radix. java.text.NumberFormat 1.1

•

Number parse(String s)

Renvoie la valeur numérique, en supposant que la chaîne spécifiée représente un nombre.

Méthodes ayant un nombre variable de paramètres Avant JDK 5.0, chaque méthode Java disposait d’un nombre fixe de paramètres. Il est toutefois maintenant possible de fournir des méthodes qui peuvent être appelées avec un nombre variable de paramètres (quelquefois appelés méthodes "varargs"). Vous avez déjà vu une telle méthode, la méthode printf. Par exemple, les appels System.out.printf("%d", n);

et System.out.printf("%d %s", n, "widgets");

appellent tous deux la même méthode, même si l’un a deux paramètres et l’autre, trois. La méthode printf est définie comme ceci : public class PrintStream { public PrintStream printf(String fmt, Object... args) ➥{ return format(fmt, args); } }

Ici, l’ellipse... fait partie du code Java. Elle montre que la méthode peut recevoir un nombre arbitraire d’objets (en plus du paramètre fmt). La méthode printf reçoit en fait deux paramètres, la chaîne format et un tableau Object[] qui contient tous les autres paramètres (si l’appelant fournit des entiers ou autres valeurs de type primitif, l’autoboxing les transforme en objets). Elle dispose maintenant de la tâche non enviable d’analyser la chaîne fmt et de se conformer au spécificateur du format ith avec la valeur args[i]. Autrement dit, pour l’implémenteur de printf, le type de paramètre Object... est exactement le même que Object[].

Livre Java .book Page 219 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

219

Le compilateur doit transformer chaque appel à printf, en regroupant les paramètres dans un tableau et en procédant à l’autoboxing en fonction des besoins : System.out.printf("%d %d", new Object[] { new Integer(d), "widgets" } );

Vous pouvez définir vos propres méthodes avec des paramètres variables et spécifier tout type pour les paramètres, même un type primitif. Voici un exemple simple : une fonction qui calcule le maximum d’un nombre variable de valeurs : public static double max(double... values) { double largest = Double.MIN_VALUE; for (double v : values) if (v > largest) largest = v; return largest; }

Appelez simplement la fonction comme ceci : double m = max(3.1, 40.4, -5);

Le compilateur transfère un nouveau double[] { 3.1, 40.4, -5 } à la fonction max. INFO Le transfert d’un tableau comme dernier paramètre d’une méthode avec des paramètres variables est autorisé, par exemple : System.out.printf("%d %s", new Object[] { new Integer(1), "widgets" } );

Vous pouvez donc redéfinir une fonction existante dont le dernier paramètre est un tableau par une méthode disposant de paramètres variables, sans casser un code existant. MessageFormat.format a, par exemple, été amélioré dans ce sens dans le JDK 5.0.

Réflexion La bibliothèque de réflexion constitue une boîte à outils riche et élaborée pour écrire des programmes qui manipulent dynamiquement du code Java. Cette fonctionnalité est très largement utilisée dans JavaBeans, l’architecture des composants Java (voir le Volume 2 pour en savoir plus sur JavaBeans). Au moyen de la réflexion, Java est capable de supporter des outils comme ceux auxquels les utilisateurs de Visual Basic sont habitués. Précisément, lorsque de nouvelles classes sont ajoutées au moment de la conception ou de l’exécution, des outils de développement d’application rapide peuvent se renseigner dynamiquement sur les capacités des classes qui ont été ajoutées. Un programme qui peut analyser les capacités des classes est appelé réflecteur. Le mécanisme de réflexion est extrêmement puissant. Comme vous le montrent les sections suivantes, il peut être employé pour : m

analyser les capacités des classes au moment de l’exécution ;

m

étudier les objets au moment de l’exécution, par exemple pour écrire une seule méthode toString qui fonctionne pour toutes les classes ;

m

implémenter un code générique pour la manipulation des tableaux ;

m

profiter des objets Method qui se comportent comme les pointeurs de fonction des langages tels que C++.

Livre Java .book Page 220 Jeudi, 25. novembre 2004 3:04 15

220

Au cœur de Java 2 - Notions fondamentales

La réflexion est un mécanisme puissant et complexe ; il intéresse toutefois principalement les concepteurs d’outils, et non les programmeurs d’applications. Si vous vous intéressez à la programmation des applications plutôt qu’aux outils pour les programmeurs Java, vous pouvez ignorer sans problème le reste de ce chapitre et y revenir par la suite.

La classe Class Lorsque le programme est lancé, le système d’exécution de Java gère, pour tous les objets, ce que l’on appelle "l’identification de type à l’exécution". Cette information mémorise la classe à laquelle chaque objet appartient. L’information de type au moment de l’exécution est employée par la machine virtuelle pour sélectionner les méthodes correctes à exécuter. Vous pouvez accéder à cette information en travaillant avec une classe Java particulière, baptisée singulièrement Class. La méthode getClass() de la classe Object renvoie une instance de type Class : Employee e; . . . Class cl = e.getClass();

Tout comme un objet Employee décrit les propriétés d’un employé particulier, un objet Class décrit les propriétés d’une classe particulière. La méthode la plus utilisée de Class est sans conteste getName, qui renvoie le nom de la classe. Par exemple, l’instruction System.out.println(e.getClass().getName() + " " + e.getName());

affiche Employee Harry Hacker

si e est un employé ou Manager Harry Hacker

si e est un directeur. Vous pouvez aussi obtenir un objet Class correspondant à une chaîne, à l’aide de la méthode statique forName : String className = "java.util.Date"; Class cl = Class.forName(className);

Cette technique est utilisée si le nom de classe est stocké dans une chaîne qui peut changer à l’exécution. Cela fonctionne lorsque className est bien le nom d’une classe ou d’une interface. Dans le cas contraire, la méthode forName lance une exception vérifiée. Consultez le texte encadré plus loin pour voir comment fournir un gestionnaire d’exception lorsque vous utilisez cette méthode. ASTUCE Au démarrage, la classe contenant votre méthode main est chargée. Elle charge toutes les classes dont elle a besoin. Chacune de ces classes charge les classes qui lui sont nécessaires, et ainsi de suite. Cela peut demander un certain temps pour une application importante, ce qui est frustrant pour l’utilisateur. Vous pouvez donner aux utilisateurs de votre programme l’illusion d’un démarrage plus rapide, à l’aide de l’astuce suivante. Assurez-vous que la classe contenant la méthode main ne fait pas explicitement référence aux autres classes. Affichez d’abord un écran splash, puis forcez manuellement le chargement des autres classes en appelant Class.forName.

Livre Java .book Page 221 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

221

Une troisième technique emploie un raccourci pratique pour obtenir un objet de type Class. En effet, si T est d’un type Java quelconque, alors T.class représente l’objet classe correspondant. Voici quelques exemples : Class cl1 = Date.class; // si vous importez java.util.*; Class cl2 = int.class; Class cl3 = Double[].class;

Remarquez qu’un objet Class désigne en réalité un type, qui n’est pas nécessairement une classe. Par exemple, int n’est pas une classe, mais int.class est pourtant un objet du type Class. INFO Depuis le JDK 5.0, la classe Class possède des paramètres. Par exemple, Employee.class est de type Class. Nous ne traiterons pas de ce problème car il compliquerait encore un concept déjà abstrait. Dans un but pratique, vous pouvez ignorer le paramètre de type et travailler avec le type Class brut. Voyez le Chapitre 13 pour en savoir plus sur ce problème.

ATTENTION Pour des raisons historiques, la méthode getName renvoie des noms étranges pour les types tableaux :

• Double[].class.getName() returns "[Ljava.lang.Double;". • int[].class.getName() returns "[I".

La machine virtuelle gère un unique objet Class pour chaque type. Vous pouvez donc utiliser l’opérateur == pour comparer les objets class, par exemple : if (e.getClass() == Employee.class) . . .

Interception d’exceptions La gestion des exceptions est vue en détail au Chapitre 11 mais, en attendant, vous pouvez rencontrer des cas où les méthodes menacent de lancer des exceptions. Lorsqu’une erreur se produit au moment de l’exécution, un programme peut "lancer une exception". L’action de lancer une exception est plus souple que de terminer le programme, car vous pouvez fournir un gestionnaire qui "intercepte" l’exception et la traite. Si vous ne fournissez pas de gestionnaire, le programme se termine pourtant et affiche à la console un message donnant le type de l’exception. Vous avez peut-être déjà vu un compte rendu d’exception si vous employez à tort une référence null ou que vous dépassiez les limites d’un tableau. Il existe deux sortes d’exceptions : vérifiées et non vérifiées (checked/unchecked). Dans le cas d’exceptions vérifiées, le compilateur vérifie que vous avez fourni un gestionnaire. Cependant, de nombreuses exceptions communes, telle qu’une tentative d’accéder à une référence null, ne sont pas vérifiées. Le compilateur ne vérifie pas si vous fournissez un gestionnaire pour ces erreurs — après tout, vous êtes censé mobiliser votre énergie pour éviter ces erreurs plutôt que de coder des gestionnaires pour les traiter.

Livre Java .book Page 222 Jeudi, 25. novembre 2004 3:04 15

222

Au cœur de Java 2 - Notions fondamentales

Mais toutes les erreurs ne sont pas évitables. Si une exception peut se produire en dépit de vos efforts, le compilateur s’attendra à ce que vous fournissiez un gestionnaire. Class.forName est un exemple de méthode qui déclenche une exception vérifiée. Vous étudierez, au Chapitre 11, plusieurs stratégies de gestion d’exception. Pour l’instant, nous nous contenterons de vous indiquer l’implémentation du gestionnaire le plus simple. Placez une ou plusieurs méthodes pouvant lancer des exceptions vérifiées, dans un bloc d’instructions try, puis fournissez le code du gestionnaire dans la clause catch. try { instructions pouvant déclencher des exceptions } catch(Exception e) { action du gestionnaire } En voici un exemple : try { String name = . . .; // extraire le nom de classe Class cl = Class.forName(name); // peut lancer une exception . . . // faire quelque chose avec cl } catch(Exception e) { e.printStackTrace(); } Si le nom de classe n’existe pas, le reste du code dans le bloc try est sauté, et le programme se poursuit à la clause catch (ici, nous imprimons une trace de pile à l’aide de la méthode printStackTrace de la classe Throwable qui est la superclasse de la classe Exception). Si aucune des méthodes dans le bloc try ne déclenche d’exception, le code du gestionnaire dans la clause catch est sauté. Vous n’avez besoin de fournir de gestionnaire d’exception que pour les exceptions vérifiées. Il est facile de déterminer les méthodes qui lancent des exceptions vérifiées — le compilateur protestera quand vous appellerez une méthode menaçant de lancer une exception vérifiée et que ne fournirez pas de gestionnaire.

Il existe une autre méthode utile qui permet de créer une instance de classe à la volée. Cette méthode se nomme, assez naturellement, newInstance(). Par exemple, e.getClass().newInstance();

crée une nouvelle instance du même type de classe que e. La méthode newInstance appelle le constructeur par défaut (celui qui ne reçoit aucun paramètre) pour initialiser l’objet nouvellement créé. Une exception est déclenchée si la classe ne dispose pas de constructeur par défaut. Une combinaison de forName et de newInstance permet de créer un objet à partir d’un nom de classe stocké dans une chaîne : String s = "java.util.Date"; Object m = Class.forName(s).newInstance();

Livre Java .book Page 223 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

223

INFO Vous ne pourrez pas employer cette technique si vous devez fournir des paramètres au constructeur d’une classe que vous souhaitez instancier à la volée. Vous devrez recourir à la méthode newInstance de la classe Constructor (il s’agit d’une des classes du package java.lang.reflect, dont nous parlerons dans la section suivante).

INFO C++ La méthode newInstance correspond à un constructeur virtuel en C++. Cependant, la construction virtuelle en C++ n’est pas une caractéristique du langage, mais une simple tournure idiomatique qui doit être prise en charge par une bibliothèque spécialisée. Class est comparable à la classe type_info de C++, et la méthode getClass équivaut à l’opérateur typeid. Néanmoins, la classe Class de Java est plus souple que type_info qui peut seulement fournir le nom d’un type, et non créer de nouveaux objets de ce type.

java.lang.Class 1.0

•

static Class forName(String className)

Renvoie l’objet Class qui représente la classe ayant pour nom className. •

Object newInstance()

Renvoie une nouvelle instance de cette classe. java.lang.reflect.Constructor 1.1

•

Object newInstance(Object[] args)

Construit une nouvelle instance de la classe déclarante du constructeur. Paramètres :

args

Les paramètres fournis au constructeur. Voir la section relative à la réflexion pour plus d’informations sur la façon de fournir les paramètres.

java.lang.Throwable 1.0

•

void printStackTrace()

Affiche l’objet Throwable et la trace de la pile dans l’unité d’erreur standard.

La réflexion pour analyser les caractéristiques d’une classe Nous vous proposons un bref aperçu des éléments les plus importants du mécanisme de réflexion, car il permet d’examiner la structure d’une classe. Les trois classes Field, Method et Constructor, qui se trouvent dans le package java.lang.reflect, décrivent respectivement les champs, les méthodes et les constructeurs d’une classe. Ces trois classes disposent d’une méthode getName qui renvoie le nom de l’élément. La classe Field possède une méthode getType renvoyant un objet, de type Class, qui décrit le type du champ. Les classes Method et Constructor possèdent des méthodes permettant d’obtenir les types des paramètres, et la classe Method signale aussi le type de retour. Les trois classes possèdent également une méthode appelée getModifiers : elle renvoie un entier dont les bits sont utilisés comme sémaphores pour décrire les modificateurs spécifiés, tels que public ou static. Vous pouvez alors utiliser les méthodes statiques de la classe Modifier du package java.lang.reflect pour analyser les entiers renvoyés par getModifiers. Par exemple, il existe des méthodes telles que isPublic, isPrivate ou isFinal pour déterminer si un constructeur ou une méthode a été déclarée public, private ou final.

Livre Java .book Page 224 Jeudi, 25. novembre 2004 3:04 15

224

Au cœur de Java 2 - Notions fondamentales

Il vous suffit d’appeler la méthode appropriée de Modifier et de l’utiliser sur l’entier renvoyé par getModifiers. Il est également possible d’employer Modifier.toString pour afficher les modificateurs. Les méthodes getFields, getMethods et getConstructors de la classe Class renvoient dans des tableaux les éléments publics, les méthodes et les constructeurs gérés par la classe. Ces éléments sont des objets de la classe correspondante de java.lang.reflect. Cela inclut les membres publics des superclasses. Les méthodes getDeclaredFields, getDeclaredMethods et getDeclaredConstructors de Class renvoient des tableaux constitués de tous les champs, méthodes et constructeurs déclarés dans la classe, y compris les membres privés et protégés, mais pas les membres des superclasses. L’Exemple 5.5 explique comment afficher toutes les informations relatives à une classe. Le programme vous demande le nom d’une classe, puis affiche la signature de chaque méthode et de chaque constructeur ainsi que le nom de chaque champ de données de la classe en question. Par exemple, si vous tapez : java.lang.Double

Le programme affiche : class java.lang.Double extends java.lang.Number { public java.lang.Double(java.lang.String); public java.lang.Double(double); public public public public public public public public public public public public public public public public public public public public public

int hashCode(); int compareTo(java.lang.Object); int compareTo(java.lang.Double); boolean equals(java.lang.Object); java.lang.String toString(); static java.lang.String toString(double); static java.lang.Double valueOf(java.lang.String); static boolean isNaN(double); boolean isNaN(); static boolean isInfinite(double); boolean isInfinite(); byte byteValue(); short shortValue(); int intValue(); long longValue(); float floatValue(); double doubleValue(); static double parseDouble(java.lang.String); static native long doubleToLongBits(double); static native long doubleToRawLongBits(double); static native double longBitsToDouble(long);

public static final double POSITIVE_INFINITY; public static final double NEGATIVE_INFINITY; public static final double NaN; public static final double MAX_VALUE; public static final double MIN_VALUE; public static final java.lang.Class TYPE; private double value; private static final long serialVersionUID; }

Livre Java .book Page 225 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

225

Ce qui est remarquable dans ce programme, c’est qu’il peut analyser toute classe apte à être chargée par l’interpréteur, et pas seulement les classes disponibles au moment où le programme est compilé. Nous le réutiliserons au chapitre suivant pour examiner les classes internes générées automatiquement par le compilateur Java. Exemple 5.5 : ReflectionTest.java import java.util.*; import java.lang.reflect.*; public class ReflectionTest { public static void main(String[] args) { /* lire le nom de classe dans les args de ligne de commande ou l’entrée de l’utilisateur */ String name; if (args.length > 0) name = args[0]; else { Scanner in = new Scanner(System.in); System.out.println("Enter class Name ("e.g. java.util.Date): "); name = in.next(); } try { /* afficher le nom de classe et de superclasse (if != Object) */ Class cl = Class.forName(name); Class supercl = cl.getSuperclass(); System.out.print("class " + name); if (supercl != null && supercl != Object.class) System.out.print(" extends " + supercl.getName()); System.out.print("\n{\n"); printConstructors(cl); System.out.println(); printMethods(cl); System.out.println(); printFields(cl); System.out.println("}"); } catch(ClassNotFoundException e) { e.printStackTrace(); } System.exit(0); } /** affiche tous les constructeurs d’une classe @param cl Une classe */ public static void printConstructors(Class cl) { Constructor[] constructors = cl.getDeclaredConstructors(); for (Constructor c : constructors) {

Livre Java .book Page 226 Jeudi, 25. novembre 2004 3:04 15

226

Au cœur de Java 2 - Notions fondamentales

String name = c.getName(); System.out.print(" " + Modifier.toString(c.getModifiers())); System.out.print(" " + name + "("); // afficher les types des paramètres Class[] paramTypes = c.getParameterTypes(); for (int j = 0; j < paramTypes.length; j++) { if (j > 0) System.out.print(", "); System.out.print(paramTypes[j].getName()); } System.out.println(");"); } } /** imprime toutes les méthodes d’une classe @param cl Une classe */ public static void printMethods(Class cl) { Method[] methods = cl.getDeclaredMethods(); for (Method m : methods) Class retType = m.getReturnType(); String name = m.getName(); /* affiche les modificateurs, le type renvoyé et le nom de la méthode */ System.out.print(" " + Modifier.toString(m.getModifiers())); System.out.print(" " + retType.getName() + " " + name  + "("); // imprime les types des paramètres Class[] paramTypes = m.getParameterTypes(); for (int j = 0; j < paramTypes.length; j++) { if (j > 0) System.out.print(", "); System.out.print(paramTypes[j].getName()); } System.out.println(");"); } } /** Affiche tous les champs d’une classe @param cl Une classe */ public static void printFields(Class cl) { Field[] fields = cl.getDeclaredFields(); for (Field f : fields) Class type = f.getType(); String name = f.getName();

Livre Java .book Page 227 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

System.out.print(" System.out.println("  + ";");

227

" + Modifier.toString(f.getModifiers())); "  + type.getName() + " " + name

} } } java.lang.Class 1.0 Field[] getFields() 1.1 Field[] getDeclaredFields() 1.1

• •

La méthode getFields renvoie un tableau contenant les objets Field représentant les champs publics de cette classe ou de ses superclasses. La méthode getDeclaredFields renvoie un tableau d’objets Field pour tous les champs de cette classe. Ces méthodes renvoient un tableau de longueur 0 s’il n’y a pas de champ correspondant ou si l’objet Class représente un type primitif ou un type tableau. • •

Method[] getMethods 1.1() Method[] getDeclaredMethods() 1.1

Renvoient un tableau qui contient des objets Method : getMethods renvoie des méthodes publiques et inclut des méthodes héritées ; getDeclaredMethods renvoie toutes les méthodes de cette classe ou interface mais n’inclut pas les méthodes héritées. • •

Constructor[] getConstructors 1.1 () Constructor[] getDeclaredConstructors() 1.1

Renvoient un tableau d’objets Constructor représentant tous les constructeurs publics (avec getConstructors) ou tous les constructeurs (avec getDeclaredConstructors) de la classe désignée par cet objet Class. java.lang.reflect.Field 1.1 java.lang.reflect.Method 1.1 java.lang.reflect.Constructor 1.1 • Class getDeclaringClass()

Renvoie l’objet Class de la classe qui définit ce constructeur, cette méthode ou ce champ. •

Class[] getExceptionTypes()

Dans les classes Constructor et Method, renvoie un tableau d’objets Class qui représentent les types d’exceptions déclenchées par la méthode. •

int getModifiers()

Renvoie un entier décrivant les modificateurs du constructeur, de la méthode ou du champ. Utilisez les méthodes de la classe Modifier pour analyser le résultat. •

String getName()

Renvoie une chaîne qui donne le nom du constructeur, de la méthode ou du champ. •

Class[] getParameterTypes()

Dans les classes Constructor et Method, renvoie un tableau d’objets Class qui représentent les types des paramètres. •

Class getReturnType() (dans les classes Method)

Renvoie un objet Class qui représente le type de retour.

Livre Java .book Page 228 Jeudi, 25. novembre 2004 3:04 15

228

Au cœur de Java 2 - Notions fondamentales

java.lang.reflect.Modifier 1.1

•

static String toString(int modifiers)

Renvoie une chaîne avec les modificateurs correspondant aux bits définis dans modifiers. • • • • • • • • • • •

static boolean isAbstract(int modifiers) static boolean isFinal(int modifiers) static boolean isInterface(int modifiers) static boolean isNative(int modifiers) static boolean isPrivate(int modifiers) static boolean isProtected(int modifiers) static boolean isPublic(int modifiers) static boolean isStatic(int modifiers) static boolean isStrict(int modifiers) static boolean isSynchronized(int modifiers) static boolean isVolatile(int modifiers)

Ces méthodes testent le bit dans la valeur modifiers qui correspond à l’élément modificateur du nom de la méthode.

La réflexion pour l’analyse des objets à l’exécution Dans la section précédente, nous avons vu comment trouver le nom et le type des champs de n’importe quel objet : m

obtenir l’objet Class correspondant ;

m

appeler getDeclaredFields sur l’objet Class.

Dans cette section, nous allons franchir une étape supplémentaire et étudier le contenu des champs. Bien entendu, il est facile de lire le contenu d’un champ spécifique d’un objet dont le nom et le type sont connus lors de l’écriture du programme. Mais la réflexion nous permet de lire les champs des objets qui n’étaient pas connus au moment de la compilation. A cet égard, la méthode essentielle est la méthode get de la classe Field. Si f est un objet de type Field (obtenu par exemple grâce à getDeclaredFields) et obj un objet de la classe dont f est un champ, alors f.get(obj) renvoie un objet dont la valeur est la valeur courante du champ de obj. Tout cela peut paraître un peu abstrait ; nous allons donc prendre un exemple : Employee harry = new Employee("Harry Hacker", 35000, 10, 1, 1989); Class cl = harry.getClass(); // l’objet class représentant Employee Field f = cl.getDeclaredField("name"); // le champ name de la classe Employee Object v = f.get(harry); /* la valeur du champ name de l’objet harry c’est-à-dire l’objet String "Harry Hacker" */

En fait, ce code pose un problème. Comme le champ name est un champ privé, la méthode get déclenche une exception IllegalAccessException (Exception pour accès interdit). Cette méthode ne peut être employée que pour obtenir les valeurs des champs accessibles. Le mécanisme de sécurité de Java vous permet de connaître les champs d’un objet, mais pas de lire la valeur de ces champs si vous n’avez pas une autorisation d’accès.

Livre Java .book Page 229 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

229

Par défaut, le mécanisme de réflexion respecte le contrôle des accès. Néanmoins, si un programme Java n’est pas contrôlé par un gestionnaire de sécurité qui le lui interdit, il peut outrepasser son droit d’accès. Pour cela, il faut invoquer la méthode setAccessible d’un objet Field, Method ou Constructor : f.setAccessible(true); // les appels f.get(harry) sont maintenant autorisés

La méthode setAccessible se trouve dans la classe AccessibleObject, qui est la superclasse commune des classes Field, Method et Constructor. Cette fonctionnalité est destinée au débogage, au stockage permanent et à des mécanismes similaires. Nous l’emploierons pour étudier une méthode toString générique. La méthode get pose un second problème. Le champ name est de type String, il est donc possible de récupérer la valeur en tant que Object. Mais supposons que nous désirions étudier le champ salary. Celui-ci est de type double, et les nombres ne sont pas des objets en Java. Il existe deux solutions. La première consiste à utiliser la méthode getDouble de la classe Field ; la seconde est un appel à get, car le mécanisme de réflexion enveloppe automatiquement la valeur du champ dans la classe enveloppe appropriée, en l’occurrence, Double. Bien entendu, il est possible de modifier les valeurs obtenues. L’appel f.set(obj, value) affecte une nouvelle valeur au champ de l’objet obj représenté par f. L’Exemple 5.6 montre comment écrire une méthode toString générique capable de fonctionner avec n’importe quelle classe. Elle appelle d’abord getDeclaredField pour obtenir tous les champs de données. Elle utilise ensuite la méthode setAccessible pour rendre tous ces champs accessibles, puis elle récupère le nom et la valeur de chaque champ. L’exemple 5.6 convertit chaque valeur en chaîne par un appel à sa propre méthode toString : class ObjectAnalyzer { public String toString(Object obj) { Class cl = obj.getClass(); ... String r = cl.getName(); /* inspecter les champs de cette classe et de toutes les superclasses */ do { r += "["; Field[] fields = cl.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); // extraire les noms et valeurs de tous les champs for (Field f : fields) { if (!Modifier.isStatic(f.getModifiers())) { if (!r.endsWith("[")) r += "," r += f.getName() + "="; try { Object val = f.get(obj); r += val.toString(val); }

Livre Java .book Page 230 Jeudi, 25. novembre 2004 3:04 15

230

Au cœur de Java 2 - Notions fondamentales

catch (Exception e) { e.printStackTrace(); } } } r += "]"; cl = cl.getSuperclass(); } while (cl != Object.class); return r; } . . . }

La totalité du code de l’Exemple 5.6 doit traiter deux complexités. Les cycles de référence pourraient entraîner une récursion infinie. ObjectAnalyzer suit donc la trace des objets qui ont déjà été visités. De même, pour regarder dans les tableaux, vous devez adopter une approche différente. Vous en saurez plus dans la section suivante. Cette méthode toString peut être employée pour disséquer n’importe quel objet. Par exemple, l’appel ArrayList squares = new ArrayList(); for (int i = 1; i <= 5; i++) squares.add(i * i); System.out.println(new ObjectAnalyzer().toString(squares));

produit l’impression java.util.ArrayList[elementData=class java.lang.Object[]{java.lang.Integer[value=1][][], java.lang.Integer[value=4][][], java.lang.Integer[value=9][][],java.lang.Integer[value=16][][], java.lang.Integer[value=25][][], null,null,null,null,null},size=5][modCount=5][][]

La méthode générique toString est utilisée dans l’Exemple 5.6 pour implémenter les méthodes toString de vos propres classes, comme ceci : public String toString() { return ObjectAnalyzer.toString(this); }

Il s’agit d’une technique sûre pour créer une méthode toString, qui pourra vous être utile dans vos programmes. Exemple 5.6 : ObjectAnalyzerTest.java import java.lang.reflect.*; import java.util.*; import java.text.*; public class ObjectAnalyzerTest { public static void main(String[] args) { ArrayList squares = new ArrayList(); for (int i = 1; i <= 5; i++) squares.add(i * i); System.out.println(new ObjectAnalyzer().toString(squares)); } }

Livre Java .book Page 231 Jeudi, 25. novembre 2004 3:04 15

Chapitre 5

L’héritage

class ObjectAnalyzer { /** Convertit un objet en une représentation chaîne qui liste tous les champs. @param obj Un objet @return une chaîne avec le nom de classe de l’objet et tous les noms et valeurs de champs */ public String toString(Object obj) { if (obj == null) return "null"; if (visited.contains(obj)) return "..."; visited.add(obj); Class cl = obj.getClass(); if (cl == String.class) return (String) obj; if (cl.isArray()) { String r = cl.getComponentType() + "[]{"; for (int i = 0; i < Array.getLength(obj); i++) { if (i > 0) r += ","; Object val = Array.get(obj, i); if (cl.getComponentType().isPrimitive()) r += val; else r += toString(val); } return r + "}"; } String r = cl.getName(); /* inspecter les champs de cette classe et de toutes les superclasses */ do { r += "["; Field[] fields = cl.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); // extraire les noms et valeurs de tous les champs for (Field f : fields) { if (!Modifier.isStatic(f.getModifiers())) { if (!r.endsWith("[")) r += ","; r += f.getName() + "="; try { Class t = f.getType(); Object val = f.get(obj); if (t.isPrimitive()) r += val; else r += toString(val); } catch (Exception e) { e.printStackTrace(); } } r += "]"; cl = cl.getSuperclass(); }

231

Livre Java .book Page 232 Jeudi, 25. novembre 2004 3:04 15

232

Au cœur de Java 2 - Notions fondamentales

while (cl != null); return r; } private ArrayList