™
Livre Java.book Page I Mercredi, 13. février 2008 2:34 14
Au cœur de Java
™
volume 1 Notions fondamentales 8e édition Cay S. Horstmann et Gary Cornell
Livre Java.book Page II Mercredi, 13. février 2008 2:34 14
Le présent ouvrage est la traduction de Core Java, vol. I Fundamentals, 8e éd., de Cay Hortsmann et Gary Cornell, publié par Pearson Education Inc./Prentice Hall, Copyright © 2008 Sun Microsystem Inc. Authorized translation from the English language edition, entitled CORE JAVA, VOL. I FUNDAMENTALS, 8th Edition By CAY HORTSMANN and GARY CORNELL, published by Pearson Education Inc., publishing as Prentice Hall, Copyright © 2008 Sun Microsystem Inc., 4150 Network Circle, Santa Clara, California 95054 USA. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. French language edition published by PEARSON EDUCATION FRANCE, Copyright © 2008
Publié par Pearson Education France 47 bis, rue des Vinaigriers 75010 PARIS Tél. : 01 72 74 90 00
Titre original : Core Java, volume 1 Fundamentals
Mise en pages : TyPAO
ISBN original : 0-13-235476-4 Copyright © 2008 Sun Microsystems, Inc. Tous droits réservés
Traduit de l’américain par : Christiane Silhol et Nathalie Le Guillou de Penanros
ISBN : 978-2-7440-4080-1 Copyright© 2009 Pearson Education France Sun Microsystems Inc. 901 San Antonio Road, Palo Alto, California 94303 USA
Tous droits réservés. Aucune représentation ou reproduction, même partielle, autre que celles prévues à l’article L. 122-5 2˚ et 3˚ a) du code de la propriété intellectuelle ne peut être faite sans l’autorisation expresse de Pearson Education France ou, le cas échéant, sans le respect des modalités prévues à l’article L. 122-10 dudit code.
Livre Java.book Page III Mercredi, 13. février 2008 2:34 14
Table des matières
Introduction .................................................................................................................................. Avertissement au lecteur .......................................................................................................... A propos de ce livre ................................................................................................................. Conventions .............................................................................................................................. Exemples de code .....................................................................................................................
1 1 2 4 5
Chapitre 1. Une introduction à Java ......................................................................................... Java, plate-forme de programmation ........................................................................................ Les termes clés du livre blanc de Java ...................................................................................... Simplicité ............................................................................................................................ Orienté objet ....................................................................................................................... Compatible avec les réseaux ............................................................................................... Fiabilité ............................................................................................................................... Sécurité ............................................................................................................................... Architecture neutre ............................................................................................................. Portabilité ........................................................................................................................... Interprété ............................................................................................................................. Performances élevées .......................................................................................................... Multithread ......................................................................................................................... Java, langage dynamique .................................................................................................... Les applets Java et Internet ...................................................................................................... Bref historique de Java ............................................................................................................. Les idées fausses les plus répandues concernant Java ..............................................................
7 7 8 8 9 10 10 10 11 12 12 12 13 13 14 15 17
Chapitre 2. L’environnement de programmation de Java ...................................................... Installation du kit de développement Java ................................................................................ Télécharger le JDK ............................................................................................................. Configurer le chemin d’exécution ...................................................................................... Installer la bibliothèque et la documentation ...................................................................... Installer les exemples de programmes ................................................................................ Explorer les répertoires de Java ..........................................................................................
21 21 22 24 26 26 27
Livre Java.book Page IV Mercredi, 13. février 2008 2:34 14
IV
Table des matières
Choix de l’environnement de développement .......................................................................... Utilisation des outils de ligne de commande ............................................................................ Conseils pour la recherche d’erreurs .................................................................................. Utilisation d’un environnement de développement intégré ...................................................... Localiser les erreurs de compilation ................................................................................... Exécution d’une application graphique .................................................................................... Elaboration et exécution d’applets ...........................................................................................
28 28 30 31 34 35 37
Chapitre 3. Structures fondamentales de la programmation Java ......................................... Un exemple simple de programme Java ................................................................................... Commentaires .......................................................................................................................... Types de données ..................................................................................................................... Entiers ................................................................................................................................. Types à virgule flottante ...................................................................................................... Le type char ...................................................................................................................... Type booléen ....................................................................................................................... Variables ................................................................................................................................... Initialisation des variables ....................................................................................................... Constantes ........................................................................................................................... Opérateurs ................................................................................................................................ Opérateurs d’incrémentation et de décrémentation ............................................................ Opérateurs relationnels et booléens .................................................................................... Opérateurs binaires ............................................................................................................. Fonctions mathématiques et constantes .............................................................................. Conversions de types numériques ...................................................................................... Transtypages ....................................................................................................................... Parenthèses et hiérarchie des opérateurs ............................................................................ Types énumérés .................................................................................................................. Chaînes ..................................................................................................................................... Sous-chaînes ....................................................................................................................... Concaténation ..................................................................................................................... Les chaînes sont inaltérables .............................................................................................. Test d’égalité des chaînes ................................................................................................... Points de code et unités de code ......................................................................................... L’API String .................................................................................................................... Lire la documentation API en ligne .................................................................................... Construction de chaînes ...................................................................................................... Entrées et sorties ....................................................................................................................... Lire les caractères entrés ..................................................................................................... Mise en forme de l’affichage .............................................................................................. Entrée et sortie de fichiers ..................................................................................................
41 42 45 45 46 47 48 49 50 51 52 52 54 54 55 56 57 58 58 59 60 60 60 61 62 63 64 66 69 70 70 72 76
Livre Java.book Page V Mercredi, 13. février 2008 2:34 14
Table des matières
V
Flux d’exécution ....................................................................................................................... Portée d’un bloc .................................................................................................................. Instructions conditionnelles ................................................................................................ Boucles .............................................................................................................................. Boucles déterminées ........................................................................................................... Sélections multiples — l’instruction switch .................................................................... Interrompre le flux d’exécution .......................................................................................... Grands nombres ....................................................................................................................... Tableaux ................................................................................................................................... La boucle "for each" ........................................................................................................... Initialiseurs de tableaux et tableaux anonymes .................................................................. Copie des tableaux .............................................................................................................. Paramètres de ligne de commande ..................................................................................... Tri d’un tableau ................................................................................................................... Tableaux multidimensionnels ............................................................................................. Tableaux irréguliers ............................................................................................................
78 78 79 82 86 90 92 94 96 97 98 99 101 102 105 108
Chapitre 4. Objets et classes ...................................................................................................... Introduction à la programmation orientée objet ....................................................................... Les classes .......................................................................................................................... Les objets ............................................................................................................................ Identification des classes .......................................................................................................... Relations entre les classes ................................................................................................... Utilisation des classes existantes .............................................................................................. Objets et variables objet ..................................................................................................... La classe GregorianCalendar de la bibliothèque Java ..................................................... Les méthodes d’altération et les méthodes d’accès ............................................................ Définition de vos propres classes ............................................................................................. Une classe Employee .......................................................................................................... Travailler avec plusieurs fichiers source ............................................................................. Analyser la classe Employee ............................................................................................. Premiers pas avec les constructeurs .................................................................................... Paramètres implicites et explicites ...................................................................................... Avantages de l’encapsulation ............................................................................................. Privilèges d’accès fondés sur les classes ............................................................................ Méthodes privées ................................................................................................................ Champs d’instance final .................................................................................................. Champs et méthodes statiques .................................................................................................. Champs statiques ................................................................................................................ Constantes statiques ............................................................................................................ Méthodes statiques .............................................................................................................
111 112 113 113 114 115 116 117 120 121 128 128 131 132 132 134 135 137 137 138 138 138 139 140
Livre Java.book Page VI Mercredi, 13. février 2008 2:34 14
VI
Table des matières
Méthodes "factory" ............................................................................................................. La méthode main ............................................................................................................... Paramètres des méthodes ......................................................................................................... Construction d’un objet ........................................................................................................... Surcharge ............................................................................................................................ Initialisation des champs par défaut ................................................................................... Constructeurs par défaut ..................................................................................................... Initialisation explicite de champ ......................................................................................... Noms de paramètres ........................................................................................................... Appel d’un autre constructeur ............................................................................................ Blocs d’initialisation ........................................................................................................... Destruction des objets et méthode finalize ......................................................................... Packages ................................................................................................................................... Importation des classes ....................................................................................................... Imports statiques ................................................................................................................. Ajout d’une classe dans un package ................................................................................... Visibilité dans un package .................................................................................................. Le chemin de classe .................................................................................................................. Définition du chemin de classe ........................................................................................... Commentaires pour la documentation ...................................................................................... Insertion des commentaires ................................................................................................ Commentaires de classe ...................................................................................................... Commentaires de méthode ................................................................................................. Commentaires de champ .................................................................................................... Commentaires généraux ..................................................................................................... Commentaires de package et d’ensemble ........................................................................... Extraction des commentaires .............................................................................................. Conseils pour la conception de classes ....................................................................................
141 141 144 150 150 151 151 152 153 153 154 158 158 159 161 161 164 165 168 168 169 169 170 171 171 172 172 173
Chapitre 5. L’héritage ................................................................................................................. Classes, superclasses et sous-classes ........................................................................................ Hiérarchie d’héritage .......................................................................................................... Polymorphisme ................................................................................................................... Liaison dynamique ............................................................................................................. Empêcher l’héritage : les classes et les méthodes final .................................................. Transtypage ......................................................................................................................... Classes abstraites ................................................................................................................ Accès protégé ..................................................................................................................... Object : la superclasse cosmique .............................................................................................. La méthode equals ........................................................................................................... Test d’égalité et héritage .....................................................................................................
177 178 184 185 186 189 190 192 197 198 198 199
Livre Java.book Page VII Mercredi, 13. février 2008 2:34 14
Table des matières
VII
La méthode hashCode ....................................................................................................... La méthode toString ....................................................................................................... Listes de tableaux génériques ................................................................................................... Accéder aux éléments d’une liste de tableaux .................................................................... Compatibilité entre les listes de tableaux brutes et typées ................................................. Enveloppes d’objets et autoboxing ........................................................................................... Méthodes ayant un nombre variable de paramètres ........................................................... Classes d’énumération .............................................................................................................. Réflexion .................................................................................................................................. La classe Class ................................................................................................................. Introduction à l’interception d’exceptions .......................................................................... La réflexion pour analyser les caractéristiques d’une classe .............................................. La réflexion pour l’analyse des objets à l’exécution .......................................................... La réflexion pour créer un tableau générique ..................................................................... Les pointeurs de méthodes ................................................................................................. Conseils pour l’utilisation de l’héritage ...................................................................................
202 204 210 212 216 217 220 221 223 224 226 227 232 237 240 244
Chapitre 6. Interfaces et classes internes ................................................................................ Interfaces .................................................................................................................................. Propriétés des interfaces ..................................................................................................... Interfaces et classes abstraites ............................................................................................ Clonage d’objets ....................................................................................................................... Interfaces et callbacks .............................................................................................................. Classes internes ........................................................................................................................ Accéder à l’état d’un objet à l’aide d’une classe interne .................................................... Règles particulières de syntaxe pour les classes internes ................................................... Utilité, nécessité et sécurité des classes internes ................................................................ Classes internes locales ...................................................................................................... Accès aux variables final à partir de méthodes externes ................................................. Classes internes anonymes ................................................................................................. Classes internes statiques .................................................................................................... Proxies ...................................................................................................................................... Propriétés des classes proxy ...............................................................................................
247 248 253 254 255 261 264 265 268 269 271 272 274 276 280 284
Chapitre 7. Programmation graphique .................................................................................... Introduction à Swing ................................................................................................................ Création d’un cadre .................................................................................................................. Positionnement d’un cadre ....................................................................................................... Propriétés des cadres .......................................................................................................... Déterminer une taille de cadre adéquate ............................................................................. Affichage des informations dans un composant .......................................................................
287 288 291 294 296 296 300
Livre Java.book Page VIII Mercredi, 13. février 2008 2:34 14
VIII
Table des matières
Formes 2D ................................................................................................................................ Couleurs ................................................................................................................................... Texte et polices ......................................................................................................................... Affichage d’images ..................................................................................................................
305 312 315 323
Chapitre 8. Gestion des événements ..........................................................................................
327
Introduction à la gestion des événements ................................................................................. Exemple : gestion d’un clic de bouton ............................................................................... Etre confortable avec les classes internes ........................................................................... Créer des écouteurs contenant un seul appel de méthode .................................................. Exemple : modification du "look and feel" ......................................................................... Classes adaptateurs ............................................................................................................. Actions ..................................................................................................................................... Evénements de la souris ..................................................................................................... Hiérarchie des événements AWT ............................................................................................. Evénements sémantiques et de bas niveau .........................................................................
327 330 334 337 337 341 344 352 359 361
Chapitre 9. Swing et les composants d’interface utilisateur ...................................................
365
Swing et l’architecture Modèle-Vue-Contrôleur ...................................................................... Modèles de conception ....................................................................................................... L’architecture Modèle-Vue-Contrôleur .............................................................................. Une analyse Modèle-Vue-Contrôleur des boutons Swing .................................................. Introduction à la gestion de mise en forme .............................................................................. Gestionnaire BorderLayout ................................................................................................ Disposition des grilles ........................................................................................................ Entrée de texte .......................................................................................................................... Champs de texte .................................................................................................................. Etiquettes et composants d’étiquetage ................................................................................ Champs de mot de passe ..................................................................................................... Zones de texte ..................................................................................................................... Volets de défilement ............................................................................................................ Composants du choix ............................................................................................................... Cases à cocher .................................................................................................................... Boutons radio ...................................................................................................................... Bordures ............................................................................................................................. Listes déroulantes ............................................................................................................... Curseurs .............................................................................................................................. Menus ....................................................................................................................................... Création d’un menu ............................................................................................................ Icônes et options de menu ..................................................................................................
366 366 367 370 372 374 376 380 380 382 383 384 385 387 387 390 394 398 402 408 408 410
Livre Java.book Page IX Mercredi, 13. février 2008 2:34 14
Table des matières
IX
Options de menu avec cases à cocher et boutons radio ...................................................... Menus contextuels .............................................................................................................. Caractères mnémoniques et raccourcis clavier ................................................................... Activation et désactivation des options de menu ................................................................ Barres d’outils .................................................................................................................... Bulles d’aide ....................................................................................................................... Mise en forme sophistiquée ...................................................................................................... Gestionnaire GridBagLayout .............................................................................................. GroupLayout ....................................................................................................................... Création sans gestionnaire de mise en forme ..................................................................... Gestionnaires de mise en forme personnalisés ................................................................... Séquence de tabulation ....................................................................................................... Boîtes de dialogue .................................................................................................................... Boîtes de dialogue d’options .............................................................................................. Création de boîtes de dialogue ............................................................................................ Echange de données ............................................................................................................ Boîtes de dialogue Fichier .................................................................................................. Sélecteurs de couleur ..........................................................................................................
411 412 414 416 420 422 425 427 436 445 446 450 451 452 461 466 472 483
Chapitre 10. Déployer des applets et des applications ............................................................. Les fichiers JAR ....................................................................................................................... Le manifeste ....................................................................................................................... Fichiers JAR exécutables .................................................................................................... Les ressources ..................................................................................................................... Verrouillage ........................................................................................................................ Java Web Start .......................................................................................................................... Le bac à sable ..................................................................................................................... Code signé .......................................................................................................................... L’API JNLP ....................................................................................................................... Les applets ................................................................................................................................ Un petit applet .................................................................................................................... Conversion d’une application en applet .............................................................................. Balises HTML et attributs pour applets .............................................................................. La balise object ................................................................................................................... Passer des informations à un applet avec des paramètres ................................................... Accéder aux images et fichiers audio ................................................................................. Le contexte d’applet ........................................................................................................... La communication interapplets .......................................................................................... Faire afficher des informations par le navigateur ............................................................... C’est un applet et c’est aussi une application ! ...................................................................
491 492 493 494 495 498 498 502 503 505 513 514 517 518 521 521 526 528 528 528 530
Livre Java.book Page X Mercredi, 13. février 2008 2:34 14
X
Table des matières
Stockage des préférences d’applications .................................................................................. Concordances de propriétés ................................................................................................ L’API Preferences ..............................................................................................................
535 536 540
Chapitre 11. Exceptions, consignation, assertion et mise au point ......................................... Le traitement des erreurs .......................................................................................................... Le classement des exceptions ............................................................................................. Signaler les exceptions sous contrôle ................................................................................. Comment lancer une exception .......................................................................................... Créer des classes d’exception ............................................................................................. Capturer les exceptions ............................................................................................................ Capturer des exceptions multiples ...................................................................................... Relancer et enchaîner les exceptions .................................................................................. La clause finally .................................................................................................................. Analyser les traces de piles ................................................................................................. Quelques conseils sur l’utilisation des exceptions ................................................................... Les assertions ........................................................................................................................... Activation et désactivation des assertions ........................................................................... Vérification des paramètres avec des assertions ................................................................. Utiliser des assertions pour documenter des hypothèses .................................................... La consignation ........................................................................................................................ Consignation de base .......................................................................................................... Consignation avancée ......................................................................................................... Modifier la configuration du gestionnaire de journaux ...................................................... La localisation .................................................................................................................... Les gestionnaires ................................................................................................................ Les filtres ............................................................................................................................ Les formateurs .................................................................................................................... Une astuce de consignation ................................................................................................ Les techniques de mise au point ............................................................................................... Utiliser une fenêtre de console ........................................................................................... Tracer les événements AWT ............................................................................................... Le robot AWT ..................................................................................................................... Utiliser un débogueur ...............................................................................................................
547 548 549 551 553 554 555 557 557 558 561 564 567 568 568 569 570 571 571 574 575 576 579 579 580 587 593 595 598 602
Chapitre 12. Programmation générique ................................................................................... Pourquoi la programmation générique ? .................................................................................. Y a-t-il un programmeur générique dans la salle ? ............................................................. Définition d’une classe générique simple ................................................................................. Méthodes génériques ................................................................................................................ Limites pour variables de type .................................................................................................
607 608 609 610 612 613
Livre Java.book Page XI Mercredi, 13. février 2008 2:34 14
Table des matières
XI
Code générique et machine virtuelle ........................................................................................ Traduire les expressions génériques ................................................................................... Traduire les méthodes génériques ...................................................................................... Appeler un code existant .................................................................................................... Restrictions et limites ............................................................................................................... Les paramètres de type ne peuvent pas être instanciés avec les types primitifs ................. Les informations sur le type d’exécution ne fonctionnent qu’avec les types bruts ............ Vous ne pouvez pas lancer ou intercepter des instances d’une classe générique ............... Les tableaux de types avec paramètres ne sont pas autorisés ............................................. Vous ne pouvez pas instancier des variables de type .......................................................... Les variables de type ne sont pas valables dans des contextes statiques des classes génériques ........................................................................................................ Attention aux conflits après un effacement ........................................................................ Règles d’héritage pour les types génériques ............................................................................ Types joker ............................................................................................................................... Limites de supertypes pour les jokers ................................................................................. Jokers sans limites .............................................................................................................. Capture de caractères joker ................................................................................................. Réflexion et générique .............................................................................................................. Utilisation des paramètres Class pour la concordance de type ................................... Informations de type générique dans la machine virtuelle .................................................
615 616 617 619 620 620 620 621 622 622
Chapitre 13. Collections ............................................................................................................. Les interfaces de collection ...................................................................................................... Séparer les interfaces d’une collection et leur implémentation .......................................... Interfaces de collection et d’itération dans la bibliothèque Java ........................................ Suppression d’éléments ...................................................................................................... Méthodes utilitaires génériques .......................................................................................... Les collections concrètes .......................................................................................................... Listes chaînées .................................................................................................................... Listes de tableaux ............................................................................................................... Tables de hachage ............................................................................................................... Arbres ................................................................................................................................. Queues et deques ................................................................................................................ Queues de priorité ............................................................................................................... Cartes .................................................................................................................................. Classes de cartes et de set spécialisées ............................................................................... La structure des collections ...................................................................................................... Les vues et les emballages .................................................................................................. Les opérations de masse ..................................................................................................... Conversion entre collections et tableaux ............................................................................
643 643 644 646 649 649 651 652 660 661 664 670 671 673 677 681 685 691 692
624 624 625 627 628 630 631 634 635 636
Livre Java.book Page XII Mercredi, 13. février 2008 2:34 14
XII
Table des matières
Algorithmes .............................................................................................................................. Trier et mélanger ................................................................................................................. Recherche binaire ............................................................................................................... Algorithmes simples ........................................................................................................... Ecrire vos propres algorithmes ........................................................................................... Les anciennes collections ......................................................................................................... La classe Hashtable ............................................................................................................ Les énumérations ................................................................................................................ Cartes de propriétés ............................................................................................................ Piles .................................................................................................................................... Les ensembles de bits .........................................................................................................
693 694 696 698 699 700 700 701 702 702 703
Chapitre 14. Multithreads .......................................................................................................... Qu’est-ce qu’un thread ? .......................................................................................................... Utiliser des threads pour laisser une chance aux autres tâches ........................................... Interrompre des threads ............................................................................................................ Les états d’un thread ........................................................................................................... Threads terminés ................................................................................................................. Propriétés d’un thread .............................................................................................................. Priorités d’un thread ........................................................................................................... Threads démons .................................................................................................................. Gestionnaire d’exceptions non récupérées ......................................................................... Synchronisation ........................................................................................................................ Exemple de condition de course ......................................................................................... Explication des conditions de course ................................................................................. Verrous d’objet ................................................................................................................... Objets de condition ............................................................................................................. Le mot clé synchronized ..................................................................................................... Blocs synchronisés ............................................................................................................. Le concept des moniteurs ................................................................................................... Champs volatiles ................................................................................................................. Verrous morts ...................................................................................................................... Test de verrous et temporisations ....................................................................................... Lire et écrire des verrous .................................................................................................... Pourquoi les méthodes stop et suspend ne sont plus utilisées .................................................. Queues de blocage .................................................................................................................... Collections compatibles avec les threads ................................................................................. Cartes, jeux et queues efficaces .......................................................................................... CopyOnWriteArray ........................................................................................................... Anciennes collections compatibles avec les threads .......................................................... Callable et Future .....................................................................................................................
707 708 713 718 721 722 724 724 725 725 727 727 731 732 735 740 743 745 745 747 750 751 752 754 760 761 762 763 764
Livre Java.book Page XIII Mercredi, 13. février 2008 2:34 14
Table des matières
XIII
Executors .................................................................................................................................. Pools de threads .................................................................................................................. Exécution programmée ....................................................................................................... Contrôle de groupes de tâches ............................................................................................ Synchronizers ........................................................................................................................... Sémaphores ......................................................................................................................... Verrous Countdown ............................................................................................................ Barrières ............................................................................................................................. Exchanger ........................................................................................................................... Queues synchrones ............................................................................................................. Exemple : pause et reprise d’une animation ....................................................................... Threads et Swing ................................................................................................................ Exécution de tâches longues ............................................................................................... Utilisation du travailleur Swing .......................................................................................... La règle du thread unique ...................................................................................................
768 769 772 773 774 775 776 776 777 777 777 783 784 788 795
Annexe. Les mots clés de Java ...................................................................................................
797
Index ..............................................................................................................................................
801
Livre Java.book Page XIV Mercredi, 13. février 2008 2:34 14
Livre Java.book Page 1 Mercredi, 13. février 2008 2:34 14
Introduction Avertissement au lecteur Vers la fin de 1995, le langage de programmation Java surgit sur la grande scène d’Internet et obtint immédiatement un énorme succès. La prétention de Java est de constituer la colle universelle capable de connecter les utilisateurs aux informations, que celles-ci proviennent de serveurs Web, de bases de données, de fournisseurs d’informations ou de toute autre source imaginable. Et Java se trouve en bonne position pour relever ce défi. Il s’agit d’un langage de conception très robuste qui a été adopté par la majorité des principaux fournisseurs, à l’exception de Microsoft. Ses caractéristiques intégrées de sécurité offrent un sentiment de confiance aux programmeurs comme aux utilisateurs des applications. De plus, Java intègre des fonctionnalités qui facilitent grandement certaines tâches de programmation avancées, comme la gestion réseaux, la connectivité bases de données ou le développement d’applications multitâches. Depuis le lancement de Java, Sun Microsystems a émis sept révisions majeures du kit de développement Java. Au cours des onze dernières années, l’API (interface de programmation d’application) est passée de 200 à plus de 3 000 classes. Elle traite maintenant des domaines aussi divers que la construction de l’interface utilisateur, la gestion des bases de données, l’internationalisation, la sécurité et le traitement du code XML. L’ouvrage que vous tenez entre les mains est le premier volume de la huitième édition de Au cœur de Java. Chaque édition a suivi la sortie du kit de développement d’aussi près que possible et, chaque fois, nous avons réécrit le livre pour y inclure les toutes dernières fonctionnalités. Cette édition a été mise à jour pour traiter des nouveautés de Java Standard Edition (SE) 6. Ce livre, comme les éditions précédentes, s’adresse essentiellement aux programmeurs professionnels désireux d’utiliser Java pour développer de véritables projets. Nous considérons que le lecteur possède déjà une solide habitude de la programmation autre que Java et qu’il fuit les ouvrages qui fourmillent d’exemples dépourvus d’utilité pratique (comme les grille-pain, les animaux du zoo ou le "texte nerveux"). Vous n’en trouverez pas ici. Notre objectif est de vous permettre d’appréhender le langage et la bibliothèque Java, et non de vous donner l’illusion que vous les comprenez. Vous trouverez de nombreux programmes de démonstration qui abordent la plupart des sujets traités dans cet ouvrage. Ces programmes sont volontairement simples afin que le lecteur puisse se concentrer sur les points importants. Néanmoins, dans la plupart des cas, il s’agit d’applications utiles qui pourront vous servir de base pour le développement de vos propres projets. Nous supposons également que vous souhaitez apprendre les caractéristiques avancées de Java ; c’est pourquoi nous étudierons en détail : m
la programmation orientée objet ;
m
le mécanisme de réflexion de Java et de proxy ;
m
les interfaces et classes internes ;
Livre Java.book Page 2 Mercredi, 13. février 2008 2:34 14
2
Au cœur de Java 2 - Notions fondamentales
m
le modèle d’écouteur d’événement ;
m
la conception d’interfaces graphiques avec la boîte à outils Swing ;
m
la gestion des exceptions ;
m
la programmation générique ;
m
le cadre des collections ;
m
la simultanéité.
Enfin, compte tenu de l’explosion de la bibliothèque de classes de Java, nous avons dû répartir l’étude de toutes les fonctionnalités sur deux volumes. Le premier, que vous avez en main, se concentre sur les concepts fondamentaux du langage Java, ainsi que sur les bases de la programmation d’une interface graphique. Le second volume traite plus exhaustivement des fonctionnalités d’entreprise et de la programmation avancée des interfaces utilisateur. Il aborde les sujets suivants : m
les fichiers et les flux ;
m
les objets distribués ;
m
les bases de données ;
m
les composants GUI avancés ;
m
les méthodes natives ;
m
le traitement XML ;
m
la programmation réseau ;
m
le graphisme avancé ;
m
l’internationalisation ;
m
JavaBeans ;
m
les annotations.
Pour cette édition, nous avons réorganisé le contenu des deux volumes. Le multithread, notamment, est traité dans le Volume I, car il est devenu très important, la loi de Moore étant désormais obsolète. Lors de la rédaction d’un ouvrage comme celui-ci, il est inévitable de commettre des erreurs et des inexactitudes. Nous avons donc préparé sur le site Web http://horstmann.com/corejava une liste de questions courantes, de corrections et d’explications. Un formulaire permettant de signaler des bogues et de suggérer des améliorations est placé stratégiquement à la fin de la page des corrections (pour vous encourager à la lire). Ne soyez pas déçu si nous ne répondons pas à chaque requête ou si nous ne vous écrivons pas rapidement. Nous lisons tous les e-mails et apprécions vos commentaires, qui nous permettent d’améliorer les futures versions de cet ouvrage.
A propos de ce livre Le Chapitre 1 présentera les caractéristiques de Java qui le distinguent des autres langages de programmation. Nous expliquerons les intentions des concepteurs du langage et nous montrerons dans quelle mesure ils sont parvenus à leurs fins. Nous terminerons par un historique de Java et nous préciserons la manière dont il a évolué.
Livre Java.book Page 3 Mercredi, 13. février 2008 2:34 14
Introduction
3
Le Chapitre 2 vous indiquera comment télécharger et installer le JDK et les exemples de programme du livre. Nous vous guiderons ensuite dans la compilation et l’exécution de trois programmes Java typiques : une application console, une application graphique et un applet, grâce à du JDK brut, un éditeur de texte activé pour Java et un IDE Java. Nous entamerons au Chapitre 3 une étude approfondie du langage, en commençant par les éléments de base : les variables, les boucles et les fonctions simples. Si vous êtes un programmeur C ou C++, tout cela ne vous posera pas de problème, car la syntaxe employée est comparable à celle de C. Si vous avez une autre formation, par exemple en Visual Basic, nous vous conseillons de lire attentivement ce chapitre. La programmation orientée objet (POO) est maintenant au cœur des méthodes modernes de programmation et Java est un langage orienté objet. Le Chapitre 4 présentera l’encapsulation — la première des deux notions fondamentales de l’orientation objet — et le mécanisme du langage Java qui permet de l’implémenter, c’est-à-dire les classes et les méthodes. En plus des règles de Java, nous vous proposerons des conseils pour une bonne conception orientée objet. Nous aborderons ensuite le merveilleux outil javadoc qui permet de transformer les commentaires de votre code en une documentation au format HTML. Si vous êtes un habitué du C++, vous pourrez vous contenter de parcourir rapidement ce chapitre. Les programmeurs qui ne sont pas familiarisés avec la programmation orientée objet doivent se donner le temps d’étudier ces concepts avant de poursuivre leur exploration de Java. Les classes et l’encapsulation ne constituent qu’une partie du concept de POO et le Chapitre 5 introduira l’autre élément essentiel : l’héritage. Celui-ci permet de récupérer une classe existante et de la modifier selon vos besoins. Il s’agit là d’une technique fondamentale de la programmation Java. Le mécanisme d’héritage de Java est comparable à celui de C++. Ici encore, les programmeurs C++ pourront se concentrer uniquement sur les différences entre les deux langages. Le Chapitre 6 vous montrera comment utiliser la notion d’interface. Les interfaces permettent de dépasser le modèle d’héritage simple vu au Chapitre 5. En maîtrisant les interfaces, vous pourrez profiter pleinement de l’approche orientée objet de la programmation Java. Nous traiterons également dans ce chapitre une caractéristique technique très utile de Java, appelée classe interne. Les classes internes permettent d’obtenir des programmes plus propres et plus concis. Au Chapitre 7, nous commencerons véritablement la programmation d’applications. Tout programmeur en Java doit connaître un minimum de programmation de GUI, des bases que vous trouverez dans ce volume. Nous vous montrerons comment créer des fenêtres, y dessiner et y tracer des figures géométriques, formater du texte avec différentes polices et afficher des images. Le Chapitre 8 sera consacré à une étude détaillée du modèle d’événement AWT, la boîte à outils de fenêtre abstraite. Nous verrons comment écrire le code permettant de répondre à des événements tels que des clics de la souris ou des frappes de touches. Vous verrez par la même occasion comment gérer des éléments de l’interface utilisateur graphique comme les boutons ou les panneaux. Le Chapitre 9 examinera de manière approfondie l’outil Swing, qui permet de créer des interfaces graphiques multi-plates-formes. Vous apprendrez tout ce qu’il faut savoir sur les différents types de boutons, les composants de saisie, les bordures, les barres de défilement, les zones de listes, les menus et les boîtes de dialogue. Certains de ces composants, plus avancés, seront étudiés dans le Volume II. Le Chapitre 10 indique comment déployer des programmes, sous forme d’applications ou d’applets. Nous expliquons comment emballer des programmes dans les fichiers JAR et livrer des applications
Livre Java.book Page 4 Mercredi, 13. février 2008 2:34 14
4
Au cœur de Java 2 - Notions fondamentales
sur Internet avec Java Web Start et les mécanismes d’applet. Enfin, nous verrons la manière dont les programmes Java peuvent stocker et récupérer des informations de configuration lorsqu’ils ont été déployés. Le Chapitre 11 traitera de la gestion des exceptions, un mécanisme robuste qui s’appuie sur le fait que même les bons programmes peuvent subir des dommages. Les exceptions fournissent un moyen efficace de séparer le code normal de traitement et la gestion d’erreurs. Bien entendu, même si vous avez sécurisé votre programme en gérant toutes les conditions exceptionnelles, il n’est pas certain qu’il fonctionne parfaitement. La seconde partie de ce chapitre vous donnera quelques astuces de débogage. Pour terminer, nous vous accompagnerons dans une session de débogage. Le Chapitre 12 donne une vue d’ensemble de la programmation générique, une avancée majeure de Java SE 5.0. Elle facilite la lecture de vos programmes, tout en les sécurisant. Nous vous montrerons comment utiliser des types forts et comment traiter les complexités liées aux transtypages peu sûrs, mais aussi comment gérer les complexités naissant du besoin de compatibilité avec les anciennes versions de Java. Le Chapitre 13 traitera des cadres de collections de la plate-forme Java. Lorsque vous souhaiterez collecter plusieurs objets pour les récupérer plus tard, vous utiliserez une collection adaptée à votre situation, au lieu de simplement faire entrer les éléments dans un tableau. Ce chapitre indique comment profiter des collections standard déjà créées pour vous. Le Chapitre 14 clôturera ce livre avec une discussion sur le multithreading, qui permet de programmer des tâches à réaliser en parallèle (un thread est un flux de contrôle dans un programme). Nous vous indiquerons comment configurer les threads et en gérer la synchronisation. Le multithreading a beaucoup évolué dans Java SE 5.0 et nous vous en montrerons les nouveaux mécanismes. L’Annexe est consacrée aux mots clés du langage Java.
Conventions Comme c’est l’usage dans la plupart des ouvrages d’informatique, nous employons la police Courier pour le code des programmes. INFO ASTUCE Les infos et les astuces sont repérées par une de ces deux icônes.
ATTENTION Une icône "Attention" vous prévient s’il y a du danger à l’horizon.
INFO C++ De nombreuses notes d’info C++ précisent les différences entre Java et C++. Vous pouvez ignorer ces notes si vous n’êtes pas familiarisé avec ce langage.
Livre Java.book Page 5 Mercredi, 13. février 2008 2:34 14
Introduction
5
API Java
Java est accompagné d’une importante bibliothèque de programmation (API, Application Programming Interface). Lorsque nous utilisons pour la première fois un appel à l’API, nous proposons également une brève description dans une note "API" située à la fin de la section. Ces descriptions sont un peu plus informelles que celles de la documentation officielle en ligne, mais nous espérons qu’elles sont plus instructives. Les programmes dont le code source se trouve sur le Web sont fournis sous forme de listings, comme ceci : Listing 2.4 : WelcomeApplet.java
Exemples de code Vous trouverez sur le site des éditions Pearson Education (www.pearsoneducation.fr) tous les exemples du livre, sous forme compressée. Ils peuvent être décompressés avec un des outils courants du marché ou avec l’utilitaire jar du kit JDK. Reportez-vous au Chapitre 2 pour en savoir plus sur l’installation du JDK et des listings d’exemple.
Livre Java.book Page 6 Mercredi, 13. février 2008 2:34 14
Livre Java.book Page 7 Mercredi, 13. février 2008 2:34 14
1 Une introduction à Java Au sommaire de ce chapitre
✔ Java, plate-forme de programmation ✔ Les termes clés du livre blanc de Java ✔ Les applets Java et Internet ✔ Bref historique de Java ✔ Les idées fausses les plus répandues concernant Java La première version de Java, sortie en 1996, a fait naître beaucoup de passions, pas seulement au niveau de la presse informatique, mais également dans la presse plus généraliste comme The New York Times, The Washington Post et Business Week. Java présente l’avantage d’être le premier et le seul langage de programmation dont l’histoire est contée à la radio. Il est plutôt amusant de revisiter cette époque pionnière, nous vous présenterons donc un bref historique de Java dans ce chapitre.
Java, plate-forme de programmation Dans la première édition de cet ouvrage, nous avons dû écrire ceci : "La réputation de Java en tant que langage informatique est exagérée : Java est assurément un bon langage de programmation. Il s’agit, sans aucun doute, de l’un des meilleurs disponibles pour un programmeur sérieux. Java aurait, potentiellement, pu être un grand langage de programmation, mais il est probablement trop tard pour cela. Lorsqu’un langage commence à être exploité, se pose le problème de la compatibilité avec le code existant." Un haut responsable de Sun Microsystems, que nous ne nommerons pas, a adressé à notre éditeur de nombreux commentaires sur ce paragraphe. Mais, avec le temps, notre pronostic semble s’avérer. Java présente de très bonnes fonctionnalités (nous les verrons en détail plus loin dans ce chapitre). Il a pourtant sa part d’inconvénients, et les derniers ajouts ne sont pas aussi agréables que les premiers, et ce pour des raisons de compatibilité. Toutefois, comme nous le disions dans la première édition, Java n’a jamais été qu’un langage. Même s’il en existe à foison, peu font beaucoup d’éclats. Java est une plate-forme complète, disposant
Livre Java.book Page 8 Mercredi, 13. février 2008 2:34 14
8
Au cœur de Java 2 - Notions fondamentales
d’une importante bibliothèque, d’une grande quantité de code réutilisable et d’un environnement d’exécution qui propose des services tels que la sécurité, la portabilité sur les systèmes d’exploitation et le ramasse-miettes automatique. En tant que programmeur, vous voulez un langage à la syntaxe agréable et à la sémantique compréhensible (donc, pas de C++). Java répond à ces critères, comme des dizaines d’autres langages. Certains vous proposent la portabilité, le ramasse-miettes et des outils du même genre, mais ils ne disposent pas de vraie bibliothèque, ce qui vous oblige à déployer la vôtre si vous souhaitez utiliser de beaux graphiques, le réseau ou l’accès aux bases de données. Java regroupe tout cela : un langage de qualité, un environnement d’exécution idoine et une grande bibliothèque. C’est cette combinaison qui fait de Java une proposition à laquelle de nombreux programmeurs ne résistent pas.
Les termes clés du livre blanc de Java Les auteurs de Java ont écrit un important livre blanc qui présente les objectifs et les réalisations de leur conception. Ce livre s’articule autour des onze termes clés suivants : Simplicité
Portabilité
Orienté objet
Interprété
Compatible avec les réseaux
Performances élevées
Fiabilité
Multithread
Sécurité
Dynamique
Architecture neutre
Dans la suite de ce chapitre, nous allons : m
résumer, par l’intermédiaire d’extraits du livre blanc, ce que les concepteurs de Java ont voulu traduire avec chacun de ces termes clés ;
m
exprimer ce que nous pensons de chaque terme, à partir de notre expérience de la version actuelle de Java. INFO
A l’heure où nous écrivons ces lignes, le livre blanc est disponible à l’adresse suivante : http://java.sun.com/docs/ white/langenv/. Le résumé des onze mots clés figure à l’adresse http://java.sun.com/docs/overviews/java/javaoverview-1.html.
Simplicité *
Nous avons voulu créer un système qui puisse être programmé simplement, sans nécessiter un apprentissage ésotérique, et qui tire parti de l’expérience standard actuelle. En conséquence, même si nous pensions que C++ ne convenait pas, Java a été conçu de façon relativement proche de ce langage dans le dessein de faciliter la compréhension du système. De nombreuses fonctions compliquées, mal comprises, rarement utilisées, de C++, qui nous semblaient par expérience apporter plus d’inconvénients que d’avantages, ont été supprimées de Java.
Livre Java.book Page 9 Mercredi, 13. février 2008 2:34 14
Chapitre 1
Une introduction à Java
9
La syntaxe de Java représente réellement une version améliorée de C++. Les fichiers d’en-tête, l’arithmétique des pointeurs (ou même une syntaxe de pointeur), les structures, les unions, la surcharge d’opérateur, les classes de base virtuelles, etc., ne sont plus nécessaires (tout au long de cet ouvrage, nous avons inclus des notes Info C++ décrivant plus précisément les différences entre Java et C++). Les concepteurs n’ont cependant pas tenté de modifier certaines fonctions pièges de C++ telles que l’instruction switch. Si vous connaissez C++, le passage à la syntaxe de Java vous semblera facile. Si vous êtes habitué à un environnement de programmation visuel (tel que Visual Basic), le langage Java vous paraîtra plus complexe. Une partie de la syntaxe vous semblera étrange (même si sa maîtrise est rapide). Plus important encore, la programmation en Java nécessitera davantage de travail. L’intérêt de Visual Basic réside dans le fait que son environnement visuel de conception fournit de façon presque automatique une grande partie de l’infrastructure d’une application. En Java, la fonctionnalité équivalente doit être programmée manuellement, généralement à l’aide d’une quantité respectable de code. Il existe cependant des environnements de développement tiers qui permettent l’écriture de programmes à l’aide d’opérations "glisser-déplacer". *
Un autre avantage de sa simplicité est sa petite taille. L’un des buts de Java est de permettre à des logiciels de s’exécuter intégralement sur de modestes machines. Ainsi, la taille cumulée de l’interpréteur de base et du support des classes est d’environ 40 Ko ; pour supporter les classes standard ainsi que la gestion multitraitement (threads), il faut ajouter 175 Ko.
C’est un exploit. Toutefois, sachez que la taille de la bibliothèque a atteint des proportions considérables. Il existe maintenant une Java Micro Edition séparée, avec une bibliothèque plus petite, convenant aux périphériques intégrés.
Orienté objet *
Pour rester simples, disons que la conception orientée objet est une technique de programmation qui se concentre sur les données (les objets) et sur les interfaces avec ces objets. Pour faire une analogie avec la menuiserie, on pourrait dire qu’un menuisier "orienté objet" s’intéresse essentiellement à la chaise (l’objet) qu’il fabrique et ensuite aux outils utilisés pour la fabriquer. Par opposition, le menuisier "non orienté objet" penserait d’abord à ses outils. Les facilités orientées objet de Java sont essentiellement celles de C++...
Au cours des trente dernières années, la programmation orientée objet a prouvé ses avantages, et il est inconcevable qu’un langage de programmation moderne n’en tire pas parti. En fait, les fonctionnalités orientées objet de Java sont comparables à celles de C++. Les différences majeures résident dans l’héritage multiple (que Java a remplacé par le concept plus simple des interfaces) et le modèle objet de Java (métaclasses), que nous verrons au Chapitre 5. INFO Si vous n’avez aucune expérience des langages de programmation orientée objet, prenez soin de lire attentivement les Chapitres 4 à 6. Ils vous expliquent ce qu’est la programmation orientée objet et pour quelles raisons elle est plus utile à la programmation de projets sophistiqués que ne le sont les langages procéduraux comme C ou Basic.
Livre Java.book Page 10 Mercredi, 13. février 2008 2:34 14
10
Au cœur de Java 2 - Notions fondamentales
Compatible avec les réseaux *
Java possède une importante bibliothèque de routines permettant de gérer les protocoles TCP/IP tels que HTTP et FTP. Les applications Java peuvent charger des objets sur Internet et y accéder via des URL avec la même facilité qu’elles accèdent à un fichier local sur le système.
Nous avons trouvé que les fonctionnalités réseau de Java étaient à la fois fiables et d’utilisation aisée. Toute personne ayant essayé de faire de la programmation pour Internet avec un autre langage se réjouira de la simplicité de Java lorsqu’il s’agit de mettre en œuvre des tâches lourdes, comme l’ouverture d’une connexion avec une socket (nous verrons les réseaux dans le Volume II de cet ouvrage). Le mécanisme d’invocation de méthode à distance (RMI) autorise la communication entre objets distribués (voir également le Volume II).
Fiabilité *
Java a été conçu pour que les programmes qui l’utilisent soient fiables sous différents aspects. Sa conception encourage le programmeur à traquer préventivement les éventuels problèmes, à lancer des vérifications dynamiques en cours d’exécution et à éliminer les situations génératrices d’erreurs... La seule et unique grosse différence entre C/C++ et Java réside dans le fait que ce dernier intègre un modèle de pointeur qui écarte les risques d’écrasement de la mémoire et d’endommagement des données.
Voilà encore une caractéristique fort utile. Le compilateur Java détecte de nombreux problèmes qui, dans d’autres langages, ne sont visibles qu’au moment de l’exécution. Tous les programmeurs qui ont passé des heures à récupérer une mémoire corrompue par un bogue de pointeur seront très heureux d’exploiter cette caractéristique de Java. Si vous connaissez déjà des langages comme Visual Basic, qui n’exploitent pas les pointeurs de façon explicite, vous vous demandez sûrement pourquoi ce problème est si important. Les programmeurs en C n’ont pas cette chance. Ils ont besoin des pointeurs pour accéder à des chaînes, à des tableaux, à des objets et même à des fichiers. Dans Visual Basic, vous n’employez de pointeur pour aucune de ces entités, pas plus que vous n’avez besoin de vous soucier de leurs allocations en mémoire. En revanche, certaines structures de données sont difficiles à implémenter sans l’aide de pointeurs. Java vous donne le meilleur des deux mondes. Vous n’avez pas besoin des pointeurs pour les constructions habituelles, comme les chaînes et les tableaux. Vous disposez de la puissance des pointeurs en cas de nécessité, par exemple, pour construire des listes chaînées. Et cela en toute sécurité dans la mesure où vous ne pouvez jamais accéder à un mauvais pointeur ni faire des erreurs d’allocation de mémoire, pas plus qu’il n’est nécessaire de vous protéger des "fuites" de mémoire.
Sécurité *
Java a été conçu pour être exploité dans des environnements serveur et distribués. Dans ce but, la sécurité n’a pas été négligée. Java permet la construction de systèmes inaltérables et sans virus.
Dans la première édition, nous déclarions : "Il ne faut jamais dire fontaine je ne boirai plus de ton eau." Et nous avions raison. Peu après la publication de la première version du JDK, un groupe d’experts de la sécurité de l’université de Princeton a localisé les premiers bogues des caractéristiques de sécurité de Java 1.0. Sun Microsystems a encouragé la recherche sur la sécurité de Java, en
Livre Java.book Page 11 Mercredi, 13. février 2008 2:34 14
Chapitre 1
Une introduction à Java
11
rendant publiques les caractéristiques et l’implémentation de la machine virtuelle et des bibliothèques de sécurité. Il a réparé rapidement tous les bogues connus. Quoi qu’il en soit, Java se charge de rendre particulièrement difficile le contournement des mécanismes de sécurité. Jusqu’à présent, les bogues qui ont été localisés étaient très subtils et relativement peu nombreux. Dès le départ, Java a été conçu pour rendre impossibles certains types d’attaques et, parmi eux : m
la surcharge de la pile d’exécution, une attaque commune des vers et des virus ;
m
l’endommagement de la mémoire située à l’extérieur de son propre espace de traitement ;
m
la lecture ou l’écriture des fichiers sans autorisation.
Avec le temps, un certain nombre de fonctionnalités relatives à la sécurité ont été ajoutées à Java. Depuis la version 1.1, Java intègre la notion de classe signée numériquement (voir Au cœur de Java 2 Volume II, éditions CampusPress), qui vous permet de savoir qui l’a écrite. Votre degré de confiance envers son auteur va déterminer l’ampleur des privilèges que vous allez accorder à la classe sur votre machine. INFO Le mécanisme concurrent de mise à disposition de code, élaboré par Microsoft et fondé sur sa technologie ActiveX, emploie exclusivement les signatures numériques pour assurer la sécurité. Bien évidemment, cela n’est pas suffisant. Tous les utilisateurs des produits Microsoft peuvent confirmer que les programmes proposés par des concepteurs bien connus rencontrent des défaillances qui provoquent des dégâts. Le modèle de sécurité de Java est nettement plus puissant que celui d’ActiveX dans la mesure où il contrôle l’application en cours d’exécution et l’empêche de faire des ravages.
Architecture neutre *
Le compilateur génère un format de fichier objet dont l’architecture est neutre — le code compilé est exécutable sur de nombreux processeurs, à partir du moment où le système d’exécution de Java est présent. Pour ce faire, le compilateur Java génère des instructions en bytecode (ou pseudo-code) qui n’ont de lien avec aucune architecture d’ordinateur particulière. Au contraire, ces instructions ont été conçues pour être à la fois faciles à interpréter, quelle que soit la machine, et faciles à traduire à la volée en code machine natif.
L’idée n’est pas nouvelle. Il y a plus de trente ans, la mise en œuvre originale de Pascal par Niklaus Wirth et le système Pascal UCSD utilisaient tous deux la même approche. Bien entendu, l’interprétation des bytecodes est forcément plus lente que l’exécution des instructions machine à pleine vitesse. On peut donc douter de la pertinence de cette idée. Toutefois, les machines virtuelles ont le choix de traduire les séquences de bytecode fréquemment utilisées en code machine, une procédure appelée compilation en "juste-à-temps" (just-in-time ou JIT). Cette stratégie s’est révélée tellement efficace que la plate-forme .NET de Microsoft va jusqu’à reposer sur une machine virtuelle. La machine virtuelle présente d’autres avantages. Elle accroît la sécurité car elle est en mesure de vérifier le comportement des suites d’instructions. Certains programmes vont jusqu’à produire des bytecodes à la volée, en améliorant dynamiquement les capacités d’un programme en cours d’exécution.
Livre Java.book Page 12 Mercredi, 13. février 2008 2:34 14
12
Au cœur de Java 2 - Notions fondamentales
Portabilité *
A la différence de C et de C++, on ne trouve pas les aspects de dépendance de la mise en œuvre dans la spécification. Les tailles des types de données primaires sont spécifiées, ainsi que le comportement arithmétique qui leur est applicable.
Par exemple, en Java, un int est toujours un entier en 32 bits. Dans C/C++, int peut représenter un entier 16 bits, un entier 32 bits ou toute autre taille décidée par le concepteur du compilateur. La seule restriction est que le type int doit contenir au moins autant d’octets qu’un short int et ne peut pas en contenir plus qu’un long int. Le principe d’une taille fixe pour les types numériques élimine les principaux soucis du portage d’applications. Les données binaires sont stockées et transmises dans un format fixe, ce qui met fin à la confusion sur l’ordre des octets. Les chaînes sont enregistrées au format Unicode standard. *
Les bibliothèques intégrées au système définissent des interfaces portables. Par exemple, il existe une classe Window abstraite, accompagnée de ses mises en œuvre pour UNIX, Windows et Macintosh.
Tous ceux qui ont essayé savent que l’élaboration d’un programme compatible avec Windows, Macintosh et dix versions d’UNIX, représente un effort héroïque. Java 1.0 a accompli cet effort en proposant un kit d’outils simples sachant "coller" aux principaux composants d’interface utilisateur d’un grand nombre de plates-formes. Malheureusement, le résultat était une bibliothèque qui donnait, avec beaucoup de travail, des programmes à peine acceptables sur différents systèmes. En outre, on rencontrait souvent des bogues différents sur les différentes implémentations graphiques. Mais ce n’était qu’un début. Il existe de nombreuses applications pour lesquelles la portabilité est plus importante que l’efficacité de l’interface utilisateur, et ce sont celles qui ont bénéficié des premières versions de Java. Aujourd’hui, le kit d’outils de l’interface utilisateur a été entièrement réécrit de manière à ne plus dépendre de l’interface utilisateur de l’hôte. Le résultat est nettement plus cohérent et nous pensons qu’il est beaucoup plus intéressant que dans les précédentes versions de Java.
Interprété *
L’interpréteur de Java peut exécuter les bytecodes directement sur n’importe quelle machine sur laquelle il a été porté. Dans la mesure où la liaison est un processus plus incrémentiel et léger, le processus de développement peut se révéler plus rapide et exploratoire.
La liaison incrémentielle présente des avantages, mais ils ont été largement exagérés. Quoi qu’il en soit, nous avons trouvé les outils de développement relativement lents. Aujourd’hui, les bytecodes sont traduits en code machine par le compilateur en juste-à-temps.
Performances élevées *
En règle générale, les performances des bytecodes interprétés sont tout à fait suffisantes ; il existe toutefois des situations dans lesquelles des performances plus élevées sont nécessaires. Les bytecodes peuvent être traduits à la volée (en cours d’exécution) en code machine pour l’unité centrale destinée à accueillir l’application.
Aux premiers temps de Java, de nombreux utilisateurs rejetaient la formule "performances élevées". Il existe toutefois aujourd’hui des compilateurs JIT (just-in-time, juste-à-temps) d’une qualité telle
Livre Java.book Page 13 Mercredi, 13. février 2008 2:34 14
Chapitre 1
Une introduction à Java
13
qu’ils concurrencent les compilateurs traditionnels et, dans certains cas, les dépassent du fait qu’ils disposent de davantage d’informations. Par exemple, un compilateur JIT est capable d’identifier du code souvent exécuté et d’optimiser exclusivement la vitesse de celui-ci. Une optimisation plus poussée consiste à éliminer les appels de fonctions. Le compilateur en juste-à-temps connaît les classes qui ont été chargées. Il peut utiliser la suppression lorsque, en fonction de la collection de classes actuellement chargée, une fonction particulière n’est jamais écrasée. Il peut ensuite annuler cette optimisation si nécessaire.
Multithread *
Les avantages du multithread sont une meilleure interréactivité et un meilleur comportement en temps réel.
Si vous avez déjà essayé de programmer le multithread dans un autre langage, vous allez être agréablement surpris de la simplicité de cette tâche dans Java. Avec lui, les threads sont également capables de tirer parti des systèmes multiprocesseurs. Le côté négatif réside dans le fait que les implémentations de threads sur les plates-formes principales sont très différentes, et Java ne fait aucun effort pour être indépendant de la plate-forme à cet égard. La seule partie de code identique entre les différentes machines est celle de l’appel du multithread. Java se décharge de l’implémentation du multithread sur le système d’exploitation sous-jacent ou sur une bibliothèque de threads. Malgré tout, la simplicité du multithread est l’une des raisons principales du succès de Java pour le développement côté serveur.
Java, langage dynamique *
Sur plusieurs points, Java est un langage plus dynamique que C ou C++. Il a été conçu pour s’adapter à un environnement en évolution constante. Les bibliothèques peuvent ajouter librement de nouvelles méthodes et variables sans pour autant affecter leurs clients. La recherche des informations de type exécution dans Java est simple.
Cette fonction est importante lorsque l’on doit ajouter du code à un programme en cours d’exécution. Le premier exemple est celui du code téléchargé depuis Internet pour s’exécuter dans un navigateur. Avec la version 1.0 de Java, la recherche d’informations de type exécution était relativement complexe. A l’heure actuelle, les versions courantes de Java procurent au programmeur un aperçu complet de la structure et du comportement de ses objets. Cela se révèle très utile pour les systèmes nécessitant une analyse des objets au cours de l’exécution, tels que les générateurs graphiques de Java, les débogueurs évolués, les composants enfichables et les bases de données objet. INFO Peu après les premiers succès de Java, Microsoft a sorti un produit intitulé J++ qui présente un lien de parenté avec Java. Pour l’heure, Microsoft ne prend plus en charge J++ mais a introduit un nouveau langage, appelé C#, qui présente aussi de nombreuses similarités avec Java mais utilise une autre machine virtuelle. Il existe même un J# pour faire migrer les applications J++ vers la machine virtuelle utilisée par C#. Sachez que nous ne reviendrons pas sur J++, C# ou J# dans cet ouvrage.
Livre Java.book Page 14 Mercredi, 13. février 2008 2:34 14
14
Au cœur de Java 2 - Notions fondamentales
Les applets Java et Internet L’idée de base est simple : les utilisateurs téléchargent les bytecodes Java depuis Internet et les exécutent sur leurs propres machines. Les programmes Java s’exécutant sur les pages Web sont nommés applets. Pour utiliser un applet, vous devez disposer d’un navigateur Web compatible Java, qui exécutera les bytecodes. Vous n’aurez besoin d’installer aucun logiciel. Sun fournit sous licence le code source de Java et affirme qu’aucun changement n’affectera le langage et la structure de la bibliothèque de base. Vous obtiendrez la dernière version du programme dès que vous visiterez la page Web contenant l’applet. Et surtout, grâce à la sécurité de la machine virtuelle, vous n’aurez plus à vous inquiéter des attaques provenant d’un code hostile. Lorsque l’utilisateur télécharge un applet, il s’agit presque de l’intégration d’une image dans une page Web. L’applet s’insère dans la page et le texte se répartit dans son espace. Le fait est que l’image est vivante. Elle réagit aux commandes utilisateur, change d’apparence et transfère les données entre l’ordinateur qui présente l’applet et l’ordinateur qui la sert. La Figure 1.1 présente un exemple intéressant de page Web dynamique, un applet qui permet d’afficher des molécules et réalise des calculs sophistiqués. A l’aide de la souris, vous pouvez faire pivoter chaque molécule et zoomer dessus, pour mieux en comprendre la structure. Ce type de manipulation directe est impossible avec des pages Web statiques, elle n’est possible qu’avec les applets (vous trouverez cet applet à l’adresse http://jmol.sourceforge.net). A leur apparition, les applets ont suscité une grande excitation. Beaucoup pensent que l’attirance pour les applets a été responsable de la formidable popularité de Java. Or, cette première excitation s’est rapidement transformée en frustration. Différentes versions de Netscape et d’Internet Explorer exécutaient des versions différentes de Java, certaines particulièrement obsolètes. Cette situation malheureuse a compliqué de plus en plus le développement d’applets capables de tirer parti de la version la plus actuelle de Java. Aujourd’hui, la plupart des pages Web utilisent simplement JavaScript ou Flash pour obtenir des effets dynamiques dans le navigateur. Java, quant à lui, est devenu le langage le plus populaire pour développer des applications côté serveur qui produisent des pages Web et réalisent la logique en arrière-plan. Figure 1.1 L’applet Jmol.
Livre Java.book Page 15 Mercredi, 13. février 2008 2:34 14
Chapitre 1
Une introduction à Java
15
Bref historique de Java Cette section présente un bref historique de l’évolution de Java. Elle se réfère à diverses sources publiées (et, plus important encore, à un entretien avec les créateurs de Java paru dans le magazine en ligne SunWorld de juillet 1995). La naissance de Java date de 1991, lorsqu’un groupe d’ingénieurs de Sun, dirigé par Patrick Naughton et James Gosling, voulut concevoir un petit langage informatique adapté à des appareils de consommation comme les décodeurs du câble TV. Ces appareils ne disposant que de très peu de puissance ou de mémoire, le langage devait être concis et générer un code très strict. Des constructeurs différents étant susceptibles de choisir des unités centrales différentes, il était également important que le langage ne soit pas lié à une seule architecture. Le nom de code du projet était "Green". Les exigences d’un code concis et indépendant de la plate-forme conduisirent l’équipe à reprendre le modèle que certaines implémentations de Pascal avaient adopté au début de l’avènement des PC. Niklaus Wirth, l’inventeur de Pascal, avait préconisé la conception d’un langage portable générant du code intermédiaire pour des machines hypothétiques (souvent nommées machines virtuelles — de là, la machine virtuelle Java ou JVM). Ce code pouvait alors être utilisé sur toute machine disposant de l’interpréteur approprié. Les ingénieurs du projet Green utilisaient également une machine virtuelle, ce qui résolvait leur principal problème. Les employés de Sun avaient toutefois une culture UNIX. Ils ont donc basé leur langage sur C++ plutôt que sur Pascal. Au lieu de créer un langage fonctionnel, ils ont mis au point un langage orienté objet. Cependant, comme Gosling l’annonce dans l’interview, "depuis toujours, le langage est un outil et non une fin". Gosling décida de nommer son langage "Oak" (probablement parce qu’il appréciait la vue de sa fenêtre de bureau, qui donnait sur un chêne). Les employés de Sun se sont aperçus plus tard que ce nom avait déjà été attribué à un langage informatique. Ils l’ont donc transformé en Java. Ce choix s’est révélé heureux. Malheureusement, personne ne fut intéressé pour le produire chez Sun. L’équipe de Green dut trouver d’autres ouvertures pour commercialiser sa technologie. Toutefois, aucune des grandes sociétés d’électronique de grande consommation n’a été intéressée. Le groupe soumit alors un nouveau projet. Il proposa la conception d’un décodeur de câble TV capable de gérer de nouveaux services câblés, tels que la vidéo à la demande. Malgré cela, le contrat n’a pu être décroché (pour la petite histoire, la compagnie qui l’a obtenu était dirigée par le même Jim Clark qui avait démarré Netscape — une entreprise qui a beaucoup participé au succès de Java). Le projet Green (sous le nouveau nom de "First Person Inc.") a passé l’année 1993 et la moitié de 1994 à rechercher des acheteurs pour sa technologie — peine perdue (Patrick Naughton, l’un des fondateurs du groupe et principal agent marketing, prétend avoir parcouru plus de 80 000 km en avion pour vendre sa technologie). First Person a été dissoute en 1994. Pendant ce temps, le World Wide Web d’Internet devenait de plus en plus important. L’élément clé du Web est le navigateur qui traduit la page hypertexte à l’écran. En 1994, la plupart des gens utilisaient Mosaic, un navigateur Web non commercialisé et issu du Supercomputing Center de l’université de l’Illinois en 1993 (alors qu’il était encore étudiant, Marc Andreessen avait participé à la création de Mosaic pour 6,85 $ l’heure. Par la suite, il a obtenu la notoriété et la fortune en tant que cofondateur et directeur de technologie de Netscape). Lors d’une interview pour le SunWorld, Gosling a déclaré qu’au milieu de l’année 1994, les développeurs de langage avaient réalisé qu’ils pouvaient créer un navigateur vraiment cool. Il s’agissait
Livre Java.book Page 16 Mercredi, 13. février 2008 2:34 14
16
Au cœur de Java 2 - Notions fondamentales
d’une des rares choses dans le courant client/serveur qui nécessitait certaines des actions bizarres qu’ils avaient réalisées : l’architecture neutre, le temps réel, la fiabilité, la sécurité — des questions qui étaient peu importantes dans le monde des stations de travail. Ils ont donc créé un navigateur. En fait, le vrai navigateur a été créé par Patrick Naughton et Jonathan Payne. Il a ensuite évolué pour donner naissance au navigateur HotJava. Ce dernier a été écrit en Java pour montrer la puissance de ce langage. Mais les concepteurs avaient également à l’esprit la puissance de ce qui est actuellement nommé les applets. Ils ont donc donné la possibilité au navigateur d’exécuter le code au sein des pages Web. Cette "démonstration de technologie" fut présentée au SunWorld le 23 mai 1995 et elle fut à l’origine de l’engouement pour Java, qui ne s’est pas démenti. Sun a diffusé la première version de Java début 1996. On a rapidement réalisé que cette version ne pouvait être utilisée pour un développement d’applications sérieux. Elle permettait, bien sûr, de créer un applet de texte animé qui se déplaçait de façon aléatoire sur un fond. Mais il était impossible d’imprimer... Cette fonctionnalité n’était pas prévue par la version 1.0. Son successeur, la version 1.1, a comblé les fossés les plus évidents, a grandement amélioré la capacité de réflexion et ajouté un nouveau modèle pour la programmation GUI. Elle demeurait pourtant assez limitée. Les grands projets de la conférence JavaOne de 1998 étaient la future version de Java 1.2. Cette dernière était destinée à remplacer les premières boîtes à outils graphiques et GUI d’amateur par des versions sophistiquées et modulaires se rapprochant beaucoup plus que leurs prédécesseurs de la promesse du "Write Once, Run Anywhere"™ (un même programme s’exécute partout). Trois jours après (!) sa sortie en décembre 1998, le service marketing de Sun a transformé le nom, qui est devenu Java 2 Standard Edition Software Development Kit Version 1.2 ! Outre "l’Edition Standard", deux autres éditions ont été introduites : "Micro Edition" pour les services intégrés comme les téléphones portables, et "Entreprise Edition" pour le traitement côté serveur. Cet ouvrage se concentre sur l’Edition Standard. Les versions 1.3 et 1.4 constituent une amélioration incrémentielle par rapport à la version Java 2 initiale, avec une bibliothèque standard en pleine croissance, des performances accrues et, bien entendu, un certain nombre de bogues corrigés. Pendant ce temps, la majeure partie de la passion générée par les applets Java et les applications côté client a diminué, mais Java est devenu la plateforme de choix pour les applications côté serveur. La version 5.0 est la première depuis la version 1.1 qui actualise le langage Java de manière significative (cette version était numérotée, à l’origine, 1.5, mais le numéro est devenu 5.0 lors de la conférence JavaOne de 2004). Après de nombreuses années de recherche, des types génériques ont été ajoutés (à peu près comparables aux modèles C++), le défi étant d’intégrer cette fonctionnalité sans exiger de changements de la machine virtuelle. Plusieurs autres fonctionnalités utiles ont été inspirées par le C# : une boucle for each, l’autoboxing (passage automatique entre type de base et classes encapsulantes) et les métadonnées. Les changements de langage continuent à poser des problèmes de compatibilité, mais plusieurs de ces fonctionnalités sont si séduisantes que les programmeurs devraient les adopter rapidement. La version 6 (dépourvue du suffixe .0) est sortie fin 2006. Une fois de plus, le langage n’a pas connu de changement, mais les performances et la bibliothèque ont été améliorées. Le Tableau 1.1 montre l’évolution du langage Java et de la bibliothèque. Vous le voyez, la taille de l’interface de programmation d’application (API) a considérablement augmenté.
Livre Java.book Page 17 Mercredi, 13. février 2008 2:34 14
Chapitre 1
Une introduction à Java
17
Tableau 1.1 : Evolution du langage Java
Version
Année
Nouvelles fonctionnalités du langage
Nombre de classes et d’interfaces
1.0
1996
Le langage lui-même
211
1.1
1997
Classes internes
477
1.2
1998
Aucune
1 524
1.3
2000
Aucune
1 840
1.4
2004
Assertions
2 723
5.0
2004
Classes génériques, boucle for each, varargs, autoboxing, métadonnées, énumérations, importation static
3 279
6
2006
Aucune
3 777
Les idées fausses les plus répandues concernant Java Nous clôturons ce chapitre par une liste de quelques idées fausses concernant Java. Elles seront accompagnées de leur commentaire. Java est une extension de HTML. Java est un langage de programmation. HTML représente une façon de décrire la structure d’une page Web. Ils n’ont rien en commun, à l’exception du fait qu’il existe des extensions HTML permettant d’insérer des applets Java sur une page Web. J’utilise XML, je n’ai donc pas besoin de Java. Java est un langage de programmation ; XML est une manière de décrire les données. Vous pouvez traiter des données XML avec tout langage de programmation, mais l’API Java en contient une excellente prise en charge. En outre, de nombreux outils XML tiers très importants sont mis en place en Java. Voir le Volume II pour en savoir plus. Java est un langage de programmation facile à apprendre. Aucun langage de programmation aussi puissant que Java n’est facile. Vous devez toujours distinguer la facilité de l’écriture de programmes triviaux et la difficulté que représente un travail sérieux. Considérez également que quatre chapitres seulement de ce livre traitent du langage Java. Les autres chapitres dans les deux volumes traitent de la façon de mettre le langage en application, à l’aide des bibliothèques Java. Celles-ci contiennent des milliers de classes et d’interfaces, et des dizaines de milliers de fonctions. Vous n’avez heureusement pas besoin de connaître chacune d’entre elles, mais vous devez cependant être capable d’en reconnaître un grand nombre pour pouvoir obtenir quelque chose de réaliste.
Livre Java.book Page 18 Mercredi, 13. février 2008 2:34 14
18
Au cœur de Java 2 - Notions fondamentales
Java va devenir un langage de programmation universel pour toutes les plates-formes. En théorie, c’est possible, et il s’agit certainement du souhait de tous les vendeurs, à l’exception de Microsoft. Il existe cependant de nombreuses applications, déjà parfaitement efficaces sur les ordinateurs de bureau, qui ne fonctionneraient pas sur d’autres unités ou à l’intérieur d’un navigateur. Ces applications ont été écrites de façon à tirer parti de la vitesse du processeur et de la bibliothèque de l’interface utilisateur native. Elles ont été portées tant bien que mal sur toutes les plates-formes importantes. Parmi ces types d’applications figurent les traitements de texte, les éditeurs d’images et les navigateurs Web. Ils sont écrits en C ou C++, et nous ne voyons aucun intérêt pour l’utilisateur final à les réécrire en Java. Java est simplement un autre langage de programmation. Java est un bon langage de programmation. De nombreux programmeurs le préfèrent à C, C++ ou C#. Mais des centaines de bons langages de programmation n’ont jamais réussi à percer, alors que des langages avec des défauts évidents, tels que C++ et Visual Basic, ont remporté un large succès. Pourquoi ? Le succès d’un langage de programmation est bien plus déterminé par la qualité du système de support qui l’entoure que par l’élégance de sa syntaxe. Existe-t-il des bibliothèques utiles, pratiques et standard pour les fonctions que vous envisagez de mettre en œuvre ? Des vendeurs d’outils ont-ils créé de bons environnements de programmation et de débogage ? Le langage et l’ensemble des outils s’intègrent-ils avec le reste de l’infrastructure informatique ? Java a du succès parce que ses bibliothèques de classes vous permettent de réaliser facilement ce qui représentait jusqu’alors une tâche complexe. La gestion de réseau et les multithreads en sont des exemples. Le fait que Java réduise les erreurs de pointeur est un bon point. Il semble que les programmeurs soient plus productifs ainsi. Mais il ne s’agit pas de la source de son succès. L’arrivée de C# rend Java obsolète. C# a repris plusieurs bonnes idées de Java, par exemple un langage de programmation propre, une machine virtuelle et un ramasse-miettes. Mais, quelles qu’en soient les raisons, le C# a également manqué certaines bonnes choses, comme la sécurité et l’indépendance de la plate-forme. Si vous appréciez Windows, optez pour le C#. Mais, si l’on en juge par les offres d’emploi, Java reste le langage préféré de la majorité des développeurs. Java est un outil propriétaire, il faut donc l’éviter. Sun Microsystems distribue Java sous licence aux distributeurs et aux utilisateurs finaux. Même si Sun possède un contrôle total sur Java, il a, par le biais de la "Communauté Java", impliqué de nombreuses autres sociétés dans le développement de versions et la conception de nouvelles bibliothèques. Le code source de la machine virtuelle et des bibliothèques est disponible gratuitement, mais pour étude uniquement et non pour modification et redistribution. Jusqu’à présent, Java est en "source fermée, mais fonctionne bien". Cette situation a considérablement changé en 2007, lorsque Sun a annoncé la disponibilité des futures versions de Java dans le cadre de la GPL (General Public Licence ou licence publique générale), la licence open source de Linux. Reste à voir comment Sun gérera Java à l’avenir, mais il ne fait aucun
Livre Java.book Page 19 Mercredi, 13. février 2008 2:34 14
Chapitre 1
Une introduction à Java
19
doute que le côté open source de Java a constitué une évolution très courageuse, qui prolongera la vie de Java de nombreuses années. Java est interprété, il est donc trop lent pour les applications sérieuses. Aux premiers jours de Java, le langage était interprété. Aujourd’hui, sauf sur les plates-formes "Micro" comme les téléphones portables, la machine virtuelle Java utilise un compilateur JIT. Les hot spots de votre code s’exécuteront aussi rapidement en Java qu’en C++ et même plus rapidement dans certains cas. Java est moins rapide que le C++. Le démarrage de la machine virtuelle peut être lent et les GUI Java sont plus lents que leurs homologues natifs car ils sont conçus indépendamment de la plate-forme. Le public se plaint depuis des années de la lenteur des applications Java. Toutefois, les ordinateurs actuels sont plus rapides. Un programme Java lent s’exécutera un peu mieux que ces programmes C++ incroyablement rapides d’il y a quelques années. Pour l’heure, ces plaintes semblent obsolètes et certains détracteurs ont tendance à viser plutôt la laideur des interfaces utilisateur de Java que leur lenteur. Tous les programmes Java s’exécutent dans une page Web. Tous les applets Java s’exécutent dans un navigateur Web. C’est la définition même d’un applet — un programme Java s’exécutant dans un navigateur. Mais la plupart des programmes Java sont des applications autonomes qui s’exécutent indépendamment d’un navigateur Web. De nombreux programmes Java s’exécutent en fait sur des serveurs Web et produisent le code des pages Web. La majeure partie des programmes de cet ouvrage sont autonomes. Les applets sont bien sûr un sujet passionnant. Mais les programmes Java autonomes sont plus importants et plus utiles dans la pratique. Les programmes Java représentent un risque majeur pour la sécurité. Aux premiers temps de Java, son système de sécurité a quelquefois été pris en défaut, et ces incidents ont été largement commentés. La plupart sont dus à l’implémentation de Java dans un navigateur spécifique. Les chercheurs ont considéré ce système de sécurité comme un défi à relever et ont tenté de détecter les failles de l’armure de Java. Les pannes techniques découvertes ont toutes été rapidement corrigées et, à notre connaissance, aucun des systèmes actuels n’a jamais été pris en défaut. Pour replacer ces incidents dans une juste perspective, prenez en compte les millions de virus qui attaquent les fichiers exécutables de Windows ainsi que les macros de Word. De réels dégâts sont alors causés, mais curieusement, peu de critiques sont émises concernant la faiblesse de la plateforme concernée. Le mécanisme ActiveX d’Internet Explorer pourrait également représenter une cible facile à prendre en défaut, mais ce système de sécurité est tellement simple à contourner que très peu de chercheurs ont pensé à publier leur découverte. Certains administrateurs système ont même désactivé Java dans les navigateurs de leur entreprise, alors qu’ils continuent à autoriser les utilisateurs à télécharger des fichiers exécutables, des contrôles ActiveX et des documents Word. Il s’agit d’un comportement tout à fait ridicule — actuellement, le risque de se voir attaqué par un applet Java hostile est à peu près comparable au risque de mourir dans un accident d’avion. Le risque d’infection inhérent à l’ouverture d’un document Word est, au contraire, comparable au risque de mourir en traversant à pied une autoroute surchargée.
Livre Java.book Page 20 Mercredi, 13. février 2008 2:34 14
20
Au cœur de Java 2 - Notions fondamentales
JavaScript est une version simplifiée de Java. JavaScript, un langage de script que l’on peut utiliser dans les pages Web, a été inventé par Netscape et s’appelait à l’origine LiveScript. On trouve dans la syntaxe de JavaScript des réminiscences de Java, mais il n’existe aucune relation (à l’exception du nom, bien sûr) entre ces deux langages. Un sous-ensemble de JavaScript est standardisé sous le nom de ECMA-262. JavaScript est plus étroitement intégré dans les navigateurs que ne le sont les applets Java. En particulier, un programme JavaScript peut modifier le document affiché, tandis qu’un applet ne peut que contrôler l’apparence d’une zone limitée. Avec Java, je peux remplacer mon ordinateur par une "boîte noire Internet" bon marché. Lors de la première sortie de Java, certains pariaient gros là-dessus. Depuis la première édition de cet ouvrage, nous pensons qu’il est absurde d’imaginer que l’on puisse abandonner une machine de bureau puissante et pratique pour une machine limitée sans mémoire locale. Cependant, un ordinateur réseau pourvu de Java est une option plausible pour une "initiative zéro administration". En effet, vous éliminez ainsi le coût des ordinateurs de l’entreprise, mais même cela n’a pas tenu ses promesses. Par ailleurs, Java est devenu largement distribué sur les téléphones portables. Nous devons avouer que nous n’avons pas encore vu d’application Java indispensable fonctionnant sur les téléphones portables, mais les jeux et les économiseurs d’écran usuels semblent bien se vendre sur de nombreux marchés. ASTUCE Pour obtenir des réponses aux questions communes sur Java, consultez les FAQ Java sur le Web : http:// www.apl.jhu.edu/~hall/java/FAQs-and-Tutorials.html.
Livre Java.book Page 21 Mercredi, 13. février 2008 2:34 14
2 L’environnement de programmation de Java Au sommaire de ce chapitre
✔ Installation du kit de développement Java ✔ Choix d’un environnement de développement ✔ Utilisation des outils de ligne de commande ✔ Utilisation d’un environnement de développement intégré ✔ Exécution d’une application graphique ✔ Elaboration et exécution d’applets Ce chapitre traite de l’installation du kit de développement Java (JDK) et de la façon de compiler et d’exécuter différents types de programmes : les programmes consoles, les applications graphiques et les applets. Vous lancez les outils JDK en tapant les commandes dans une fenêtre shell. De nombreux programmeurs préfèrent toutefois le confort d’un environnement de développement intégré. Vous apprendrez à utiliser un environnement disponible gratuitement, pour compiler et exécuter les programmes Java. Faciles à comprendre et à utiliser, les environnements de développement intégrés peuvent nécessiter des ressources importantes et être lourds à utiliser pour de petits programmes. Comme solution intermédiaire, vous disposez des éditeurs de texte appelant le compilateur Java et exécutant les programmes Java. Lorsque vous aurez maîtrisé les techniques présentées dans ce chapitre et choisi vos outils de développement, vous serez prêt à aborder le Chapitre 3, où vous commencerez à explorer le langage de programmation Java.
Installation du kit de développement Java Les versions les plus complètes et les plus récentes du kit de développement Java (JDK) sont disponibles auprès de Sun Microsystems pour Solaris, Linux et Windows. Certaines versions de Java sont disponibles en divers degrés de développement pour Macintosh et de nombreuses autres plates-formes, mais ces versions sont fournies sous licence et distribuées par les fournisseurs de ces plates-formes.
Livre Java.book Page 22 Mercredi, 13. février 2008 2:34 14
22
Au cœur de Java 2 - Notions fondamentales
INFO Certaines distributions de Linux possèdent des versions préemballées du JDK. Ainsi, par exemple, sous Ubuntu, vous pouvez installer le JDK en installant simplement le package sun-java6-jdk avec apt-get ou la GUI Synaptic.
Télécharger le JDK Pour télécharger le JDK, accédez au site Web de Sun ; vous devrez passer une grande quantité de jargon avant de pouvoir obtenir le logiciel. Voyez le Tableau 2.1 pour en obtenir un résumé. Vous avez déjà rencontré l’abréviation JDK (Java Development Kit). Pour compliquer un peu les choses, les versions 1.2 à 1.4 du kit étaient connues sous le nom de Java SDK (Software Development Kit). Sachez que vous retrouverez des mentions occasionnelles de cet ancien acronyme. Il existe également un JRE (Java Runtime Environment) contenant la machine virtuelle, mais pas le compilateur. Or, cela n’est pas adapté pour les développeurs, il est plutôt destiné aux utilisateurs n’ayant pas besoin du compilateur. Vous rencontrerez aussi très souvent le terme "Java SE". Il signifie "Java Standard Edition", par opposition à Java EE (Entreprise Edition) et à Java ME (Micro Edition). Le terme "Java 2" est apparu en 1998, l’année où les commerciaux de Sun ont considéré qu’augmenter le numéro de version par une décimale ne traduisait pas correctement les nouveautés du JDK 1.2. Or, ils ne s’en sont aperçus qu’après la sortie et ont donc décidé de conserver le numéro 1.2 pour le kit de développement. Les versions consécutives ont été numérotées 1.3, 1.4 et 5.0. La plate-forme a toutefois été renommée de "Java" en "Java 2". Ce qui nous donne donc Java 2 Standard Edition Software Development Kit version 5.0, soit J2SE SDK 5.0. Cela peut être assez désarmant pour les ingénieurs, mais c’est là le côté caché du marketing. Heureusement, en 2006, le bon sens a repris le dessus. Le surnom Java 2, parfaitement inutile, a donc été abandonné, et la version actuelle de Java Standard Edition s’est appelée Java SE 6. Vous trouverez toujours, par moments, une référence aux versions 1.5 et 1.6, ce sont simplement des synonymes des versions 5.0 et 6. Enfin, lorsque Sun apporte un changement mineur pour corriger des problèmes urgents, il nomme cette opération une mise à jour. Ainsi, la première mise à jour du kit de développement pour Java SE 6 s’intitule officiellement JDK 6u1 et porte le numéro de version interne 1.6.0_01. Pour les utilisateurs de Solaris, de Linux ou de Windows, accédez à l’adresse http://java.sun.com/ javase pour télécharger le JDK. Demandez la version 6 ou supérieure, puis choisissez votre plateforme. Ne vous inquiétez pas si le logiciel est qualifié de "mise à jour". Le module contient la version actuelle de l’ensemble du JDK. Sun sort parfois des modules contenant à la fois le Java Development Kit et un environnement de développement intégré. Cet environnement a, selon les époques, été nommé Forte, Sun ONE Studio, Sun Java Studio et NetBeans. Nous ne savons pas ce que les arcanes du marketing auront trouvé lorsque vous visiterez le site Web de Sun. Nous vous suggérons de n’installer pour l’heure que le Java Development Kit. Si vous décidez par la suite d’utiliser l’environnement de développement intégré de Sun, téléchargez-le simplement à l’adresse http://netbeans.org.
Livre Java.book Page 23 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
23
Tableau 2.1 : Le jargon de Java
Nom
Acronyme
Explication
Java Development Kit
JDK
Le logiciel destiné aux programmeurs qui souhaitent écrire des programmes Java
Java Runtime Environment
JRE
Le logiciel destiné aux clients qui veulent exécuter des programmes Java
Standard Edition
SE
La plate-forme Java à utiliser sur les ordinateurs de bureau et les applications de serveur simples
Enterprise Edition
EE
La plate-forme Java pour les applications de serveur complexes
Micro Edition
ME
La plate-forme Java à utiliser sur les téléphones portables et autres petits appareils
Java 2
J2
Un terme obsolète désignant les versions de Java entre 1998 et 2006
Software Development Kit
SDK
Terme obsolète désignant le JDK entre 1998 et 2006
Mise à jour (Update)
u
Terme employé par Sun pour désigner un correctif de bogue
NetBeans
–
L’environnement de développement intégré de Sun
Une fois le JDK téléchargé, suivez les instructions d’installation, qui sont fonction de la plate-forme. A l’heure où nous écrivons, elles étaient disponibles à l’adresse http://java.sun.com/javase/6/ webnotes/install/index.html. Seules les instructions d’installation et de compilation pour Java dépendent du système. Une fois Java installé et opérationnel, les autres informations fournies dans ce livre s’appliqueront à votre situation. L’indépendance vis-à-vis du système est un avantage important de Java. INFO La procédure d’installation propose un répertoire d’installation par défaut incluant le numéro de version de Java JDK, comme jdk1.6.0. Ceci peut paraître pénible, mais le numéro de version est finalement assez pratique, puisque vous pouvez tester facilement une nouvelle version du JDK. Sous Windows, nous vous recommandons fortement de ne pas accepter l’emplacement par défaut avec des espaces dans le nom du chemin, comme C:\Program Files\jdk1.6.0. Enlevez simplement la partie Program Files. Dans cet ouvrage, nous désignons le répertoire d’installation par jdk. Par exemple, lorsque nous faisons référence au répertoire jdk/bin, nous désignons le répertoire ayant le nom /usr/local/jdk1.6.0/bin ou C:\jdk1.6.0\bin.
Livre Java.book Page 24 Mercredi, 13. février 2008 2:34 14
24
Au cœur de Java 2 - Notions fondamentales
Configurer le chemin d’exécution Après avoir installé le JDK, vous devez effectuer une étape supplémentaire : ajouter le répertoire jdk/bin au chemin d’exécution, la liste des répertoires que traverse le système d’exploitation pour localiser les fichiers exécutables. Les directives concernant cette étape varient également en fonction du système d’exploitation. m
Sous UNIX (y compris Solaris ou Linux), la procédure pour modifier le chemin d’exécution dépend du shell que vous utilisez. Si vous utilisez le C shell (qui est le défaut pour Solaris), vous devez ajouter une ligne analogue à celle qui suit à la fin de votre fichier ~/.cshrc : set path=(/usr/local/jdk/bin $path)
Si vous utilisez le Bourne Again shell (défaut pour Linux), ajoutez une ligne analogue à celle qui suit, à la fin de votre fichier ~/.bashrc ou ~/.bash_profile : export PATH=/usr/local/jdk/bin:$PATH m
Sous Windows, connectez-vous en tant qu’administrateur. Ouvrez le Panneau de configuration, passez en affichage classique et sélectionnez Système. Sous Windows NT/2000/XP, la boîte de dialogue des propriétés système s’ouvre immédiatement. Sous Vista, sélectionnez les paramètres système avancés (voir Figure 2.1). Dans la boîte de dialogue des propriétés du système, cliquez sur l’onglet Paramètres système avancés, puis sur le bouton Variables d’environnement. Parcourez la fenêtre Variables système pour rechercher la variable nommée Path (voir Figure 2.2). Ajoutez le répertoire jdk\bin au début du chemin, en ajoutant un point-virgule pour séparer la nouvelle entrée, de la façon suivante : c:\jdk\bin;le reste
Sauvegardez votre configuration. Toute nouvelle fenêtre console que vous lancerez comprendra le chemin correct. Procédez de la façon suivante pour vérifier que vous avez effectué les manipulations appropriées. Démarrez une fenêtre shell. Tapez la ligne : java -version
Appuyez sur la touche Entrée. Vous devez obtenir un affichage comparable à ce qui suit : java version "1.6.0_01" Java(TM) SE Runtime Environment (build 1.6.0_01-b06) Java HotSpot(TM) Client VM (build 1.6.0_01-b06, mixed mode, sharing)
Si, à la place, vous obtenez un message du type "java: command not found" ou "The name specified is not recognized as an internal or external command, operable program or batch file", messages qui signalent une commande ou un fichier erroné, vous devez vérifier votre installation. INFO Selon la version de Windows, une fenêtre shell s’ouvre d’une des manières suivantes. Sous Windows NT/2000/XP, choisissez l’option Exécuter du menu Démarrer et tapez cmd. Sous Vista, cliquez sur Démarrer et tapez cmd. Appuyez sur Entrée pour ouvrir la fenêtre shell. Si vous n’avez jamais utilisé de fenêtre shell, nous vous proposons un didacticiel enseignant les bases de la ligne de commande. De nombreux services informatiques proposent des didacticiels sur le Web, notamment à l’adresse http://www.cs.sjsu.edu/faculty/horstman/CS46A/windows/tutorial.html.
Livre Java.book Page 25 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
Figure 2.1 Lancement de la boîte de dialogue des propriétés du système sous Windows Vista.
Figure 2.2 Paramétrage de la variable d’environnement Path sous Windows Vista.
25
Livre Java.book Page 26 Mercredi, 13. février 2008 2:34 14
26
Au cœur de Java 2 - Notions fondamentales
Installer la bibliothèque et la documentation Les fichiers source de bibliothèque sont fournis dans le JDK sous la forme d’un fichier compressé src.zip et vous devez le décompresser pour avoir accès au code source. La procédure suivante est hautement recommandée. 1. Assurez-vous que le JDK est installé et que le répertoire jdk/bin figure dans le chemin d’exécution. 2. Ouvrez une fenêtre shell. 3. Positionnez-vous dans le répertoire jdk (par ex. /usr/local/jdk1.6.0 ou C:\jdk1.6.0). 4. Créez un sous-répertoire src. mkdir src cd src
5. Exécutez la commande : jar xvf ../src.zip
(ou jar xvf ..\src.zip sous Windows). ASTUCE Le fichier src.zip contient le code source pour toutes les bibliothèques publiques. Vous pouvez obtenir d’autres codes source (pour le compilateur, la machine virtuelle, les méthodes natives et les classes privées helper) à l’adresse http://download.java.net/jdk6.
La documentation est contenue dans un fichier compressé séparé du JDK. Vous pouvez télécharger la documentation à l’adresse http://java.sun.com/javase/downloads. Procédez de la façon suivante : 1. Assurez-vous que le JDK est installé et que le répertoire jdk/bin figure dans le chemin d’exécution. 2. Copiez le fichier zip de documentation dans le répertoire qui contient le répertoire jdk. Le fichier est nommé jdk-version-doc.zip, où version ressemble à 6. 3. Lancez une fenêtre shell. 4. Positionnez-vous dans le répertoire jdk. 5. Exécutez la commande : jar xvf jdk-version-doc.zip
où version est le numéro de version approprié.
Installer les exemples de programmes Il est conseillé d’installer les exemples de programmes que vous pouvez télécharger à l’adresse www.pearsoneducation.fr. Les programmes sont compressés dans un fichier zip corejavavol1.zip. Décompressez-les dans un répertoire séparé que nous vous recommandons d’appeler CoreJavaBook. Procédez de la façon suivante :
Livre Java.book Page 27 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
27
1. Assurez-vous que le JDK est installé et que le répertoire jdk/bin figure dans le chemin d’exécution. 2. Créez un répertoire nommé CoreJavaBook. 3. Copiez le fichier corejavavol1.zip dans ce répertoire. 4. Lancez une fenêtre shell. 5. Positionnez-vous dans le répertoire CoreJavaBook. 6. Exécutez la commande : jar xvf corejavavol1.zip
Explorer les répertoires de Java Au cours de votre étude, vous aurez à examiner des fichiers source Java. Vous devrez également, bien sûr, exploiter au maximum la documentation bibliothèque. Le Tableau 2.2 présente l’arborescence des répertoires du JDK. Tableau 2.2 : Arborescence des répertoires de Java
Structure du répertoire
Description Le nom peut être différent, par exemple jdk5.0
jdk bin
Compilateur et outils
demo
Démos
docs
Documentation de la bibliothèque au format HTML (après décompression de j2sdkversion-doc.zip)
include
Fichiers pour les méthodes natives (voir Volume II)
jre
Fichiers d’environnement d’exécution de Java
lib
Fichiers de bibliothèque
src
Source de bibliothèque (après décompression de src.zip)
Les deux sous-répertoires les plus importants sont docs et src. Le répertoire docs contient la documentation de la bibliothèque Java au format HTML. Vous pouvez la consulter à l’aide de tout navigateur Web tel que Netscape. ASTUCE Définissez un signet dans votre navigateur pour le fichier docs/api/index.html. Vous consulterez fréquemment cette page au cours de votre étude de la plate-forme Java !
Livre Java.book Page 28 Mercredi, 13. février 2008 2:34 14
28
Au cœur de Java 2 - Notions fondamentales
Le répertoire src contient le code source de la partie publique des bibliothèques de Java. Lorsque ce langage vous sera plus familier, ce livre et les informations en ligne ne vous apporteront sans doute plus les infos dont vous avez besoin. Le code source de Java constituera alors un bon emplacement où commencer les recherches. Il est quelquefois rassurant de savoir que l’on a toujours la possibilité de se plonger dans le code source pour découvrir ce qui est réellement réalisé par une fonction de bibliothèque. Si vous vous intéressez, par exemple, à la classe System, vous pouvez consulter src/java/lang/System.java.
Choix de l’environnement de développement Si vous avez l’habitude de programmer avec Microsoft Visual Studio, vous êtes accoutumé à un environnement de développement qui dispose d’un éditeur de texte intégré et de menus vous permettant de compiler et d’exécuter un programme avec un débogueur intégré. La version de base du JDK ne contient rien de tel, même approximativement. Tout se fait par l’entrée de commandes dans une fenêtre shell. Même si cela peut paraître lourd, il s’agit d’une compétence essentielle. A la première installation de Java, vous devrez mettre au propre votre installation avant d’installer un environnement de développement. De plus, en réalisant vous-même les étapes de base, vous appréhenderez mieux ce que fait l’environnement de développement dans votre dos. Toutefois, lorsque vous aurez maîtrisé les bases de la compilation et de l’exécution des programmes Java, vous aurez besoin d’un environnement de développement professionnel. Au cours de la dernière décennie, ces environnements sont devenus si puissants et si commodes qu’il n’est tout simplement pas logique de s’en passer. Deux excellents choix sont les programmes gratuits Eclipse et NetBeans. Nous vous présentons dans ce chapitre une mise en route d’Eclipse, qui est un peu plus performant que NetBeans, même si ce dernier rattrape rapidement son retard. Bien entendu, si vous disposez déjà d’un environnement de développement, n’hésitez pas à l’utiliser. Auparavant, nous recommandions d’utiliser un éditeur de texte comme Emacs, JEdit ou TextPad pour des programmes simples. Nous ne le faisons plus car les environnements de développement intégrés sont aujourd’hui rapides et pratiques. En résumé, nous supposons que vous savez utiliser les outils de base du JDK et que vous devriez vous familiariser avec un environnement de développement intégré.
Utilisation des outils de ligne de commande Commençons par le plus difficile : compiler et lancer un programme Java à partir de la ligne de commande. 1. Ouvrez un shell. 2. Positionnez-vous dans le répertoire CoreJavaBook/v1ch02/Welcome (le répertoire CoreJavaBook est celui dans lequel vous avez installé le code source pour les exemples du livre, tel qu’expliqué précédemment). 3. Entrez les commandes suivantes : javac Welcome.java java Welcome
Vous devez voir apparaître le message de la Figure 2.3 à l’écran.
Livre Java.book Page 29 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
29
Figure 2.3 Compilation et exécution de Welcome.java.
Félicitations ! Vous venez de compiler et d’exécuter votre premier programme Java. Que s’est-il passé ? Le programme javac est le compilateur Java. Il compile le fichier Welcome.java en un fichier Welcome.class. Le programme java lance la machine virtuelle Java. Il interprète les bytecodes que le compilateur a placés dans le fichier class. INFO Si vous obtenez un message d’erreur relatif à la ligne for (String g : greeting)
cela signifie que vous utilisez probablement une ancienne version du compilateur Java. Java SE 5.0 a introduit plusieurs fonctions utiles au langage de programmation Java dont nous profiterons dans cet ouvrage. Si vous utilisez une ancienne version, vous devez réécrire la boucle comme suit : for (int i = 0; i < greeting.length; i++) System.out.println(greeting[i]);
Le programme Welcome est extrêmement simple. Il se contente d’afficher un message sur l’écran. Vous pouvez examiner ce programme dans le Listing 2.1 — nous en expliquerons le fonctionnement dans le prochain chapitre. Listing 2.1 : Welcome.java /** * Ce programme affiche un message de bienvenue des auteurs. * @version 1.20 2004-02-28 * @author Cay Horstmann */
Livre Java.book Page 30 Mercredi, 13. février 2008 2:34 14
30
Au cœur de Java 2 - Notions fondamentales
public class Welcome { public static void main(String[] args) { String[] greeting = new String[3]; greeting[0] = "Welcome to Core Java"; greeting[1] = "by Cay Horstmann"; greeting[2] = "and Gary Cornell"; for (String g : greeting) System.out.println(g); } }
Conseils pour la recherche d’erreurs A l’heure des environnements de développement visuels, les programmeurs n’ont pas l’habitude de lancer des programmes dans une fenêtre shell. Tant de choses peuvent mal tourner et mener à des résultats décevants. Surveillez particulièrement les points suivants : m
Si vous tapez le programme manuellement, faites attention aux lettres majuscules et minuscules. En particulier, le nom de classe est Welcome et non welcome ou WELCOME.
m
Le compilateur requiert un nom de fichier Welcome.java. Lorsque vous exécutez le programme, vous spécifiez un nom de classe (Welcome) sans extension .java ni .class.
m
Si vous obtenez un message tel que "Bad command or file name" ou "javac: command not found", signalant une commande erronée, vous devez vérifier votre installation, en particulier la configuration du chemin d’exécution.
m
Si javac signale une erreur "cannot read: Welcome.java", signalant une erreur de lecture du fichier, vérifiez si ce fichier est présent dans le répertoire. Sous UNIX, vérifiez que vous avez respecté la casse des caractères pour Welcome.java. Sous Windows, utilisez la commande shell dir, et non l’outil Explorateur graphique. Certains éditeurs de texte (en particulier le Bloc-notes) ajoutent systématiquement une extension .txt après chaque fichier. Si vous utilisez le Bloc-notes pour modifier Welcome.java, le fichier sera enregistré sous le nom Welcome.java.txt. Dans la configuration par défaut de Windows, l’Explorateur conspire avec le Bloc-notes et masque l’extension .txt, car elle est considérée comme un "type de fichier connu". Dans ce cas, vous devez renommer le fichier à l’aide de la commande shell ren ou le réenregistrer, en plaçant des guillemets autour du nom de fichier : "Welcome.java".
m
Si java affiche un message signalant une erreur "java.lang.NoClassDefFoundError", vérifiez soigneusement le nom de la classe concernée. Si l’interpréteur se plaint que welcome contient un w minuscule, vous devez réémettre la commande java Welcome avec un W majuscule. Comme toujours, la casse doit être respectée dans Java.
Livre Java.book Page 31 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
31
Si l’interpréteur signale un problème concernant Welcome/java, vous avez accidentellement tapé java Welcome.java. Réémettez la commande java Welcome. m
Si vous avez tapé java Welcome et que la machine virtuelle ne trouve pas la classe Welcome, vérifiez si quelqu’un a configuré la variable d’environnement CLASSPATH sur votre système. Il n’est généralement pas conseillé de définir cette variable globalement, même si certains installateurs de logiciels mal écrits sous Windows le font. Pour l’annuler temporairement dans la fenêtre shell actuelle, tapez : set CLASSPATH=
Cette commande fonctionne sous Windows et UNIX/Linux avec le shell C. Sous UNIX/Linux, avec le shell Bourne/bash, utilisez : export CLASSPATH= m
Si vous recevez un message d’erreur sur une nouvelle construction de langage, vérifiez que votre compilateur supporte Java SE 5.0.
m
Si vous avez trop d’erreurs dans votre programme, tous les messages vont défiler très vite. Le compilateur envoie les messages vers la sortie d’erreur standard, ce qui rend leur capture difficile s’ils occupent plus d’un écran. Utilisez l’opérateur shell 2> pour rediriger les erreurs vers un fichier : javac MyProg.java 2> errors.txt
ASTUCE Il existe à l’adresse http://java.sun.com/docs/books/tutorial/getStarted/cupojava/ un excellent didacticiel qui explore en détail les pièges qui peuvent dérouter les débutants.
Utilisation d’un environnement de développement intégré Dans cette section, vous apprendrez à compiler un programme à l’aide d’Eclipse, un environnement de développement intégré gratuit disponible à l’adresse http://eclipse.org. Eclipse est écrit en Java mais, comme il utilise une bibliothèque de fenêtre non standard, il n’est pas aussi portable que Java. Il en existe néanmoins des versions pour Linux, Mac OS X, Solaris et Windows. Il existe d’autres IDE populaires mais Eclipse est actuellement le plus usité. Voici les étapes de démarrage : 1. Après le démarrage d’Eclipse, choisissez File -> New Project. 2. Sélectionnez "Java Project" dans la boîte de dialogue de l’assistant (voir Figure 2.4). Ces captures d’écran proviennent d’Eclipse 3.2. Votre version sera peut-être légèrement différente. 3. Cliquez sur Next. Indiquez le nom du projet, à savoir "Welcome", et tapez le nom de chemin complet jusqu’au répertoire qui contient Welcome.java ; consultez la Figure 2.5. 4. Vérifiez que l’option intitulée "Create project in workspace" est décochée. 5. Cliquez sur Finish. Le projet est maintenant créé.
Livre Java.book Page 32 Mercredi, 13. février 2008 2:34 14
32
Au cœur de Java 2 - Notions fondamentales
Figure 2.4 Boîte de dialogue New Project dans Eclipse.
Figure 2.5 Configuration d’un projet Eclipse.
Livre Java.book Page 33 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
33
6. Cliquez sur le triangle situé dans le volet de gauche près de la fenêtre de projet pour l’ouvrir, puis cliquez sur le triangle près de "Default package". Double-cliquez sur Welcome.java. Une fenêtre s’ouvre avec le code du programme (voir Figure 2.6). Figure 2.6 Modification d’un fichier source avec Eclipse.
7. Cliquez du bouton droit sur le nom du projet (Welcome), dans le volet le plus à gauche. Sélectionnez Run -> Run As -> Java Application. Une fenêtre apparaît au bas de la fenêtre. Le résultat du programme s’y affiche (voir Figure 2.7). Figure 2.7 Exécution d’un programme dans Eclipse.
Livre Java.book Page 34 Mercredi, 13. février 2008 2:34 14
34
Au cœur de Java 2 - Notions fondamentales
Localiser les erreurs de compilation Notre programme ne devrait pas contenir d’erreur de frappe ou de bogue (après tout, il ne comprend que quelques lignes de code). Supposons, pour la démonstration, qu’il contienne une coquille (peutêtre même une erreur de syntaxe). Essayez d’exécuter le fichier en modifiant la casse de String de la façon suivante : public static void main(string[] args)
Compilez à nouveau le programme. Vous obtiendrez des messages d’erreur (voir Figure 2.8) qui signalent un type string inconnu. Cliquez simplement sur le message. Le curseur se positionne sur la ligne correspondante dans la fenêtre d’édition. Ce comportement vous permet de corriger rapidement vos erreurs. ASTUCE Bien souvent, un rapport d’erreur d’Eclipse est accompagné de l’icône d’une ampoule. Cliquez dessus pour obtenir une liste des correctifs proposés.
Figure 2.8 Des messages d’erreur dans Eclipse.
Ces instructions doivent vous amener à vouloir travailler dans un environnement intégré. Nous étudierons le débogueur Eclipse au Chapitre 11.
Livre Java.book Page 35 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
35
Exécution d’une application graphique Le programme Welcome ne présentait pas beaucoup d’intérêt. Exécutons maintenant une application graphique. Il s’agit d’un afficheur simple de fichiers image. Compilons ce programme et exécutonsle depuis la ligne de commande. 1. Ouvrez une fenêtre shell. 2. Placez-vous sur le répertoire CoreJavaBook/v1ch02/ImageViewer. 3. Tapez : javac ImageViewer.java java ImageViewer
Une nouvelle fenêtre de programme apparaît avec notre visionneuse, ImageViewer (voir Figure 2.9). Sélectionnez maintenant File/Open et recherchez une image à ouvrir (nous avons inclus quelques exemples de fichiers dans le même répertoire). Pour fermer le programme, cliquez sur le bouton de fermeture dans la barre de titre ou déroulez le menu système et choisissez Quitter (pour compiler et exécuter ce programme dans un éditeur de texte ou un environnement de développement intégré, procédez comme précédemment. Par exemple, dans le cas d’Emacs, choisissez JDE -> Compile, puis JDE -> Run App. Figure 2.9 Exécution de l’application ImageViewer.
Nous espérons que vous trouverez ce programme pratique et intéressant. Examinez rapidement le code source. Ce programme est plus long que le précédent, mais il n’est pas très compliqué en comparaison avec la quantité de code qui aurait été nécessaire pour écrire une application analogue en C ou C++. Ce type de programme est bien sûr très facile à écrire avec Visual Basic ou plutôt à copier et coller. Le JDK ne propose pas de générateur d’interface visuel, vous devez donc tout programmer à la main (voir Listing 2.2). Vous apprendrez à créer des programmes graphiques tels que celui-ci aux Chapitres 7 à 9.
Livre Java.book Page 36 Mercredi, 13. février 2008 2:34 14
36
Au cœur de Java 2 - Notions fondamentales
Listing 2.2 : ImageViewer.java import import import import
java.awt.EventQueue; java.awt.event.*; java.io.*; javax.swing.*;
/** * Un programme permettant d’afficher des images. * @version 1.22 2007-05-21 * @author Cay Horstmann */ public class ImageViewer { public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { JFrame frame = new ImageViewerFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }); } } /** * Un cadre avec une étiquette permettant d’afficher une image. */ class ImageViewerFrame extends JFrame { public ImageViewerFrame() { setTitle("ImageViewer"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); // utiliser une étiquette pour afficher les images label = new JLabel(); add(label); // configurer le sélecteur de fichiers chooser = new JFileChooser(); chooser.setCurrentDirectory(new File(".")); // configurer la barre de menus JMenuBar menuBar = new JMenuBar(); setJMenuBar(menuBar); JMenu menu = new JMenu("File"); menuBar.add(menu); JMenuItem openItem = new JMenuItem("Open"); menu.add(openItem); openItem.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) {
Livre Java.book Page 37 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
37
// montrer la boîte de dialogue du sélecteur int result = chooser.showOpenDialog(null); // en cas de sélection d’un fichier, définir comme icône // de l’étiquette if (result == JFileChooser.APPROVE_OPTION) { String name = chooser.getSelectedFile().getPath(); label.setIcon(new ImageIcon(name)); } } }); JMenuItem exitItem = new JMenuItem("Exit"); menu.add(exitItem); exitItem.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) { System.exit(0); } }); } private private private private
JLabel label; JFileChooser chooser; static final int DEFAULT_WIDTH = 300; static final int DEFAULT_HEIGHT = 400;
}
Elaboration et exécution d’applets Les deux premiers programmes présentés dans cet ouvrage sont des applications Java, des programmes autonomes comme tout programme natif. Comme nous l’avons mentionné dans le dernier chapitre, la réputation de Java est due en grande partie à sa capacité à exécuter des applets dans un navigateur Web. Nous allons vous montrer comment créer et exécuter un applet à partir de la ligne de commande. Puis nous allons charger l’applet dans l’éditeur d’applets fourni avec le JDK et enfin, nous l’afficherons dans un navigateur Web. Ouvrez un shell et placez-vous dans le répertoire CoreJavaBook/v1ch02/WelcomeApplet, puis saisissez les commandes suivantes : javac WelcomeApplet.java appletviewer WelcomeApplet.html
La Figure 2.10 montre ce que vous voyez dans la fenêtre de l’afficheur d’applets. La première commande, qui nous est maintenant familière, est la commande d’appel du compilateur Java. Celui-ci compile le fichier source WelcomeApplet.java et produit le fichier de bytecodes WelcomeApplet.class. Cependant, nous n’exécutons pas cette fois l’interpréteur Java, mais nous invoquons le programme appletviewer. Ce programme est un outil particulier inclus avec le JDK qui vous permet de tester rapidement un applet. Vous devez lui transmettre un nom de fichier HTML plutôt que le nom d’un fichier de classe java. Le contenu du fichier WelcomeApplet.html est présenté dans le Listing 2.3 ci-après.
Livre Java.book Page 38 Mercredi, 13. février 2008 2:34 14
38
Au cœur de Java 2 - Notions fondamentales
Figure 2.10 L’applet WelcomeApplet dans l’afficheur d’applets.
Listing 2.3 : WelcomeApplet.html WelcomeApplet
This applet is from the book Core Java by Cay Horstmann and Gary Cornell, published by Sun Microsystems Press.
The source.
Si vous connaissez le code HTML, vous remarquerez quelques instructions standard et la balise applet qui demande à l’afficheur de charger l’applet dont le code est stocké dans WelcomeApplet.class. Cet afficheur d’applets ignore toutes les balises HTML excepté la balise applet. Malheureusement, la situation des navigateurs est un peu confuse. m
Firefox prend en charge Java sous Windows, Linux et Mac OS X. Pour tester ces applets, téléchargez simplement la dernière version, rendez-vous sur le site http://java.com et utilisez le système de vérification des versions pour chercher si vous devez installer le plug-in Java.
m
Certaines versions d’Internet Explorer ne prennent pas du tout en charge Java. D’autres ne prennent en charge que la très obsolète machine virtuelle Microsoft Java. Si vous exécutez Internet Explorer, accédez à l’adresse http://java.com et installez le plug-in Java.
m
Safari est intégré dans l’implémentation Macintosh Java de Macintosh sous OS X, qui prend en charge Java SE 5.0 au moment où nous rédigeons.
A condition d’avoir un navigateur compatible avec une version moderne de Java, vous pouvez tenter de charger l’applet dans le navigateur.
Livre Java.book Page 39 Mercredi, 13. février 2008 2:34 14
Chapitre 2
L’environnement de programmation de Java
39
1. Démarrez votre navigateur. 2. Sélectionnez Fichier -> Ouvrir (ou l’équivalent). 3. Placez-vous sur le répertoire CoreJavaBook/v1ch02/WelcomeApplet. Vous devez voir apparaître le fichier WelcomeApplet.html dans la boîte de dialogue. Chargez le fichier. 4. Votre navigateur va maintenant charger l’applet avec le texte qui l’entoure. Votre écran doit ressembler à celui de la Figure 2.11. Vous pouvez constater que cette application est réellement dynamique et adaptée à l’environnement Internet. Cliquez sur le bouton Cay Horstmann, l’applet commande au navigateur d’afficher la page Web de Cay. Cliquez sur le bouton Gary Cornell, l’applet lance l’affichage d’une fenêtre de courrier électronique avec l’adresse e-mail de Gary préenregistrée. Figure 2.11 Exécution de l’applet WelcomeApplet dans un navigateur.
Vous remarquerez qu’aucun de ces deux boutons ne fonctionne dans l’afficheur d’applets. Cet afficheur n’a pas la possibilité d’envoyer du courrier ou d’afficher une page Web, il ignore donc vos demandes. L’afficheur d’applets est uniquement destiné à tester les applets de façon isolée, mais vous devrez placer ces dernières dans un navigateur pour contrôler leur interaction avec le navigateur et Internet. Pour terminer, le code de l’applet est présenté dans le Listing 2.4. A ce niveau de votre étude, contentez-vous de l’examiner rapidement. Nous reviendrons sur l’écriture des applets au Chapitre 10. Listing 2.4 : WelcomeApplet.java import import import import
java.awt.*; java.awt.event.*; java.net.*; javax.swing.*;
Livre Java.book Page 40 Mercredi, 13. février 2008 2:34 14
40
Au cœur de Java 2 - Notions fondamentales
/** * Cet applet affiche un message des auteurs. * @version 1.22 2007-04-08 * @author Cay Horstmann */ public class WelcomeApplet extends JApplet { public void init() { EventQueue.invokeLater(new Runnable() { public void run() { setLayout(new BorderLayout()); JLabel label = new JLabel(getParameter("greeting"), SwingConstants.CENTER); label.setFont(new Font("Serif", Font.BOLD, 18)); add(label, BorderLayout.CENTER); JPanel panel = new JPanel(); JButton cayButton = new JButton("Cay Horstmann"); cayButton.addActionListener(makeAction ("http://www.horstmann.com")); panel.add(cayButton); JButton garyButton = new JButton("Gary Cornell"); garyButton.addActionListener(makeAction ("mailto:
[email protected]")); panel.add(garyButton); add(panel, BorderLayout.SOUTH); } }); } private ActionListener makeAction(final String urlString) { return new ActionListener() { public void actionPerformed(ActionEvent event) { try { getAppletContext().showDocument(new URL(urlString)); } catch(MalformedURLException e) { e.printStackTrace(); } } }; } }
Au cours de ce chapitre, vous avez appris les mécanismes de la compilation et de l’exécution des programmes Java. Vous êtes maintenant prêt à aborder le Chapitre 3, où vous attaquerez l’apprentissage du langage Java.
Livre Java.book Page 41 Mercredi, 13. février 2008 2:34 14
3 Structures fondamentales de la programmation Java Au sommaire de ce chapitre
✔ Un exemple simple de programme Java ✔ Commentaires ✔ Types de données ✔ Variables ✔ Opérateurs ✔ Chaînes ✔ Entrées et sorties ✔ Flux de contrôle ✔ Grands nombres ✔ Tableaux Nous supposons maintenant que vous avez correctement installé le JDK et que vous avez pu exécuter les exemples de programmes proposés au Chapitre 2. Il est temps d’aborder la programmation. Ce chapitre vous montrera comment sont implémentés en Java certains concepts fondamentaux de la programmation, tels que les types de données, les instructions de branchement et les boucles. Malheureusement, Java ne permet pas d’écrire facilement un programme utilisant une interface graphique — il faut connaître de nombreuses fonctionnalités pour construire des fenêtres, ajouter des zones de texte, des boutons et les autres composants d’une interface. La présentation des techniques exigées par une interface graphique nous entraînerait trop loin de notre sujet — les concepts fondamentaux de la programmation — et les exemples de programmes proposés dans ce chapitre ne seront que des programmes conçus pour illustrer un concept. Tous ces exemples utilisent simplement une fenêtre shell pour l’entrée et la sortie d’informations.
Livre Java.book Page 42 Mercredi, 13. février 2008 2:34 14
42
Au cœur de Java 2 - Notions fondamentales
Si vous êtes un programmeur C++ expérimenté, vous pouvez vous contenter de parcourir ce chapitre et de vous concentrer sur les rubriques Info C++. Les programmeurs qui viennent d’un autre environnement, comme Visual Basic, rencontreront à la fois des concepts familiers et une syntaxe très différente : nous leur recommandons de lire ce chapitre attentivement.
Un exemple simple de programme Java Examinons le plus simple des programmes Java ; il se contente d’afficher un message à la console : public class FirstSample { public static void main(String[] args) { System.out.println("We will not use ’Hello, World!’"); } }
Même si cela doit prendre un peu de temps, il est nécessaire de vous familiariser avec la présentation de cet exemple ; les éléments qui le composent se retrouveront dans toutes les applications. Avant tout, précisons que Java est sensible à la casse des caractères (majuscules et minuscules). Si vous commettez la moindre erreur en tapant, par exemple, Main au lieu de main, le programme ne pourra pas s’exécuter ! Etudions maintenant le code source, ligne par ligne. Le mot clé public est appelé un modificateur d’accès (ou encore un spécificateur d’accès ou spécificateur de visibilité) ; les modificateurs déterminent les autres parties du programme qui peuvent être utilisées par notre exemple. Nous reparlerons des modificateurs au Chapitre 5. Le mot clé class est là pour vous rappeler que tout ce que l’on programme en Java se trouve à l’intérieur d’une classe. Nous étudierons en détail les classes dans le prochain chapitre, mais considérez dès à présent qu’une classe est une sorte de conteneur renfermant la logique du programme qui définit le comportement d’une application. Comme nous l’avons vu au Chapitre 1, les classes sont des briques logicielles avec lesquelles sont construites toutes les applications ou applets Java. Dans un programme Java, tout doit toujours se trouver dans une classe. Derrière le mot clé class se trouve le nom de la classe. Les règles de Java sont assez souples en ce qui concerne l’attribution des noms de classes. Ceux-ci doivent commencer par une lettre et peuvent ensuite contenir n’importe quelle combinaison de lettres et de chiffres. Leur taille n’est pas limitée. Il ne faut cependant pas attribuer un mot réservé de Java (comme public ou class) à un nom de classe (vous trouverez une liste des mots réservés dans l’Annexe). Comme vous pouvez le constater avec notre classe FirstSample, la convention généralement admise est de former les noms de classes avec des substantifs commençant par une majuscule. Lorsqu’un nom est constitué de plusieurs mots, placez l’initiale de chaque mot en majuscule. Il faut donner au fichier du code source le même nom que celui de la classe publique, avec l’extension .java. Le code sera donc sauvegardé dans un fichier baptisé FirstSample.java (répétons que la casse des caractères est importante, il ne faut pas nommer le fichier firstsample.java). Si vous n’avez pas commis d’erreur de frappe en nommant le fichier et en tapant le code source, la compilation de ce code produira un fichier contenant le pseudo-code de la classe. Le compilateur Java nomme automatiquement le fichier de pseudo-code FirstSample.class et le sauvegarde dans le même répertoire que le fichier source. Lorsque tout cela est terminé, lancez le programme à l’aide de la commande suivante : java FirstSample.
Livre Java.book Page 43 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
43
Ne spécifiez pas l’extension .class. L’exécution du programme affiche simplement la chaîne We will not use ’Hello, World’! à la console. Lorsque vous tapez la commande java NomDeClasse
pour lancer un programme compilé, la machine virtuelle démarre toujours l’exécution par les instructions de la méthode main de la classe spécifiée. Par conséquent, vous devez écrire une méthode main dans le fichier source de la classe pour que le code puisse être exécuté. Bien entendu, il est possible d’ajouter vos propres méthodes à une classe et de les appeler à partir de la méthode main (vous verrez au prochain chapitre comment écrire vos propres méthodes). INFO Selon la spécification du langage Java, la méthode main doit être déclarée public. La spécification est le document officiel qui décrit le langage Java. Vous pouvez le consulter ou le télécharger à l’adresse http://java.sun.com/docs/ books/jls. Toutefois, plusieurs versions du lanceur Java avaient pour intention d’exécuter les programmes Java même lorsque la méthode main n’était pas public. Un programmeur a alors rédigé un rapport de bogue. Pour le voir, consultez le site http://bugs.sun.com/bugdatabase/index.jsp et entrez le numéro d’identification 4252539. Le bogue a toutefois fait l’objet de la mention "clos, ne sera pas résolu". Un ingénieur Sun a ajouté une explication indiquant que la spécification de la machine virtuelle (à l’adresse http://java.sun.com/docs/books/vmspec) n’obligeait pas à ce que main soit public et a précisé que "le résoudre risquait d’entraîner des problèmes". Heureusement, le bon sens a fini par parler. Le lanceur Java de Java SE 1.4 et au-delà oblige à ce que la méthode main soit public. Cette histoire est assez intéressante. D’un côté, il est désagréable de voir que des ingénieurs d’assurance qualité, souvent débordés et pas toujours au fait des aspects pointus de Java, prennent des décisions contestables sur les rapports de bogues. De l’autre, il est remarquable que Sun place les rapports de bogues et leurs résolutions sur le Web, afin que tout le monde puisse les étudier. La "parade des bogues" est une ressource très utile pour les programmeurs. Vous pouvez même "voter" pour votre bogue favori. Ceux qui réuniront le plus de suffrages pourraient bien être résolus dans la prochaine version du JDK.
Remarquez les accolades dans le code source. En Java, comme en C/C++, les accolades sont employées pour délimiter les parties (généralement appelées blocs) de votre programme. En Java, le code de chaque méthode doit débuter par une accolade ouvrante { et se terminer par une accolade fermante }. La manière d’employer des accolades a provoqué une inépuisable controverse. Nous employons dans cet ouvrage un style d’indentation classique, en alignant les accolades ouvrantes et fermantes de chaque bloc. Comme les espaces ne sont pas pris en compte par le compilateur, vous pouvez utiliser le style de présentation que vous préférez. Nous reparlerons de l’emploi des accolades lorsque nous étudierons les boucles. Pour l’instant, ne vous préoccupez pas des mots clés static void, songez simplement qu’ils sont nécessaires à la compilation du programme. Cette curieuse incantation vous sera familière à la fin du Chapitre 4. Rappelez-vous surtout que chaque application Java doit disposer d’une méthode main déclarée de la manière suivante : public class NomDeClasse { public static void main(String[] args) { Instructions du programme } }
Livre Java.book Page 44 Mercredi, 13. février 2008 2:34 14
44
Au cœur de Java 2 - Notions fondamentales
INFO C++ Les programmeurs C++ savent ce qu’est une classe. Les classes Java sont comparables aux classes C++, mais certaines différences risquent de vous induire en erreur. En Java, par exemple, toutes les fonctions sont des méthodes d’une classe quelconque (la terminologie standard les appelle des méthodes et non des fonctions membres). Ainsi, Java requiert que la méthode main se trouve dans une classe. Sans doute êtes-vous également familiarisé avec la notion de fonction membre statique en C++. Il s’agit de fonctions membres définies à l’intérieur d’une classe et qui n’opèrent pas sur des objets. En Java, la méthode main est toujours statique. Précisons enfin que, comme en C/C++, le mot clé void indique que la méthode ne renvoie aucune valeur. Contrairement à C/C++, la méthode main ne renvoie pas un "code de sortie" au système d’exploitation. Si la méthode main se termine normalement, le programme Java a le code de sortie 0 qui l’indique. Pour terminer le programme avec un code de sortie différent, utilisez la méthode System.exit.
Portez maintenant votre attention sur ce fragment de code : { System.out.println("We will not use ’Hello, World!’"); }
Les accolades délimitent le début et la fin du corps de la méthode. Celle-ci ne contient qu’une seule instruction. Comme dans la plupart des langages de programmation, vous pouvez considérer les instructions Java comme les phrases du langage. En Java, chaque instruction doit se terminer par un point-virgule. En particulier, les retours à la ligne ne délimitent pas la fin d’une instruction, et une même instruction peut donc occuper plusieurs lignes en cas de besoin. Le corps de la méthode main contient une instruction qui envoie une ligne de texte vers la console. Nous employons ici l’objet System.out et appelons sa méthode println. Remarquez que le point sert à invoquer la méthode. Java utilise toujours la syntaxe objet.méthode(paramètres)
pour ce qui équivaut à un appel de fonction. Dans ce cas précis, nous appelons la méthode println et lui passons une chaîne en paramètre. La méthode affiche la chaîne sur la console. Elle passe ensuite à la ligne afin que chaque appel à println affiche la chaîne spécifiée sur une nouvelle ligne. Notez que Java, comme C/C++, utilise les guillemets pour délimiter les chaînes (pour plus d’informations, voir la section de ce chapitre consacrée aux chaînes). Comme les fonctions de n’importe quel langage de programmation, les méthodes de Java peuvent utiliser zéro, un ou plusieurs paramètres (certains langages les appellent arguments). Même si une méthode ne prend aucun paramètre, il faut néanmoins employer des parenthèses vides). Il existe par exemple une variante sans paramètres de la méthode println qui imprime une ligne vide. Elle est invoquée de la façon suivante : System.out.println();
INFO
System.out dispose également d’une méthode print qui n’ajoute pas de retour à la ligne en sortie. Par exemple, System.out.print("Bonjour") imprime "Bonjour" sans retourner à la ligne. La sortie suivante apparaîtra immédiatement derrière le "r" de "Bonjour".
Livre Java.book Page 45 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
45
Commentaires Les commentaires de Java, comme ceux de la plupart des langages de programmation, n’apparaissent pas dans le programme exécutable. Vous pouvez donc ajouter autant de commentaires que vous le souhaitez sans craindre de gonfler la taille du code compilé. Java propose trois types de commentaires. Le plus courant est //, qui débute un commentaire allant jusqu’à la fin de ligne : System.out.println("We will not use ’Hello, World!’"); // Ce gag est-il trop connu ?
Lorsque des commentaires plus longs sont nécessaires, il est possible de placer // au début de chaque ligne, ou vous pouvez utiliser /* et */ pour délimiter le début et la fin d’un long commentaire. Nous voyons ce type de délimiteur au Listing 3.1. Listing 3.1 : FirstSample.java /** * Voici le premier exemple de programme de Au coeur de Java, Chapitre 3 * @version 1.01 1997-03-22 * @author Gary Cornell */ public class FirstSample { public static void main(String[] args) { System.out.println("We will not use ’Hello, World!’"); } }
Il existe un troisième type de commentaire utilisable pour la génération automatique de documentation. Ce type de commentaire commence par /** et se termine par */. Pour en savoir plus sur la génération automatique de documentation, consultez le Chapitre 4. ATTENTION Les commentaires /* */ ne peuvent pas être imbriqués en Java. Autrement dit, pour désactiver un bloc de code, il ne suffit pas de l’enfermer entre un /* et un */, car ce bloc peut lui-même contenir un délimiteur */.
Types de données Java est un langage fortement typé. Cela signifie que le type de chaque variable doit être déclaré. Il existe huit types primitifs en Java. Quatre d’entre eux sont des types entiers (integer), deux sont des types réels à virgule flottante, un est le type caractère char utilisé pour le codage Unicode (voir la section consacrée au type char) et le type boolean, pour les valeurs booléennes (vrai/faux). INFO Java dispose d’un package arithmétique de précision arbitraire. Cependant, les "grands nombres", comme on les appelle, sont des objets Java et ne constituent pas un nouveau type Java. Vous apprendrez à les utiliser plus loin dans ce chapitre.
Livre Java.book Page 46 Mercredi, 13. février 2008 2:34 14
46
Au cœur de Java 2 - Notions fondamentales
Entiers Les types entiers représentent les nombres sans partie décimale. Les valeurs négatives sont autorisées. Java dispose des quatre types présentés au Tableau 3.1. Tableau 3.1 : Les types entiers de Java
Type
Occupation en mémoire
Intervalle (limites incluses)
int
4 octets
– 2 147 483 648 à 2 147 483 647 (un peu plus de 2 milliards)
short
2 octets
– 32768 à 32767
long
8 octets
– 9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
byte
1 octet
– 128 à 127
Le type int se révèle le plus pratique dans la majorité des cas. Bien entendu, si vous désirez exprimer le nombre des habitants de la planète, vous devrez employer le type long. Les types byte et short sont essentiellement destinés à des applications spécialisées, telles que la gestion bas niveau des fichiers ou la manipulation de tableaux volumineux, lorsque l’occupation mémoire doit être réduite au minimum. En Java, la plage valide des types de nombres entiers ne dépend pas de la machine sur laquelle s’exécute le code. Cela épargne bien des efforts au programmeur souhaitant porter un logiciel d’une plate-forme vers une autre, ou même entre différents systèmes d’exploitation sur une même plate-forme. En revanche, les programmes C et C++ utilisent le type d’entier le plus efficace pour chaque processeur. Par conséquent, un programme C qui fonctionne bien sur un processeur 32 bits peut provoquer un dépassement de capacité sur un système 16 bits. Comme les programmes Java doivent s’exécuter de la même manière sur toutes les machines, les plages de valeur des différents types sont fixes. Le suffixe des entiers longs est L (par exemple, 4000000000L). Le préfixe des entiers hexadécimaux est 0x (par exemple, 0xCAFE). Les valeurs octales ont le préfixe 0. Par exemple, 010 vaut 8. Cela peut prêter à confusion, il est donc déconseillé d’avoir recours aux constantes octales.
INFO C++ En C et C++, int représente le type entier qui dépend de l’ordinateur cible. Sur un processeur 16 bits, comme le 8086, les entiers sont codés sur 2 octets. Sur un processeur 32 bits, comme le SPARC de Sun, ils sont codés sur 4 octets. Sur un Pentium Intel, le codage du type entier C et C++ dépend du système d’exploitation : 2 octets sous DOS et Windows 3.1, 4 octets sous Windows en mode 32 bits. En Java, la taille de tous les types numériques est indépendante de la plate-forme utilisée. Remarquez que Java ne possède pas de type non signé.
Livre Java.book Page 47 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
47
Types à virgule flottante Les types à virgule flottante expriment les nombres réels disposant d’une partie décimale. Il existe deux types à virgule flottante, présentés au Tableau 3.2. Tableau 3.2 : Les types à virgule flottante
Type
Occupation en mémoire
Intervalle
float
4 octets
Environ ± 3.40282347E + 38F (6 ou 7 décimales significatives)
double
8 octets
Environ ± 1.79769313486231570E + 308 (15 chiffres significatifs)
Le terme double indique que les nombres de ce type ont une précision deux fois supérieure à ceux du type float (on les appelle parfois nombres à double précision). On choisira de préférence le type double dans la plupart des applications. La précision limitée de float se révèle insuffisante dans de nombreuses situations. On ne l’emploiera que dans les rares cas où la vitesse de calcul (plus élevée pour les nombres à précision simple) est importante pour l’exécution, ou lorsqu’une grande quantité de nombres doit être stockée (afin d’économiser la mémoire). Les nombres de type float ont pour suffixe F, par exemple 3.402F. Les nombres à décimales exprimés sans ce suffixe F, par exemple 3.402, sont toujours considérés comme étant du type double. Pour ces derniers, il est également possible de spécifier un suffixe D, par exemple 3.402D. INFO Depuis Java SE 5.0, vous pouvez spécifier des nombres à virgule flottante en hexadécimal. Par exemple, 0.125 = 2–3 équivaut à 0x1.0p-3. Dans la notation hexadécimale, vous utilisez p, et non e, pour indiquer un exposant.
Tous les calculs en virgule flottante respectent la spécification IEEE 754. En particulier, il existe trois valeurs spéciales en virgule flottante, qui servent à indiquer les dépassements et les erreurs : m
infinité positive ;
m
infinité négative ;
m
NaN (Not a Number — pas un nombre).
Par exemple, le résultat de la division d’un nombre positif par 0 est "infinité positive". Le calcul 0/0 ou la racine carrée d’un nombre négatif donne "NaN". INFO Il existe des constantes Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY et Double.NaN (ainsi que les constantes correspondantes Float) permettant de représenter ces valeurs spéciales. Elles sont cependant rarement utilisées dans la pratique. En particulier, vous ne pouvez tester if (x == Double.NaN) // n’est jamais vrai
pour vérifier si un résultat particulier est égal à Double.NaN. Toutes les valeurs "pas un nombre" sont considérées comme distinctes. Vous pouvez cependant employer la méthode Double.isNaN : if (Double.isNaN(x)) // vérifier si x est "pas un nombre"
Livre Java.book Page 48 Mercredi, 13. février 2008 2:34 14
48
Au cœur de Java 2 - Notions fondamentales
ATTENTION Les nombres à virgule flottante ne conviennent pas aux calculs financiers, dans lesquels les erreurs d’arrondi sont inadmissibles. La commande System.out.println(2.0 - 1.1) produit 0.8999999999999999, et non 0.9 comme vous pourriez le penser. Ces erreurs d’arrondi proviennent du fait que les nombres à virgule flottante sont représentés dans un système de nombres binaires. Il n’existe pas de représentation binaire précise de la fraction 1/10, tout comme il n’existe pas de représentation précise de la fraction 1/3 dans le système décimal. Si vous voulez obtenir des calculs numériques précis sans erreurs d’arrondi, utilisez la classe BigDecimal, présentée plus loin dans ce chapitre.
Le type char Le type char sert à décrire des caractères individuels. Le plus souvent, il s’agira de constantes de caractères. Par exemple, ’A’ est une constante de caractère de valeur 65. Elle diffère de "A", une chaîne contenant un seul caractère. Les unités de code Unicode peuvent s’exprimer sous forme de valeurs hexadécimales allant de \u0000 à \uFFFF. Ainsi, \u2122 correspond au symbole de marque commerciale (™) et \u03C0 correspond à la lettre grecque Pi (π). Outre les séquences d’échappement \u, indiquant le codage en Unicode, il existe plusieurs séquences d’échappement pour les caractères spéciaux, comme cela est indiqué au Tableau 3.3. Vous pouvez les utiliser dans des constantes et des chaînes de caractères, comme ’\u2122’ ou "Hello\ n". La séquence d’échappement \u (mais aucune des autres séquences d’échappement) peut même être utilisée en dehors des constantes et des chaînes de caractères entre apostrophes ou entre guillemets. L’exemple : public static void main(String\u005B\u005D args)
est tout à fait autorisé, \u005B et \u005D sont les codages pour [ et ]. Tableau 3.3 : Séquences d’échappement pour les caractères spéciaux
Séquence d’échappement
Nom
Valeur Unicode
\b
Retour arrière
\u0008
\t
Tabulation
\u0009
\n
Séparation de ligne
\u000a
\r
Retour chariot
\u000d
\"
Guillemet
\u0022
\’
Apostrophe
\u0027
\\
Barre oblique inverse
\u005c
Pour bien comprendre le type char, vous devez connaître le schéma de codage Unicode. Unicode a été inventé pour surmonter les limitations des schémas de codage traditionnels. Avant lui, il existait de nombreuses normes différentes : ASCII aux Etats-Unis, ISO 8859-1 pour les langues d’Europe de l’Est, KOI-8 pour le russe, GB18030 et BIG-5 pour le chinois, etc. Deux problèmes se posaient. Une valeur de code particulière correspondait à des lettres différentes selon le schéma de codage.
Livre Java.book Page 49 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
49
De plus, le codage des langues ayant de grands jeux de caractères avait des longueurs variables : certains caractères communs étaient codés sous la forme d’octets simples, d’autres nécessitaient deux octets ou plus. Unicode a été conçu pour résoudre ces problèmes. Aux débuts des efforts d’unification, dans les années 1980, un code de largeur fixe sur 2 octets était plus que suffisant pour coder tous les caractères utilisés dans toutes les langues du monde, et il restait encore de la place pour une future extension (ou, du moins, c’est ce que l’on pensait). En 1991 est sorti Unicode 1.0, qui utilisait légèrement moins de la moitié des 65 536 valeurs de code disponibles. Java a été conçu dès le départ pour utiliser les caractères Unicode à 16 bits, ce qui constituait une avancée majeure sur les autres langages de programmation, qui utilisaient des caractères sur 8 bits. Malheureusement, au fil du temps, ce qui devait arriver arriva. Unicode a grossi au-delà des 65 536 caractères, principalement du fait de l’ajout d’un très grand jeu d’idéogrammes utilisés pour le chinois, le japonais et le coréen. Le type char à 16 bits est désormais insuffisant pour décrire tous les caractères Unicode. Nous ferons appel à la terminologie pour expliquer comment ce problème a été résolu en Java, et ce depuis Java SE 5.0. Un point de code est une valeur de code associée à un caractère dans un schéma de codage. Dans la norme Unicode, les points de code sont écrits en hexadécimal et préfixés par U+, par exemple U+0041 pour le point de code de la lettre A. Unicode possède des points de code regroupés en 17 plans de codes. Le premier, appelé plan multilingue de base, est constitué des caractères Unicode "classiques" ayant les points de code U+0000 à U+FFFF. Seize autres plans, ayant les points de code U+10000 à U+10FFFF, contiennent les caractères complémentaires. Le codage UTF-16 permet de représenter tous les points de code Unicode dans un code de longueur variable. Les caractères du plan multilingue de base sont représentés sous forme de valeurs de 16 bits, appelées unités de code. Les caractères complémentaires sont englobés sous forme de paires consécutives d’unités de code. Chacune des valeurs d’une paire de codage se situe dans une plage inutilisée de 2 048 octets du plan multilingue de base, appelé zone de remplacement (de U+D800 à U+DBFF pour la première unité de code, de U+DC00 à U+DFFF pour la deuxième unité de code). Ceci est assez intéressant, car vous pouvez immédiatement dire si une unité de code procède à un codage sur un seul caractère ou s’il s’agit de la première ou de la deuxième partie d’un caractère complémentaire. Par exemple, le symbole mathématique pour le jeu d’entiers a le point de code U+1D56B et est codé par les deux unités de code U+D835 et U+DD6B (voir http://en.wikipedia.org/wiki/UTF-16 pour obtenir une description de l’algorithme de codage). En Java, le type char décrit une unité de code en codage UTF-16. Nous recommandons fortement de ne pas utiliser le type char dans vos programmes, à moins d’être à l’aise dans la manipulation des unités de code UTF-16. Il vaut presque mieux traiter les chaînes (ce que nous verrons plus loin) sous forme de types de données abstraits.
Type booléen Le type boolean peut avoir deux valeurs, false (faux) ou true (vrai). Il est employé pour l’évaluation de conditions logiques. Les conversions entre valeurs entières et booléennes sont impossibles.
Livre Java.book Page 50 Mercredi, 13. février 2008 2:34 14
50
Au cœur de Java 2 - Notions fondamentales
INFO C++ En C++, des nombres et même des pointeurs peuvent être employés à la place des valeurs booléennes. La valeur 0 équivaut à la valeur booléenne false, et une valeur non zéro équivaut à true. Ce n’est pas le cas avec Java. Les programmeurs Java sont donc mis en garde contre ce type d’accidents : if (x = 0) // pardon... je voulais dire x == 0
En C++, ce test est compilé et exécuté, il donne toujours le résultat false. En Java, la compilation du test échoue, car l’expression entière x = 0 ne peut pas être convertie en une valeur booléenne.
Variables En Java, toute variable a un type. Vous déclarez une variable en spécifiant d’abord son type, puis son nom. Voici quelques exemples de déclarations : double salary; int vacationDays; long earthPopulation; boolean done;
Remarquez que chaque déclaration se termine par un point-virgule. Il est nécessaire, car une déclaration est une instruction Java complète. Un nom de variable doit débuter par une lettre et doit être une séquence de lettres ou de chiffres. Notez que le sens des termes "lettres" et "chiffres" est plus large en Java que dans beaucoup d’autres langages. Une lettre est définie comme l’un des caractères ’A’...’Z’, ’a’...’z’, ’_’, ou n’importe quel caractère Unicode représentant une lettre dans une langue quelconque. Par exemple, un utilisateur français ou allemand peut employer des caractères accentués, tels que ä ou ê, dans un nom de variable. De même, les lecteurs grecs peuvent utiliser π. D’une manière comparable, un chiffre est un des caractères ’0’ à ’9’, ou n’importe quel caractère Unicode représentant un chiffre dans une langue. Des espaces ou des symboles tels que ’+’ ou © ne peuvent pas être employés. Tous les caractères d’un nom de variable sont significatifs, ainsi que la casse de chaque caractère (minuscule ou majuscule). La longueur possible d’un nom est théoriquement illimitée. ASTUCE Si vous vous demandez lesquels des caractères Unicode sont des "lettres" pour Java, vous pouvez le savoir en appelant les méthodes isJavaIdentifierStart et isJavaIdentifierPart de la classe Character.
Il est évidemment interdit de donner à une variable le même nom qu’un mot réservé de Java (voir, dans l’Annexe, la liste des mots réservés). Il est possible de déclarer plusieurs variables sur une seule ligne, comme suit : int i, j; // ce sont deux entiers en Java
Ce style de déclaration n’est pas recommandé. Si vous définissez chaque variable séparément, vos programmes seront plus faciles à lire.
Livre Java.book Page 51 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
51
INFO Vous avez vu que les noms étaient sensibles à la casse. Par exemple, hireday et hireDay sont deux noms différents. En règle générale, n’employez pas deux noms différant seulement par la casse des caractères. Il est toutefois difficile parfois de définir un nom correct pour une variable. Les programmeurs attribuent alors fréquemment à la variable le même nom que le type, par exemple : Box box; // OK--Box est le type et box le nom de la variable
Cependant, une meilleure solution consiste à attribuer un préfixe "a" à la variable Box aBox;
Initialisation des variables Après avoir déclaré une variable, vous devez explicitement l’initialiser à l’aide d’une instruction d’affectation. Vous ne devez pas utiliser une variable non initialisée. Le compilateur Java signale la suite d’instructions suivantes comme une erreur : int vacationDays; System.out.println(vacationDays); //ERREUR--variable non-initialisée
L’affectation d’une variable déclarée se fait à l’aide du symbole d’égalité (=), précédé à gauche du nom de la variable et suivi à droite par une expression Java représentant la valeur appropriée : int vacationDays; vacationDays = 12;
Une fonctionnalité de Java permet de déclarer et d’initialiser simultanément une variable en une seule instruction, de la façon suivante : int vacationDays = 12;
Précisons enfin que Java permet de déclarer des variables n’importe où dans le code. Par exemple, le code suivant est valide en Java : double salary = 65000.0; System.out.println(salary); int vacationDays = 12; // vous pouvez déclarer la variable ici
En Java, il est recommandé de déclarer les variables aussi près que possible du point de leur première utilisation. INFO C++ C et C++ font une distinction entre une déclaration et une définition de variables. Par exemple, int i = 10;
est une définition, alors que extern int i;
est une déclaration. En Java, il n’y a pas de déclaration séparée de la définition.
Livre Java.book Page 52 Mercredi, 13. février 2008 2:34 14
52
Au cœur de Java 2 - Notions fondamentales
Constantes En Java, le mot clé final sert à désigner une constante. Voici un exemple : public class Constants { public static void main(String[] args) { final double CM_PER_INCH = 2.54; double paperWidth = 8.5; double paperHeight = 11; System.out.println("Paper size in centimeters: " + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH); } }
Le mot clé final signifie que vous affectez une valeur à la variable une seule fois, et une fois pour toutes. Par convention, les noms des constantes sont entièrement en majuscules. Il est plus courant de créer une constante qui est accessible à plusieurs méthodes de la même classe. Les méthodes de ce genre sont appelées généralement constantes de classe. On définit une constante de classe à l’aide des mots clés static final. Voici un exemple utilisant une constante de classe : public class Constants2 { public static void main(String[] args) { double paperWidth = 8.5; double paperHeight = 11; System.out.println("Paper size in centimeters: " + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH); } public static final double CM_PER_INCH = 2.54; }
Notez que la définition de la constante de classe apparaît en dehors de la méthode main. La constante peut donc aussi être employée dans d’autres méthodes de la même classe. De plus, si (comme dans notre exemple), la constante est déclarée public, les méthodes des autres classes peuvent aussi utiliser la constante — sous la forme Constants2.CM_PER_INCH, dans notre exemple. INFO C++ Bien que const soit un mot réservé de Java, il n’est pas utilisé actuellement. C’est le mot clé final qui permet de définir une constante.
Opérateurs Les habituels opérateurs arithmétiques + – * / sont respectivement utilisés en Java pour les opérations d’addition, de soustraction, de multiplication et de division. L’opérateur de division / indique une division entière si les deux arguments sont des entiers et une division en virgule flottante dans les
Livre Java.book Page 53 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
53
autres cas. Le reste d’une division entière est représenté par le symbole %. Par exemple, 15/2 donne 7 ; 15 % 2 donne 1 et 15.0/2 donne 7.5. Notez que la division d’un entier par 0 déclenche une exception, alors que la division d’une valeur en virgule flottante par 0 donne un résultat infini ou NaN. Les opérateurs arithmétiques peuvent être utilisés en combinaison avec l’opérateur d’affectation pour simplifier l’écriture d’une affectation. Par exemple, l’instruction x += 4;
équivaut à l’instruction x = x + 4;
En règle générale, placez l’opérateur arithmétique à gauche du signe =, par exemple *= ou %=. INFO L’un des intérêts évidents de la programmation en langage Java est la portabilité. Un calcul doit aboutir au même résultat quelle que soit la machine virtuelle sur laquelle il est exécuté. Dans le cas de calculs avec des nombres à virgule flottante, il est étonnamment difficile d’obtenir cette portabilité. Le type double utilise 64 bits pour le stockage d’une valeur numérique, mais certains processeurs emploient des registres à virgule flottante de 80 bits. Ces registres ajoutent une précision lors des étapes intermédiaires d’un calcul. Examinez, par exemple, le calcul suivant : double w = x * y / z;
De nombreux processeurs Intel vont calculer x * y et placer le résultat dans un registre 80 bits, puis diviser par z pour finalement tronquer le résultat à 64 bits. Cela peut donner un résultat plus précis et éviter un dépassement d’exposant. Cependant le résultat peut être différent de celui d’un calcul effectué constamment sur 64 bits. Pour cette raison, la spécification initiale de la machine virtuelle Java prévoyait la troncation de tous les calculs intermédiaires, au grand dam de la communauté numérique. Non seulement les calculs tronqués peuvent provoquer un dépassement de capacité, mais ils sont aussi plus lents, du fait du temps nécessaire aux opérations de troncation. C’est pourquoi le langage Java a été actualisé pour tenir compte des besoins conflictuels de performance optimale et de reproductibilité parfaite. Par défaut, les concepteurs de machine virtuelle peuvent maintenant utiliser une précision étendue pour les calculs intermédiaires. Toutefois, les méthodes balisées avec le mot clé strictfp doivent utiliser des opérations virgule flottante strictes menant à des résultats reproductibles. Vous pouvez, par exemple, baliser la méthode main de la façon suivante : public static strictfp void main(String[] args)
Toutes les instructions au sein de main auront alors recours à des calculs virgule flottante stricts. Si vous balisez une classe à l’aide de strictfp, toutes ses méthodes utiliseront les calculs virgule flottante stricts. Les détails sordides dépendent essentiellement du comportement des processeurs Intel. En mode par défaut, les résultats intermédiaires sont autorisés à utiliser un exposant étendu, mais pas une mantisse étendue (les puces Intel gèrent la troncation de la mantisse sans perte de performance). Par conséquent, la seule différence entre les modes par défaut et strict est que les calculs stricts peuvent engendrer des dépassements de capacité, à la différence des calculs par défaut. Si vos yeux s’arrondissent à la lecture de cette Info, ne vous inquiétez pas. Le dépassement de capacité en virgule flottante ne se pose pas pour la majorité des programmes courants. Nous n’utiliserons pas le mot clé strictfp dans cet ouvrage.
Livre Java.book Page 54 Mercredi, 13. février 2008 2:34 14
54
Au cœur de Java 2 - Notions fondamentales
Opérateurs d’incrémentation et de décrémentation Les programmeurs savent évidemment qu’une des opérations les plus courantes effectuées sur une variable numérique consiste à lui ajouter ou à lui retrancher 1. Suivant les traces de C et de C++, Java offre des opérateurs d’incrémentation et de décrémentation : n++ ajoute 1 à la valeur courante n et n-- retranche 1 à cette valeur. Ainsi, cet exemple : int n = 12; n++;
donne à n la valeur 13. Comme ces opérateurs modifient la valeur d’une variable, ils ne peuvent pas être appliqués à des nombres. Par exemple, 4++ n’est pas une instruction valide. Ces opérateurs peuvent en réalité prendre deux formes ; vous avez vu la forme "suffixe", où l’opérateur est situé après l’opérande : n++. Il peut également être placé en préfixe : ++n. Dans les deux cas, la variable est incrémentée de 1. La différence entre ces deux formes n’apparaît que lorsqu’elles sont employées dans des expressions. Lorsqu’il est placé en préfixe, l’opérateur effectue d’abord l’addition ; en suffixe, il fournit l’ancienne valeur de la variable : int int int int
m n a b
= = = =
7; 7; 2 * ++m; // maintenant a vaut 16, m vaut 8 2 * n++; // maintenant b vaut 14, n vaut 8
Nous déconseillons vivement l’emploi de l’opérateur ++ dans d’autres expressions, car cela entraîne souvent un code confus et des bogues difficiles à détecter. L’opérateur ++ a bien évidemment donné son nom au langage C++, mais il a également provoqué une des premières plaisanteries à propos de ce langage. Les anti-C++ ont fait remarquer que même le nom du langage contenait un bogue : "En fait, il devrait s’appeler ++C, car on ne désire employer le langage qu’après son amélioration."
Opérateurs relationnels et booléens Java offre le jeu complet d’opérateurs relationnels. Un double signe égal, ==, permet de tester l’égalité de deux opérandes. Par exemple, l’évaluation de 3 == 7
donne un résultat faux (false). Utilisez != pour pratiquer un test d’inégalité. Par exemple, le résultat de 3 != 7
est vrai (true). De plus, nous disposons des habituels opérateurs < (inférieur à), > (supérieur à), = (supérieur ou égal à). Suivant l’exemple de C++, Java utilise && comme opérateur "et" logique et || comme opérateur "ou" logique. Le point d’exclamation ! représente l’opérateur de négation. Les opérateurs && et || sont évalués de manière optimisée (en court-circuit). Le deuxième argument n’est pas évalué si le premier détermine déjà la valeur. Si vous combinez deux expressions avec l’opérateur &&, expression 1 && expression 2
Livre Java.book Page 55 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
55
la valeur de la deuxième expression n’est pas calculée si la première a pu être évaluée à false (puisque le résultat final serait false de toute façon). Ce comportement peut éviter des erreurs. Par exemple, dans l’expression x != 0 && 1 / x > x + y // pas de division par 0
la seconde partie n’est jamais évaluée si x égale zéro. Par conséquent, 1/x n’est pas calculé si x vaut zéro, et une erreur "division par zéro" ne peut pas se produire. De même, si la première expression est évaluée à true, la valeur de expression1 || expression2 est automatiquement true, sans que la deuxième expression doive être évaluée. Enfin, Java gère l’opérateur ternaire ? qui se révèle utile à l’occasion. L’expression condition ? expression 1 : expression 2
est évaluée à expression1 si la condition est true, à expression2 sinon. Par exemple, x < y ? x : y
donne le plus petit entre x et y.
Opérateurs binaires Lorsqu’on manipule des types entiers, il est possible d’employer des opérateurs travaillant directement sur les bits qui composent ces entiers. Certaines techniques de masquage permettent de récupérer un bit particulier dans un nombre. Les opérateurs binaires sont les suivants : &("et")
|("ou")
^("ou exclusif")
~("non")
Ces opérateurs travaillent sur des groupes de bits. Par exemple, si n est une variable entière, alors la déclaration int quatrièmeBitPartantDeDroite = (n & 8) / 8;
renvoie 1 si le quatrième bit à partir de la droite est à 1 dans la représentation binaire de n, et zéro dans le cas contraire. L’emploi de & avec la puissance de deux appropriée permet de masquer tous les bits sauf un. INFO Lorsqu’ils sont appliqués à des valeurs boolean, les opérateurs & et | donnent une valeur boolean. Ces opérateurs sont comparables aux opérateurs && et ||, excepté que & et | ne sont pas évalués de façon optimisée "court-circuit". C’est-à-dire que les deux arguments sont évalués en premier, avant le calcul du résultat.
Il existe également des opérateurs >> et 3;
Signalons enfin qu’il existe également un opérateur >>> permettant de remplir les bits de poids fort avec des zéros, alors que >> étend le bit de signature dans les bits de poids fort. Il n’existe pas d’opérateur >>>
De la gauche vers la droite
< >= instanceof
De la gauche vers la droite
== !=
De la gauche vers la droite
&
De la gauche vers la droite
^
De la gauche vers la droite
|
De la gauche vers la droite
&&
De la gauche vers la droite
||
De la gauche vers la droite
?:
De la droite vers la gauche
= += -= *= /= %= &= |= ^= = >>>=
De la droite vers la gauche
Types énumérés Une variable ne doit quelquefois contenir qu’un jeu de valeurs limité. Vous pouvez par exemple vendre des vêtements ou des pizzas en quatre formats : petit, moyen, grand, très grand. Bien sûr, ces formats pourraient être codés sous forme d’entiers 1, 2, 3, 4 ou de caractères S, M, L et X. Mais cette configuration est sujette à erreur. Une variable peut trop facilement contenir une valeur erronée (comme 0 ou m). Depuis Java SE 5.0, vous pouvez définir votre propre type énuméré dès qu’une situation se présente. Un type énuméré possède un nombre fini de valeurs nommées. Par exemple, enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };
Livre Java.book Page 60 Mercredi, 13. février 2008 2:34 14
60
Au cœur de Java 2 - Notions fondamentales
Vous pouvez maintenant déclarer des variables de ce type : Size s = Size.MEDIUM;
Une variable de type Size ne peut contenir que l’une des valeurs listées dans la déclaration de type ou la valeur spéciale null qui indique que la variable n’est définie sur aucune valeur. Nous verrons les types énumérés plus en détail au Chapitre 5.
Chaînes Les chaînes sont des suites de caractères Unicode. Par exemple, la chaîne "Java\u2122" est constituée de cinq caractères Unicode J, a, v, a et ™. Java ne possède pas de type chaîne intégré. En revanche, la bibliothèque standard Java contient une classe prédéfinie appelée, assez naturellement, String. Chaque chaîne entre guillemets est une instance de la classe String : String e = ""; // une chaîne vide String greeting = "Hello";
Sous-chaînes Pour extraire une sous-chaîne à partir d’une chaîne plus grande, utilisez la méthode substring de la classe String. Par exemple, String greeting = "Hello"; String s = greeting.substring(0, 3);
crée une chaîne constituée des caractères "Hel". Le deuxième paramètre de substring est la première unité de code que vous ne souhaitez pas copier. Ici, nous voulons copier les unités de code des positions 0, 1 et 2 (de la position 0 à la position 2 incluse). Pour substring, cela va de la position 0 incluse à la position 3 (exclue). On reconnaît un avantage au fonctionnement de substring : il facilite le calcul du nombre d’unités de code présentes dans la sous-chaîne. La chaîne s.substring(a, b) a toujours les unités de code b - a. Par exemple, la sous-chaîne "Hel" a 3 – 0 = 3 unités de code.
Concaténation Java, comme la plupart des langages de programmation, autorise l’emploi du signe + pour joindre (concaténer) deux chaînes : String expletive = "Expletive"; String PG13 = "deleted"; String message = expletive + PG13;
Le code qui précède donne à la variable message le contenu "Expletivedeleted" (remarquez qu’il n’insère pas d’espace entre les mots : le signe + accole les deux chaînes exactement telles qu’elles sont fournies). Lorsque vous concaténez une chaîne et une valeur qui n’est pas une chaîne, cette valeur est convertie en chaîne (comme vous le verrez au Chapitre 5, tout objet Java peut être converti en chaîne).
Livre Java.book Page 61 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
61
Voici un exemple : int age = 13; String rating = "PG" + age;
qui donne à la chaîne rating la valeur "PG13". Cette caractéristique est utilisée couramment pour l’affichage. Par exemple, l’instruction System.out.println("The answer is " + answer);
est parfaitement valide et affichera la réponse voulue avec un espacement correct (notez l’espace derrière le mot is).
Les chaînes sont inaltérables La classe String ne fournit pas de méthode permettant de modifier un caractère dans une chaîne existante. Au cas où vous voudriez transformer le contenu de la variable greeting en "Help!", vous ne pouvez pas remplacer directement la dernière position de greeting par ’p’ et par ’!’. Si vous êtes un programmeur C, vous devez vous sentir frustré. Et, pourtant, la solution est très simple en Java : il suffit de récupérer la sous-chaîne à conserver et de la concaténer avec les caractères à remplacer : greeting = greeting.substring(0, 3) + "p!";
Cette instruction donne à la variable greeting la valeur "Help!". Comme il n’est pas possible de modifier individuellement des caractères dans une chaîne Java, la documentation indique que les objets de la classe String sont inaltérables. Tout comme le nombre 3 vaut toujours 3, la chaîne "Hello" contient toujours la suite de caractères ’H’, ’e’, ’l’, ’l’, ’o’. Il est impossible de changer cette valeur. En revanche, comme nous venons de le voir, il est possible de modifier le contenu de la variable chaîne greeting et de lui faire référencer une chaîne différente (de même qu’une variable numérique contenant la valeur 3 peut recevoir la valeur 4). On pourrait penser que tout cela n’est pas très performant. Ne serait-il pas plus simple de changer les unités de code au lieu de construire une nouvelle chaîne ? Oui et non. En vérité, il n’est pas très intéressant de générer une nouvelle chaîne contenant la concaténation de "Hel" et de "p!". Mais les chaînes inaltérables possèdent pourtant un énorme avantage : le compilateur peut les partager. Pour comprendre cette technique, imaginez que les diverses chaînes résident dans un pool commun. Les variables chaînes, quant à elles, pointent sur des positions dans le pool. Si vous copiez une variable chaîne, la chaîne d’origine et la copie partagent les mêmes caractères. Tout bien considéré, les concepteurs de Java ont estimé que l’efficacité du partage des chaînes surpassait l’inconvénient de la modification des chaînes par extraction de sous-chaînes et concaténation. Examinez vos propres programmes ; la plupart du temps, vous ne modifiez sans doute pas les chaînes — vous vous contentez de les comparer. Bien entendu, il existe des situations où une manipulation directe se révèle plus efficace (par exemple lorsqu’on assemble des chaînes à partir de caractères individuels tapés au clavier ou récupérés dans un fichier). Pour ces cas-là, Java fournit une classe séparée, que nous décrivons plus loin dans ce chapitre.
Livre Java.book Page 62 Mercredi, 13. février 2008 2:34 14
62
Au cœur de Java 2 - Notions fondamentales
INFO C++ Les programmeurs C sont souvent stupéfaits lorsqu’ils rencontrent des chaînes Java pour la première fois, car ils considèrent les chaînes comme des tableaux de caractères : char greeting[] = "Hello";
La comparaison n’est pas bonne ; une chaîne Java ressemble davantage à un pointeur char* : char* greeting = "Hello";
Lorsque vous remplacez la valeur de greeting par une autre chaîne, le code Java exécute à peu près ce qui suit : char* temp = malloc(6); strncpy(temp, greeting, 3); strcpy(temp + 3, "p!", 3); greeting = temp;
greeting pointe maintenant vers la chaîne "Help!". Et même le plus intégriste des programmeurs C doit reconnaître que la syntaxe de Java est plus agréable qu’une série d’appels à strncpy. Mais que se passe-t-il si nous affectons une nouvelle valeur à greeting ? greeting = "Howdy";
La chaîne d’origine ne va-t-elle pas occuper inutilement la mémoire, puisqu’elle a été allouée dans le pool ? Heureusement, Java récupère automatiquement la mémoire libérée. Si un bloc de mémoire n’est plus utilisé, il finira par être recyclé. Si vous programmez en C++ et utilisez la classe string définie par ANSI C++, vous vous sentirez à l’aise avec le type String de Java. Les objets string de C++ se chargent automatiquement de l’allocation et de la récupération de la mémoire. La gestion de la mémoire est accomplie explicitement par les constructeurs, les opérateurs d’affectations et les destructeurs. Cependant, les chaînes C++ sont altérables — il est possible de modifier individuellement un caractère dans une chaîne.
Test d’égalité des chaînes Pour savoir si deux chaînes sont égales, utilisez la méthode equals ; l’expression s.equals(t)
donne true si les chaînes s et t sont égales, et false dans le cas contraire. Notez que s et t peuvent être des variables chaînes ou des constantes chaînes. Par exemple, "Hello".equals(greeting)
est parfaitement valide. Pour tester si deux chaînes sont identiques à l’exception de la casse des caractères, utilisez la méthode equalsIgnoreCase : "Hello".equalsIgnoreCase("hello")
Attention, n’employez pas l’opérateur == pour tester l’égalité de deux chaînes ! Cet opérateur détermine seulement si les chaînes sont stockées au même emplacement. Il est évident que si deux chaînes se trouvent à la même adresse, elles doivent être égales. Mais des copies de chaînes identiques peuvent être stockées à des emplacements différents dans la mémoire : String greeting = "Hello"; //initialise la chaîne greeting if (greeting == "Hello") . . . // probablement vrai
Livre Java.book Page 63 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
63
if (greeting.substring(0, 3) == "Hel") . . . // probablement faux
Si la machine virtuelle faisait en sorte de toujours partager les chaînes identiques, l’opérateur == pourrait être utilisé pour un test d’égalité. Mais seules les constantes chaînes sont partagées, et non les chaînes créées à l’aide de l’opérateur + ou de la méthode substring. Par conséquent, n’employez jamais == pour comparer des chaînes, car cela pourrait générer le pire des bogues : un bogue intermittent qui semble se produire aléatoirement. INFO C++ Si vous êtes familiarisé avec la classe string de C++, vous devez être particulièrement attentif aux tests d’égalité, car la classe string surcharge l’opérateur == pour tester l’égalité du contenu de deux chaînes. Il est peut-être dommage que les chaînes Java aient un "aspect général" comparable à celui des valeurs numériques, mais qu’elles se comportent comme des pointeurs lors des tests d’égalité. Les concepteurs auraient pu redéfinir == pour l’adapter aux chaînes, comme ils l’ont fait pour l’opérateur +, mais aucun langage n’est parfait. Pour comparer des chaînes, les programmeurs C n’emploient pas l’opérateur ==, mais la fonction strcmp. La méthode analogue en langage Java est compareTo. Vous pouvez écrire if (greeting.compareTo("Hello") == 0) . . .
mais il est plus pratique d’appeler la méthode equals.
Points de code et unités de code Les chaînes Java sont implémentées sous forme de suites de valeurs char. Comme nous l’avons vu, le type char est une unité de code permettant de représenter des points de code Unicode en codage UTF-16. Les caractères Unicode les plus souvent utilisés peuvent être représentés par une seule unité de code. Les caractères complémentaires exigent, quant à eux, une paire d’unités de code. La méthode length produit le nombre d’unités de code exigé pour une chaîne donnée dans le codage UTF-16. Par exemple : String greeting = "Hello"; int n = greeting.length(); // vaut 5
Pour obtenir la bonne longueur, c’est-à-dire le nombre de points de code, appelez int cpCount = greeting.codePointCount(0, greeting.length());
L’appel s.chartAt(n) renvoie l’unité de code présente à la position n, où n est compris entre 0 et s.length() -1. Par exemple : char first = greeting.charAt(0); // le premier est ’H’ char last = greeting.charAt(4); // le dernier est ’o’
Pour accéder au ième point de code, utilisez les instructions int index = greeting.offsetByCodePoints(0, i); int cp = greeting.codePointAt(index);
Livre Java.book Page 64 Mercredi, 13. février 2008 2:34 14
64
Au cœur de Java 2 - Notions fondamentales
INFO Java compte les unités de code dans les chaînes d’une manière particulière : la première unité de code d’une chaîne occupe la position 0. Cette convention est née dans le C, à une époque où il existait une raison technique à démarrer les positions à 0. Cette raison a disparu depuis longtemps, et seule la nuisance demeure. Toutefois, les programmeurs sont tellement habitués à cette convention que les concepteurs Java ont décidé de la garder.
Pourquoi nous préoccuper tant des unités de code ? Etudiez la phrase is the set of integers
Le caractère exige deux unités de code en codage UTF-16. Appeler char ch = sentence.charAt(1)
ne renvoie pas un espace mais la deuxième unité de code de . Pour éviter ce problème, il vaut mieux ne pas utiliser le type char, qui est de trop bas niveau. Si votre code traverse une chaîne et que vous souhaitiez étudier chaque point de code tour à tour, utilisez ces instructions : int cp = sentence.codePointAt(i); if (Character.isSupplementaryCodePoint(cp)) i += 2; else i++;
Heureusement, la méthode codePointAt peut dire si une unité de code est la première ou la seconde moitié d’un caractère complémentaire, elle renvoie le bon résultat quel que soit le cas. Ainsi, vous pouvez revenir en arrière avec les instructions suivantes : i--; int cp = sentence.codePointAt(i); if (Character.isSupplementaryCodePoint(cp)) i--;
L’API String La classe String de Java contient plus de 50 méthodes. Beaucoup d’entre elles sont assez utiles pour être employées couramment. La note API qui suit présente les méthodes qui nous semblent les plus intéressantes pour le programmeur. INFO Vous rencontrerez ces notes API dans tout l’ouvrage. Elles vous aideront à comprendre l’interface de programmation Java, ou API (Application Programming Interface). Chaque note API commence par le nom d’une classe, tel que java.lang.String — la signification du nom de package java.lang sera expliquée au Chapitre 4. Le nom de la classe est suivi des noms, explications et descriptions des paramètres d’une ou plusieurs méthodes de cette classe. Nous ne donnons pas la liste de toutes les méthodes d’une classe donnée, mais seulement celles qui sont utilisées le plus fréquemment, décrites sous une forme concise. Consultez la documentation en ligne si vous désirez obtenir une liste complète des méthodes d’une classe. Nous indiquons également le numéro de version dans laquelle une classe particulière a été introduite. Si une méthode a été ajoutée par la suite, elle présente un numéro de version distinct.
Livre Java.book Page 65 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
65
java.lang.String 1.0
•
char charAt(int index)
Renvoie l’unité de code située à la position spécifiée. Vous ne voudrez probablement pas appeler cette méthode à moins d’être intéressé par les unités de code de bas niveau. •
int codePointAt(int index) 5.0
Renvoie le point de code qui démarre ou se termine à l’emplacement spécifié. •
int offsetByCodePoints(int startIndex, int cpCount) 5.0
Renvoie l’indice du point de code d’où pointe cpCount, depuis le point de code jusqu’à startIndex. •
int compareTo(String other)
Renvoie une valeur négative si la chaîne se trouve avant other (dans l’ordre alphabétique), une valeur positive si la chaîne se trouve après other ou un 0 si les deux chaînes sont identiques. •
boolean endsWith(String suffix)
Renvoie true si la chaîne se termine par suffix. •
boolean equals(Object other)
Renvoie true si la chaîne est identique à other. •
boolean equalsIgnoreCase(String other)
Renvoie true si la chaîne est identique à other, sans tenir compte de la casse. • • • •
int indexOf(String str) int indexOf(String str, int fromIndex) int indexOf(int cp) int indexOf(int cp, int fromIndex)
Renvoient la position de départ de la première sous-chaîne égale à str ou au point de code cp, en commençant par la position 0 ou par fromIndex ou –1 si str n’apparaît pas dans cette chaîne. • • • •
int lastIndexOf(String str) int lastIndexOf(String str, int fromIndex) int lastIndexOf(int cp) int lastIndexOf(int cp, int fromIndex)
Renvoient la position de départ de la dernière sous-chaîne égale à str ou au point de code cp, en commençant à la fin de la chaîne ou par fromIndex. •
int length()
Renvoie la taille (ou longueur) de la chaîne. •
int codePointCount(int startIndex, int endIndex) 5.0
Renvoie le nombre de points de code entre startIndex et endIndex - 1. Les substitutions sans paires sont considérées comme des points de code. •
String replace(CharSequence oldString, CharSequence newString)
Renvoie une nouvelle chaîne, obtenue en remplaçant tous les caractères oldString de la chaîne par les caractères newString. Vous pouvez fournir des objets String ou StringBuilder pour les paramètres CharSequence.
Livre Java.book Page 66 Mercredi, 13. février 2008 2:34 14
66
•
Au cœur de Java 2 - Notions fondamentales
boolean startsWith(String prefix)
Renvoie true si la chaîne commence par prefix. • •
String substring(int beginIndex) String substring(int beginIndex, int endIndex)
Renvoient une nouvelle chaîne composée de toutes les unités de code situées entre beginIndex et, soit la fin de la chaîne, soit endIndex - 1. •
String toLowerCase()
Renvoie une nouvelle chaîne composée de tous les caractères de la chaîne d’origine, mais dont les majuscules ont été converties en minuscules. •
String toUpperCase()
Renvoie une nouvelle chaîne composée de tous les caractères de la chaîne d’origine, mais dont les minuscules ont été converties en majuscules. •
String trim()
Renvoie une nouvelle chaîne en éliminant tous les espaces qui auraient pu se trouver devant ou derrière la chaîne d’origine.
Lire la documentation API en ligne Vous avez vu que la classe String comprend quantité de méthodes. Il existe de plus des milliers de classes dans les bibliothèques standard, avec bien d’autres méthodes encore. Il est impossible de mémoriser toutes les classes et méthodes utiles. Il est donc essentiel que vous puissiez facilement consulter la documentation API en ligne concernant les classes et méthodes de la bibliothèque standard. La documentation API fait partie du JDK. Elle est au format HTML. Pointez votre navigateur Web sur le sous-répertoire docs/api/index.html de votre installation JDK. Vous verrez apparaître un écran comme celui de la Figure 3.2. Figure 3.2 Les trois panneaux de la documentation API.
Livre Java.book Page 67 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
67
L’écran est divisé en trois fenêtres. Une petite fenêtre en haut à gauche affiche tous les packages disponibles. Au-dessous, une fenêtre plus grande énumère toutes les classes. Cliquez sur un nom de classe pour faire apparaître la documentation API pour cette classe dans la fenêtre de droite (voir Figure 3.3). Par exemple, pour obtenir des informations sur les méthodes de la classe String, faites défiler la deuxième fenêtre jusqu’à ce que le lien String soit visible, puis cliquez dessus.
Figure 3.3 Description de la classe String.
Faites défiler la fenêtre de droite jusqu’à atteindre le résumé de toutes les méthodes, triées par ordre alphabétique (voir Figure 3.4). Cliquez sur le nom d’une méthode pour afficher sa description détaillée (voir Figure 3.5). Par exemple, si vous cliquez sur le lien compareToIgnoreCase, vous obtiendrez la description de la méthode compareToIgnoreCase. ASTUCE Affectez dès maintenant un signet à la page docs/api/index.html dans votre navigateur.
Livre Java.book Page 68 Mercredi, 13. février 2008 2:34 14
68
Au cœur de Java 2 - Notions fondamentales
Figure 3.4 Liste des méthodes de la classe String.
Figure 3.5 Description détaillée d’une méthode de la classe String.
Livre Java.book Page 69 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
69
Construction de chaînes Pour le traitement d’une saisie, vous devez parfois construire des chaînes à partir de caractères individuels ou de mots d’un fichier. La concaténation serait totalement inefficace dans ce cas. A chaque concaténation, un nouvel objet String est construit. L’opération prend du temps et consomme de la mémoire mais la classe StringBuilder permet d’éviter ce problème. Procédez comme suit pour construire une chaîne à partir de petits éléments. Construisez d’abord un constructeur de chaîne vide : StringBuilder builder = new StringBuilder();
Nous verrons les constructeurs et l’opérateur new en détail au Chapitre 4. Chaque fois que vous devez ajouter une partie, appelez la méthode append. builder.append(ch); // annexe un seul caractère builder.append(str); // annexe une chaîne
Lorsque vous avez terminé de construire la chaîne, appelez la méthode toString. Vous obtiendrez un objet String avec la suite de caractères contenue dans le constructeur. String completedString = builder.toString();
INFO La classe StringBuilder a été introduite dans le JDK 5.0. Son prédécesseur, StringBuffer, est légèrement moins efficace mais permet à plusieurs threads d’ajouter ou de supprimer des caractères. Si toute la modification des chaînes survient dans un seul thread, ce qui est généralement le cas, utilisez plutôt StringBuilder. Les API des deux classes sont identiques.
Les notes d’API suivantes contiennent les méthodes les plus importantes pour la classe StringBuilder. java.lang.StringBuilder 5.0
•
StringBuilder()
Construit un constructeur de chaîne vide. •
int length
Renvoie le nombre d’unités de code du constructeur ou du tampon. •
StringBuilder append(String str)
Annexe une chaîne et renvoie this. •
StringBuilder append(char c)
Annexe une unité de code et renvoie this. •
StringBuilder appendCodePoint(int cp)
Annexe un point de code, en le transformant en une ou deux unités de code et renvoie this. •
void setCharAt(int i, char c)
Définit la ième unité de code sur c. •
StringBuilder insert(int offset, String str)
Insère une chaîne à la position offset et renvoie this.
Livre Java.book Page 70 Mercredi, 13. février 2008 2:34 14
70
•
Au cœur de Java 2 - Notions fondamentales
StringBuilder insert(int offset, char c)
Insère une unité de code à la position offset et renvoie this. •
StringBuilder delete(int startIndex, int endIndex)
Supprime les unités de code avec les décalages startIndex à endIndex - 1 et renvoie this. •
String toString()
Renvoie une chaîne contenant les mêmes données que le constructeur ou le tampon.
Entrées et sorties Pour rendre nos programmes d’exemple plus intéressants, il faut accepter les saisies et mettre correctement en forme le programme. Bien entendu, les langages de programmation modernes utilisent une interface graphique pour recueillir la saisie utilisateur. Mais la programmation de cette interface exige plus d’outils et de techniques que ce que nous avons à disposition pour le moment. L’intérêt pour l’instant étant de se familiariser avec le langage de programmation Java, nous allons nous contenter de notre humble console pour l’entrée et la sortie. La programmation des interfaces graphiques est traitée aux Chapitres 7 à 9.
Lire les caractères entrés Vous avez pu constater combien il était simple d’afficher une sortie sur l’unité de "sortie standard" (c’est-à-dire la fenêtre de la console) en appelant System.out.println. La lecture d’une "entrée standard" System.in n’est pas aussi simple. La lecture d’une entrée au clavier se fait en construisant un Scanner attaché à System.in. Scanner in = new Scanner(System.in);
Les diverses méthodes de la classe Scanner permettent ensuite de lire les entrées. Par exemple, la méthode nextLine lit une ligne saisie : System.out.print("What is your name? "); String name = in.nextLine();
Ici, nous utilisons la méthode nextLine car la saisie pourrait contenir des espaces. Pour lire un seul mot (délimité par des espaces), appelez String firstName = in.next();
Pour lire un entier, utilisez la méthode nextInt : System.out.print("How old are you? "); int age = in.nextInt();
De même, la méthode nextDouble lit le prochain chiffre à virgule flottante. Le programme du Listing 3.2 demande le nom de l’utilisateur et son âge, puis affiche un message du style Hello, Cay. Next year, you’ll be 46
Enfin, ajoutez la ligne import java.util.*;
Livre Java.book Page 71 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
71
au début du programme. La classe Scanner est définie dans le package java.util. Dès que vous utilisez une classe qui n’est pas définie dans le package de base java.lang, vous devez utiliser une directive import. Nous étudierons les packages et les directives import plus en détail au Chapitre 4. Listing 3.2 : InputTest.java import java.util.*; /** * Ce programme montre une entrée de console * @version 1.10 2004-02-10 * @author Cay Horstmann */ public class InputTest { public static void main(String[] args) { Scanner in = new Scanner(System.in); // récupérer la première entrée System.out.print("What is your name? "); String name = in.nextLine(); // récupérer la seconde entrée System.out.print("How old are you? "); int age = in nextInt(); // afficher la sortie à la console System.out.println("Hello, " + name + ". Next year, you’ll be " + (age + 1)); } }
INFO La classe Scanner ne convient pas pour la lecture d’un mot de passe à partir d’une console puisque l’entrée est tout à fait visible pour tous. Java SE 6 introduit une classe Console réservée à cet usage. Pour lire un mot de passe, utilisez le code suivant : Console cons = System.console(); String username = cons.readLine("User name: "); char[] passwd = cons.readPassword("Password: ");
Pour des raisons de sécurité, le mot de passe est renvoyé dans un tableau de caractères plutôt que dans une chaîne. Une fois que vous avez traité le mot de passe, écrasez immédiatement les éléments du tableau par une valeur de remplissage (le traitement des tableaux est traité plus loin dans ce chapitre). Le traitement des entrées avec un objet Console n’est pas aussi pratique qu’avec un Scanner. Vous ne pouvez lire qu’une ligne d’entrée à la fois. Il n’existe pas de méthodes pour lire des mots ou des nombres individuels.
java.util.Scanner 5.0 • Scanner(InputStream in)
Construit un objet Scanner à partir du flux de saisie donné. •
String nextLine()
Lit la prochaine ligne saisie.
Livre Java.book Page 72 Mercredi, 13. février 2008 2:34 14
72
•
Au cœur de Java 2 - Notions fondamentales
String next()
Lit le prochain mot saisi (délimité par un espace). • •
int nextInt() double nextDouble()
Lisent et transforment la prochaine suite de caractères qui représente un entier ou un nombre à virgule flottante. •
boolean hasNext()
Teste s’il y a un autre mot dans la saisie. • •
boolean hasNextInt() boolean hasNextDouble()
Testent si la prochaine suite de caractères représente un entier ou un nombre à virgule flottante. java.lang.System 1.0 • static Console console() 6
Renvoie un objet Console pour interagir avec l’utilisateur via une fenêtre console si cette interaction est possible, null dans les autres cas. Un objet Console est disponible pour tout programme lancé dans une fenêtre console. Dans le cas contraire, la disponibilité dépend du système. java.io.Console 6 • static char[] readPassword(String prompt, Object... args) • static String readLine(String prompt, Object... args)
Affichent l’invite et lisent la saisie utilisateur jusqu’à la fin de la ligne d’entrée. Les paramètres args peuvent servir à fournir des arguments de mise en forme, comme c’est indiqué à la section suivante.
Mise en forme de l’affichage L’instruction System.out.print(x) permet d’afficher un nombre x à la console. Cette instruction affichera x avec le maximum de chiffres différents de zéro (pour le type donné). Par exemple, double x = 10000.0 / 3.0; System.out.print(x);
affiche 3333.3333333333335
Cela pose un problème si vous désirez afficher, par exemple, des euros et des centimes. Dans les précédentes versions de Java, l’affichage des nombres posait quelques problèmes. Heureusement, Java SE 5.0 a rapatrié la vénérable méthode printf de la bibliothèque C. Par exemple, l’appel System.out.printf("%8.2f", x);
affiche x avec une largeur de champ de 8 caractères et une précision de 2 caractères. En fait, l’affichage contient un espace préalable et les sept caractères 3333.33
Vous pouvez fournir plusieurs paramètres à printf, et notamment System.out.printf("Hello, %s. Next year, you’ll be %d", name, age);
Livre Java.book Page 73 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
73
Chacun des spécificateurs de format qui commencent par le caractère % est remplacé par l’argument correspondant. Le caractère de conversion qui termine un spécificateur de format indique le type de la valeur à mettre en forme : f est un nombre à virgule flottante, s une chaîne et d une valeur décimale. Le Tableau 3.5 montre tous les caractères de conversion. Tableau 3.5 : Conversions pour printf
Caractère de conversion
Type
Exemple
d
Entier décimal
159
x
Entier hexadécimal
9f
o
Entier octal
237
f
Virgule fixe, virgule flottante
15.9
e
Virgule flottante exponentielle
1.59e+01
g
Virgule flottante générale (le plus court entre e et f)
a
Virgule flottante hexadécimale
0x1.fccdp3
s
Chaîne
Hello
c
Caractère
H
b
Valeur booléenne
true
h
Code de hachage
42628b2
tx
Date et heure
Voir Tableau 3.7
%
Symbole du pourcentage
%
n
Séparateur de ligne fonction de la plate-forme
Vous pouvez également spécifier des drapeaux qui contrôleront l’apparence du résultat mis en forme. Le Tableau 3.6 énumère les drapeaux. Par exemple, le drapeau virgule ajoute des séparateurs de groupe. Ainsi, System.out.printf("%,.2f", 1000.0 / 3.0);
affiche 3,333.33
Vous pouvez afficher plusieurs drapeaux, par exemple "%,(.2f", pour utiliser des séparateurs de groupe et inclure les nombres négatifs entre parenthèses. INFO Vous pouvez utiliser la conversion s pour mettre en forme des objets arbitraires. Lorsqu’un objet arbitraire implémente l’interface Formattable, la méthode formatTo de l’objet est appelée. Dans le cas contraire, c’est la méthode toString qui est appelée pour transformer l’objet en chaîne. Nous traiterons de la méthode toString au Chapitre 5 et des interfaces au Chapitre 6.
Livre Java.book Page 74 Mercredi, 13. février 2008 2:34 14
74
Au cœur de Java 2 - Notions fondamentales
Tableau 3.6 : Drapeaux pour printf
Drapeau
Rôle
Exemple
+
Affiche le signe des nombres positifs et négatifs.
+3333.33
espace
Ajoute un espace avant les nombres positifs.
| 3333.33|
0
Ajoute des zéros préalables.
003333.33
-
Justifie le champ à gauche.
|3333.33|
(
Entoure le nombre négatif de parenthèses.
(3333.33)
,
Ajoute des séparateurs de groupe.
3,333.33
# (pour format f)
Inclut toujours une décimale.
3,333
# (pour format x ou o)
Ajoute le préfixe 0x ou 0.
0xcafe
$
Indique l’indice de l’argument à mettre en forme ; par exemple, %1$d %1$x affiche le premier argument en décimal et hexadécimal.
159 9F
<
Met en forme la même valeur que la spécification précédente ; par exemple, %d %= target) { performance = "Satisfactory"; bonus = 100; }
Dans cet extrait de code, toutes les instructions qui se trouvent à l’intérieur des accolades seront exécutées lorsque la valeur de yourSales sera supérieure à la valeur de target (voir Figure 3.7).
Livre Java.book Page 80 Mercredi, 13. février 2008 2:34 14
80
Au cœur de Java 2 - Notions fondamentales
Figure 3.7 Organigramme de l’instruction if. NON yourSales target
OUI
performance =“Satisfactory”
bonus=100
INFO Un bloc (parfois appelé instruction composée) permet de regrouper plus d’une instruction (simple) dans une structure de programmation Java qui, sans ce regroupement, ne pourrait contenir qu’une seule instruction (simple).
L’instruction conditionnelle de Java a l’aspect suivant (voir Figure 3.8) : if (condition)
instruction1
else
instruction2
Par exemple : if (yourSales >= target) { performance = "Satisfactory"; bonus = 100 + 0.01 * (yourSales - target); } else { performance = "Unsatisfactory"; bonus = 0; }
La partie else est toujours facultative. Une directive else est toujours associée à l’instruction if la plus proche. Par conséquent, dans l’instruction if (x = 1.5 * target) { performance = "Fine"; bonus = 500; } else if (yourSales >= target) { performance = "Satisfactory"; bonus = 100; } else { System.out.println("You’re fired"); }
Livre Java.book Page 82 Mercredi, 13. février 2008 2:34 14
82
Au cœur de Java 2 - Notions fondamentales
yourSales 2*target
OUI
performance =“Excellent”
bonus=1000
performance =“Fine”
bonus=500
performance =“Satisfactory”
bonus=100
NON
yourSales 1.5*target
OUI
NON
OUI yourSales target
NON
Print “You’re fired”
Figure 3.9 Organigramme de l’instruction if/else if (branchement multiple).
Boucles La boucle while exécute une instruction (qui peut être une instruction de bloc) tant qu’une condition est vraie. Sa forme générale est la suivante : while (condition) instruction
La boucle while ne s’exécute jamais si la condition est fausse dès le départ (voir Figure 3.10).
Livre Java.book Page 83 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
83
Figure 3.10 Organigramme de l’instruction while. NON balance < goal
OUI
update balance
years++
Print years
Dans le Listing 3.3, nous écrivons un programme permettant de déterminer combien de temps sera nécessaire pour économiser une certaine somme vous permettant de prendre une retraite bien méritée, en supposant que vous déposiez chaque année une même somme d’argent à un taux d’intérêt spécifié. Dans notre exemple, nous incrémentons un compteur et nous mettons à jour le total cumulé dans le corps de la boucle jusqu’à ce que le total excède le montant souhaité : while (balance < goal) { balance += payment; double interest = balance * interestRate / 100; balance += interest; years++; } System.out.println(years + " years.");
Livre Java.book Page 84 Mercredi, 13. février 2008 2:34 14
84
Au cœur de Java 2 - Notions fondamentales
Ne vous fiez pas à ce programme pour prévoir votre retraite. Nous avons laissé de côté quelques détails comme l’inflation et votre espérance de vie. Le test d’une boucle while est effectué avant l’exécution du corps de la boucle. Par conséquent, ce bloc peut ne jamais être exécuté. Si vous voulez être certain que le bloc soit exécuté au moins une fois, vous devez placer la condition de test en fin de boucle. Pour cela, employez une boucle do/while, dont voici la syntaxe : do instruction while (condition);
Cette boucle exécute l’instruction (généralement un bloc) avant de tester la condition. Le programme réexécute le bloc avant d’effectuer un nouveau test, et ainsi de suite. Par exemple, le code du Listing 3.4 calcule le nouveau solde de votre compte retraite, puis vous demande si vous êtes prêt à partir à la retraite : do { balance += payment; double interest = balance * interestRate / 100; balance += interest; year++; // afficher le solde actuel . . . // demander si prêt à prendre la retraite // et récupérer la réponse . . . } while (input.equals("N"));
Tant que la réponse de l’utilisateur est "N", la boucle est répétée (voir Figure 3.11). Ce programme est un bon exemple d’une boucle devant être exécutée au moins une fois, car l’utilisateur doit pouvoir vérifier le solde avant de décider s’il est suffisant pour assurer sa retraite. Listing 3.3 : Retirement.java import java.util.*; /** * Ce programme présente une boucle while. * @version 1.20 2004-02-10 * @author Cay Horstmann */ public class Retirement { public static void main(String[] args) { // lire les infos entrées Scanner in = new Scanner(System.in); System.out.print("How much do you need to retire? "); double goal = in.nextDouble(); System.out.print("How much money will you contribute every year?"); double payment = in.nextDouble(); System.out.print("Interst rate in %: "); double interestRate = in.nextDouble();
Livre Java.book Page 85 Mercredi, 13. février 2008 2:34 14
Chapitre 3
Structures fondamentales de la programmation Java
double balance = 0; int years = 0; // mettre à jour le solde du compte tant que cible non atteinte while (balance < goal) { // ajouter versements et intérêts de cette année balance += payment; double interest = balance * interestRate / 100; balance += interest; years++; } System.out.println ("You can retire in " + years + " years."); } }
Figure 3.11 Organigramme de l’instruction do/while. actualiser le solde
imprimer le solde demander "Ready to retire? (Y/N)"
lire l'entrée
OUI input="N"
NON
85
Livre Java.book Page 86 Mercredi, 13. février 2008 2:34 14
86
Au cœur de Java 2 - Notions fondamentales
Listing 3.4 : Retirement2.java import java.util.*; /** * Ce programme présente une boucle do/while. * @version 1.20 2004-02-10 * @author Cay Horstmann */ public class Retirement2 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("How much money will you contribute every year?"); double payment = in.nextDouble(); System.out.print("Interest rate in %: "); double interestRate = in.nextDouble(); double balance = 0; int year = 0; String input; // mettre à jour le solde du compte tant que l’utilisateur // n’est pas prêt à prendre sa retraite do { // ajouter versements et intérêts de cette année balance += payment; double interest = balance * interestRate / 100; balance += interest; year++; // afficher le solde actuel System.out.println("After year %d, your balance is %,.2f%n", year, balance); // demander si prêt pour la retraite System.out.print("Ready to retire? (Y/N)"); input = in.next(); } while (input.equals("N")); } }
Boucles déterminées La boucle for est une construction très générale pour gérer une itération contrôlée par un compteur ou une variable similaire, mis à jour après chaque itération. Comme le montre la Figure 3.12, le code suivant affiche les nombres 1 à 10 sur l’écran : for (int i = 1; i 0; i--) System.out.println("Counting down . . . " + i); System.out.println("Blastoff!");
Livre Java.book Page 88 Mercredi, 13. février 2008 2:34 14
88
Au cœur de Java 2 - Notions fondamentales
ATTENTION Soyez prudent lorsque vous testez l’égalité de deux nombres réels. Une boucle for comme celle-ci : for (double x = 0; x != 10; x += 0.1) . . .
risque de ne jamais se terminer. Du fait des erreurs d’arrondi, la valeur finale risque de n’être jamais atteinte. Par exemple, dans la boucle ci-dessus, x saute de 9.99999999999998 à 10.09999999999998, puisqu’il n’existe pas de représentation binaire exacte pour 0.1.
Lorsque vous déclarez une variable dans le premier élément d’une instruction for, la portée de cette variable s’étend jusqu’à la fin du corps de la boucle : for (int i = 1; i 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, par exemple, a été amélioré dans ce sens dans Java SE 5.0. Si vous le souhaitez, vous pouvez même déclarer la méthode main sous la forme : public static void main(String... args)
Classes d’énumération Vous avez vu au Chapitre 3 comment définir les types énumérés dans Java SE 5.0 et versions ultérieures. Voici un exemple typique : public enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };
Le type défini par cette déclaration est, en fait, une classe. La classe possède exactement quatre instances ; il n’est pas possible de construire de nouveaux objets. Vous n’avez donc jamais besoin d’utiliser equals pour les valeurs de types énumérés. Utilisez simplement == pour les comparer. Vous pouvez, si vous le souhaitez, ajouter des constructeurs, des méthodes et des champs à un type énuméré. Bien entendu, les constructeurs ne sont invoqués que lorsque les constantes énumérées sont construites. En voici un exemple : enum Size { SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL"); private Size(String abbreviation) { this.abbreviation = abbreviation; } public String getAbbreviation() { return abbreviation; }
Livre Java.book Page 222 Mercredi, 13. février 2008 2:34 14
222
Au cœur de Java 2 - Notions fondamentales
private String abbreviation; }
Tous les types énumérés sont des sous-classes de la classe Enum, dont ils héritent de plusieurs méthodes. La méthode la plus utile est toString, qui renvoie le nom de la constante énumérée. Ainsi, Size.SMALL.toString() renvoie la chaîne "SMALL". L’inverse de toString est la méthode statique valueOf. Par exemple, l’instruction Size s = (Size) Enum.valueOf(Size.class, "SMALL");
définit s sur Size.SMALL. Chaque type énuméré possède une méthode de valeurs statique qui renvoie un tableau de toutes les valeurs de l’énumération. Par exemple, l’appel : Size[] values = Size.values();
renvoie le tableau avec les éléments Size.SMALL, Size.MEDIUM, Size.LARGE et Size.EXTRA_LARGE. La méthode ordinal donne la position d’une constante énumérée dans la déclaration enum, en partant de zéro. Ainsi, Size.MEDIUM.ordinal() renvoie 1. Le petit programme du Listing 5.5 montre comment fonctionnent les types énumérés. INFO La classe Enum dispose d’un paramètre de type que nous avons ignoré pour des raisons de simplicité. Par exemple, le type énuméré Size étend en fait Enum. Le paramètre de type est utilisé dans la méthode compareTo. Nous verrons cette méthode au Chapitre 6 et les paramètres de type au Chapitre 12.
Listing 5.5 : EnumTest.java import java.util.*; /** * Ce programme présente les types énumérés. * @version 1.0 2004-05-24 * @author Cay Horstmann */ public class EnumTest { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) "); String input = in.next().toUpperCase(); Size size = Enum.valueOf(Size.class, input); System.out.println("size=" + size); System.out.println("abbreviation=" + size.getAbbreviation()); if (size == Size.EXTRA_LARGE) System.out.println("Good job--you paid attention to the _."); } }
Livre Java.book Page 223 Mercredi, 13. février 2008 2:34 14
Chapitre 5
L’héritage
223
enum Size { SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL"); private Size(String abbreviation) { this.abbreviation = abbreviation; } public String getAbbreviation() { return abbreviation; } private String abbreviation; } java.lang.Enum 5.0
•
static Enum valueOf(Class enumClass, String name)
Renvoie la constante énumérée de la classe donnée, avec le nom donné. •
String toString()
Renvoie le nom de cette constante énumérée. •
int ordinal()
Renvoie la position basée sur zéro de cette constante énumérée dans la déclaration enum. •
int compareTo(E other)
Renvoie un entier négatif si cette constante énumérée arrive avant, zéro si this == other, et un entier positif le reste du temps. L’ordre des constantes est donné par la déclaration enum.
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 II 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++.
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.
Livre Java.book Page 224 Mercredi, 13. février 2008 2:34 14
224
Au cœur de Java 2 - Notions fondamentales
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. Si la classe se trouve dans un package, le nom du package fait partie du nom de la classe : Date d = new Date(); Class cl = d.getClass(); String name = cl.getName(); // nom réglé sur "java.util.Date"
Vous pouvez aussi obtenir un objet Class correspondant à un nom de classe, à 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 la section "Introduction à l’interception des exceptions" 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 225 Mercredi, 13. février 2008 2:34 14
Chapitre 5
L’héritage
225
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 Java SE 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() renvoie "[Ljava.lang.Double;".
• int[].class.getName() renvoie "[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) . . .
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();
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.
Livre Java.book Page 226 Mercredi, 13. février 2008 2:34 14
226
Au cœur de Java 2 - Notions fondamentales
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.
Introduction à l’interception d’exceptions La gestion des exceptions est traitée 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". Le lancement d’une exception est plus souple que la terminaison du 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. 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 voir l’implémentation du gestionnaire le plus simple. Placez une ou plusieurs instructions 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 }
Livre Java.book Page 227 Mercredi, 13. février 2008 2:34 14
Chapitre 5
L’héritage
227
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 celles-ci — le compilateur protestera quand vous appellerez une méthode menaçant de lancer une exception vérifiée et que vous ne fournirez pas de gestionnaire. 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 228 Mercredi, 13. février 2008 2:34 14
228
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. Le Listing 5.6 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 : public 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 229 Mercredi, 13. février 2008 2:34 14
Chapitre 5
L’héritage
229
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. Listing 5.6 : ReflectionTest.java import java.util.*; import java.lang.reflect.*; /** * Ce programme utilise la réflexion pour afficher toutes les * caractéristiques d’une classe. * @version 1.1 2004-02-01 * @author Cay Horstmann */ 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(); String modifiers = Modifier.toString(cl.getModifiers()); if (modifiers.length() > 0) System.out.print(modifiers + " "); 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); }
Livre Java.book Page 230 Mercredi, 13. février 2008 2:34 14
230
Au cœur de Java 2 - Notions fondamentales
/** * 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) { String name = c.getName(); System.out.print(" "); String modifiers = Modifier.toString(c.getModifiers()); If (modifiers.length() > 0) System.out.print(modifiers + " "); 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(); System.out.print(" "); // affiche les modificateurs, le type renvoyé // et le nom de la méthode String modifiers = Modifier.toString(m.getModifiers()); if (modifiers.length() > 0) System.out.print( modifiers + " "); 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(");"); } }
Livre Java.book Page 231 Mercredi, 13. février 2008 2:34 14
Chapitre 5
L’héritage
231
/** * 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(); System.out.print(" "); String modifiers = Modifier.toString(f.getModifiers()); if (modifiers.length() > 0) System.out.println( modifiers + " "); System.out.println(type.getName() + " " + name + ";"); } } } java.lang.Class 1.0
• •
Field[] getFields() 1.1 Field[] getDeclaredFields() 1.1
getFields renvoie un tableau contenant les objets Field représentant les champs publics de cette classe ou de ses superclasses. 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.
Livre Java.book Page 232 Mercredi, 13. février 2008 2:34 14
232
•
Au cœur de Java 2 - Notions fondamentales
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. 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 :
Livre Java.book Page 233 Mercredi, 13. février 2008 2:34 14
Chapitre 5
L’héritage
233
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. 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. Le Listing 5.7 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. Le Listing 5.7 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();
Livre Java.book Page 234 Mercredi, 13. février 2008 2:34 14
234
Au cœur de Java 2 - Notions fondamentales
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); } catch (Exception e) { e.printStackTrace(); } } } r += "]"; cl = cl.getSuperclass(); } while (cl != null); return r; } . . . }
La totalité du code du Listing 5.7 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 0) { // réorganiser a[i] et a[j] . . . }
Le compilateur doit savoir que a[i] possède réellement une méthode compareTo. Si a est un tableau d’objets Comparable, l’existence de la méthode est confirmée, car chaque classe qui implémente l’interface Comparable doit fournir la méthode. INFO Il serait logique que la méthode sort dans la classe Arrays soit définie pour accepter un tableau Comparable[], afin que le compilateur puisse protester si quelqu’un appelle sort avec un tableau dont le type d’élément n’implémente pas l’interface Comparable. Malheureusement, il n’en est rien. La méthode sort accepte un tableau Object[] et a recours à un transtypage bizarre : // dans la bibliothèque standard -- Non recommandé if (((Comparable) a[i]).compareTo(a[j]) > 0) { // réorganiser a[i] et a[j] . . . }
Si a[i] n’appartient pas à une classe qui implémente l’interface Comparable, la machine virtuelle déclenche une exception.
Le Listing 6.1 décrit la totalité du code nécessaire pour le tri d’un tableau d’employés. Listing 6.1 : EmployeeSortTest.java import java.util.*; /** * Ce programme présente l’utilisation de l’interface Comparable. * @version 1.30 2004-02-27 * @author Cay Horstmann */
Livre Java.book Page 251 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
public class EmployeeSortTest { public static void main(String[] args) { Employee[] staff = new Employee[3]; staff[0] = new Employee("Harry Hacker", 35000); staff[1] = new Employee("Carl Cracker", 75000); staff[2] = new Employee("Tony Tester", 38000); Arrays.sort(staff); // afficher les informations pour tous les objets Employee for (Employee e : staff) System.out.println("name=" + e.getName() + ",salary=" + e.getSalary()); } } class Employee implements Comparable { public Employee(String n, double s) { name = n; salary = s; } public String getName() { return name; } public double getSalary() { return salary; } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } /** * Compare les salaires des employés * @param other Un autre objet Employee * @return une valeur négative si cet employé * a un salaire inférieur à celui de otherObject, * 0 si les salaires sont identiques, * une valeur positive dans les autres cas */ public int compareTo(Employee other) { if (salary < other.salary) return -1; if (salary > other.salary) return 1; return 0; }
251
Livre Java.book Page 252 Mercredi, 13. février 2008 2:34 14
252
Au cœur de Java 2 - Notions fondamentales
private String name; private double salary; } java.lang.Comparable 1.0 int compareTo(T other)
•
Compare cet objet à d’autres et renvoie un entier négatif si cet objet est inférieur à l’autre, 0 s’ils sont égaux et un entier positif dans les autres cas. java.util.Arrays 1.2 • static void sort(Object[] a)
Trie les éléments du tableau a, à l’aide d’un algorithme mergesort personnalisé. Tous les éléments du tableau doivent appartenir à des classes qui implémentent l’interface Comparable ; ils doivent aussi tous être comparables entre eux. INFO Selon les standards du langage : "L’implémenteur doit s’assurer que sgn(x.compareTo(y)) = –sgn(y.compare To(x)) pour toutes les occurrences de x et y (cela implique que x.compareTo(y) doit déclencher une exception si y.compareTo(x) déclenche une exception)." Ici, "sgn" est le signe d’un nombre : sgn(n) vaut –1 si n est négatif, 0 si n égale 0 et 1 si n est positif. En bon français, si vous inversez les paramètres de compareTo, le signe (mais pas nécessairement la valeur réelle) du résultat doit aussi être inversé. Comme avec la méthode equals, des problèmes peuvent survenir lorsque l’on fait appel à l’héritage. Etant donné que Manager étend Employee, il implémente Comparable et non pas Comparable . Si Manager choisit de remplacer compareTo, il doit être préparé à comparer les directeurs aux employés. Il ne peut pas simplement transtyper l’employé en directeur : class Manager extends Employee { public int compareTo(Employee other) { Manager otherManager = (Manager) other; // NON . . . } . . . }
La règle d’"antisymétrie" est violée. Si x est un Employee et y un Manager, l’appel x.compareTo(y) ne déclenche pas d’exception — il compare simplement x et y en tant qu’employés. Mais l’inverse, y.compareTo(x) déclenche une exception ClassCastException. C’est la même situation qu’avec la méthode equals vue au Chapitre 5 ; la solution est la même. Il existe deux scénarios distincts. Si les sous-classes ont des notions différentes de la comparaison, vous devez interdire la comparaison des objets appartenant à des classes différentes. Chaque méthode compareTo devrait commencer par le test if (getClass() != other.getClass()) throw new ClassCastException();
S’il existe un algorithme commun pour comparer les objets de sous-classe, fournissez simplement une seule méthode compareTo dans la superclasse et déclarez-la sous la forme final. Supposons par exemple que vous vouliez que les directeurs aient une meilleure situation que les employés ordinaires, en dehors du salaire. Qu’adviendra-t-il des autres sous-classes comme Executive et Secretary ? Si vous devez établir un ordre hiérarchique, fournissez une méthode dans la classe Employee (par exemple rank). Amenez
Livre Java.book Page 253 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
253
chaque sous-classe à remplacer rank et implémentez une seule méthode compareTo qui prendra en compte les valeurs du rang.
Propriétés des interfaces Les interfaces ne sont pas des classes. En particulier, vous ne devez jamais utiliser l’opérateur new pour instancier une interface : x = new Comparable(. . .); // ERREUR
Cependant, bien que vous ne puissiez pas construire des objets interface, vous pouvez toujours déclarer des variables interface : Comparable x; // OK
Une variable interface doit faire référence à un objet d’une classe qui implémente l’interface : x = new Employee(. . .); // OK du moment que Employee implémente Comparable
Ensuite, tout comme vous utilisez instanceof pour vérifier si un objet appartient à une classe spécifique, vous pouvez utiliser instanceof pour vérifier si un objet implémente une interface : if (unObjet instanceof Comparable) { . . . }
Tout comme vous pouvez construire des hiérarchies de classes, vous pouvez étendre des interfaces. Cela autorise plusieurs chaînes d’interfaces allant d’un plus large degré de généralité à un plus petit degré de spécialisation. Supposez, par exemple, que vous ayez une interface appelée Moveable : public interface Moveable { void move(double x, double y); }
Vous pourriez alors imaginer une interface appelée Powered qui l’étendrait : public interface Powered extends Moveable { double milesPerGallon(); }
Bien que vous ne puissiez pas mettre des champs d’instance ou des méthodes statiques dans une interface, vous pouvez fournir des constantes à l’intérieur. Par exemple : public interface Powered extends Moveable { double milesPerGallon(); double SPEED_LIMIT = 95; // une constante public static final }
Tout comme les méthodes dans une interface sont automatiquement public, les champs sont toujours public static final. INFO Il est légal de qualifier les méthodes d’interface de public, et les champs de public static final. Certains programmeurs le font, par habitude ou pour une plus grande clarté. Cependant, les spécifications du langage Java recommandent de ne pas fournir de mots clés redondants et nous respectons cette recommandation.
Livre Java.book Page 254 Mercredi, 13. février 2008 2:34 14
254
Au cœur de Java 2 - Notions fondamentales
Certaines interfaces définissent simplement les constantes et pas de méthodes. Par exemple, la bibliothèque standard contient une interface SwingConstants qui définit les constantes NORTH, SOUTH, HORIZONTAL, etc. Toute classe qui choisit d’implémenter l’interface SwingConstants hérite automatiquement de ces constantes. Ses méthodes peuvent faire simplement référence à NORTH au lieu du SwingConstants.NORTH, plus encombrant. Toutefois, cette utilisation des interfaces semble plutôt dégénérée, et nous ne la recommandons pas. Alors que chaque classe ne peut avoir qu’une superclasse, les classes peuvent implémenter plusieurs interfaces. Cela vous donne un maximum de flexibilité pour la définition du comportement d’une classe. Par exemple, le langage Java a une importante interface intégrée, appelée Cloneable (nous reviendrons en détail sur cette interface dans la section suivante). Si votre classe implémente Cloneable, la méthode clone dans la classe Object réalisera une copie fidèle des objets de votre classe. Supposez, par conséquent, que vous vouliez disposer des fonctions de clonage et de comparaison ; il vous suffira d’implémenter les deux interfaces : class Employee implements Cloneable, Comparable
Utilisez des virgules pour séparer les interfaces qui décrivent les caractéristiques que vous voulez fournir.
Interfaces et classes abstraites Si vous avez lu la section concernant les classes abstraites au Chapitre 5, vous vous demandez peutêtre pourquoi les concepteurs du langage Java se sont compliqué la tâche en introduisant le concept d’interface. Pourquoi ne pas faire de Comparable une classe abstraite ? abstract class Comparable // Pourquoi pas ? { public abstract int compareTo(Object other); }
La classe Employee pourrait simplement étendre cette classe abstraite et fournir la méthode compareTo : class Employee extends Comparable // Pourquoi pas ? { public int compareTo(Object other) { . . . } }
Il y a, malheureusement, un problème majeur en ce qui concerne l’utilisation d’une classe de base abstraite pour exprimer une propriété générique. Une classe ne peut étendre qu’une seule classe. Supposons qu’une autre classe dérive déjà de la classe Employee, disons Person. La classe Employee ne peut alors étendre de seconde classe : class Employee extends Person, Comparable // ERREUR
En revanche, chaque classe peut implémenter autant d’interfaces qu’elle le souhaite : class Employee extends Person implements Comparable // OK
Les autres langages de programmation, en particulier C++, autorisent une classe à avoir plus d’une superclasse. Cette fonctionnalité est appelée héritage multiple. Les concepteurs de Java ont choisi de ne pas la prendre en charge, car elle rend le langage soit très complexe (comme dans C++), soit moins efficace (comme dans Eiffel).
Livre Java.book Page 255 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
255
Les interfaces, elles, procurent la plupart des avantages de l’héritage multiple tout en évitant les risques de complexité et d’inefficacité. INFO C++ Le langage C++ prend en charge l’héritage multiple, avec tous les tracas qui l’accompagnent, comme les classes de base virtuelles, les règles de prédominance et les transtypages de pointeurs transversaux. Peu de programmeurs C++ exploitent réellement l’héritage multiple et certains affirment qu’il ne devrait jamais être utilisé. D’autres conseillent de n’employer l’héritage multiple que pour l’héritage de style "mix-in". Dans ce style, une classe de base primaire décrit l’objet parent et des classes de base additionnelles (les mix-in) peuvent fournir des caractéristiques complémentaires. Ce style est comparable à une classe Java ayant une seule classe de base et des interfaces additionnelles. Néanmoins, en C++, les mix-in peuvent ajouter un comportement par défaut, ce que ne peuvent pas faire les interfaces Java.
Clonage d’objets Lorsque vous faites une copie d’une variable, l’original et la copie sont des références au même objet (voir Figure 6.1). Cela signifie que tout changement apporté à l’une des variables affecte aussi l’autre. Employee original = new Employee("John Public", 50000); Employee copy = original; copy.raiseSalary(10); // aïe--a aussi changé l’original
Si vous voulez que copy soit un nouvel objet qui, au départ, est identique à original, mais dont l’état peut diverger avec le temps, appelez la méthode clone. Employee copy = original.clone(); copy.raiseSalary(10); // OK—-original inchangé
En réalité, les choses ne sont pas si simples. La méthode clone est une méthode protected de Object, ce qui signifie que votre code ne peut pas simplement l’appeler directement. Seule la classe Employee peut cloner des objets Employee. Et il y a une bonne raison à cela. Réfléchissons à la manière dont la classe Object peut implémenter clone. Elle ne sait rien de l’objet et ne peut effectuer qu’une copie champ à champ. Si tous les champs de données de l’objet sont des nombres ou appartiennent à un autre type de base, la copie des champs ne posera pas de problème. Mais si l’objet contient des références à des sous-objets, la copie des champs vous donnera une autre référence au sous-objet. En conséquence, l’original et les objets clonés continueront à partager certaines informations. Pour visualiser ce phénomène, considérons la classe Employee, présentée au Chapitre 4. La Figure 6.2 montre ce qui se passe lorsque vous appelez la méthode clone de la classe Object pour cloner un tel objet Employee. Vous pouvez constater que l’opération de clonage par défaut est "superficielle" (shallow) — elle ne clone pas les objets qui sont référencés à l’intérieur d’autres objets. Le fait que cette copie soit superficielle est-il important ? Cela dépend. Si le sous-objet qui est partagé entre l’original et le clone superficiel est inaltérable, le partage est sûr. Cela se produit certainement si le sous-objet appartient à une classe inaltérable, telle que String. Le sous-objet peut aussi tout simplement rester constant pendant toute la durée de vie de l’objet, sans que des méthodes d’altération ne l’affectent, ni qu’aucune méthode ne produise de référence vers lui.
Livre Java.book Page 256 Mercredi, 13. février 2008 2:34 14
256
Au cœur de Java 2 - Notions fondamentales
Figure 6.1
Copie
Copie et clonage.
original =
Employee
copy =
Clonage
Figure 6.2
original =
Une copie "shallow".
original =
Employee
copy =
Employee
Employee
String
name = salary =
50000.0
hireDay =
copy =
Employee name = salary = hireDay =
50000.0
Date
Livre Java.book Page 257 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
257
Cependant, assez fréquemment, les sous-objets sont altérables et vous devez redéfinir la méthode clone pour réaliser une copie "intégrale" (deep copy) qui clone aussi les sous-objets. Dans notre exemple, le champ hireDay est un objet Date, qui lui est altérable. Pour chaque classe, vous devez décider si oui ou non : 1. La méthode clone par défaut convient. 2. La méthode clone par défaut peut être corrigée par un appel de clone sur les sous-objets altérables. 3. La méthode clone ne doit pas être tentée. La troisième option est celle par défaut. Pour pouvoir choisir la première ou la deuxième option, une classe doit : 1. Implémenter l’interface Cloneable. 2. Redéfinir la méthode clone avec le modificateur d’accès public. INFO La méthode clone est déclarée protected dans la classe Object afin que votre code ne puisse pas simplement appeler unObjet.clone(). Mais les méthodes protégées ne sont-elles pas accessibles à partir de n’importe quelle sous-classe et toute classe n’est-elle pas une sous-classe de Object ? Heureusement, les règles concernant les accès protégés sont plus subtiles (voir Chapitre 5). Une sous-classe peut appeler une méthode clone protégée, seulement pour cloner ses propres objets. Vous devez redéfinir clone comme publique pour permettre aux objets d’être clonés par n’importe quelle méthode.
Dans ce cas, l’apparence de l’interface Cloneable n’a rien à voir avec l’utilisation normale des interfaces. En particulier, elle ne spécifie pas la méthode clone — qui est héritée de la classe Object. L’interface sert purement de balise, indiquant que le concepteur de la classe comprend le processus de clonage. Les objets sont tellement paranoïaques en ce qui concerne le clonage, qu’ils génèrent une exception vérifiée (checked exception), si un objet requiert le clonage, mais n’implémentent pas cette interface. INFO L’interface Cloneable fait partie des quelques interfaces de balisage que fournit Java (certains programmeurs les appellent interfaces marqueur). Souvenez-vous que l’intérêt habituel d’une interface telle que Comparable est d’assurer qu’une classe implémente une méthode ou un jeu de méthodes spécifique. Une interface de balisage n’a pas de méthodes ; son seul objectif est de permettre l’utilisation de instanceof dans une requête de type : if (obj instanceof Cloneable) . . .
Nous vous recommandons de ne pas utiliser les interfaces de balisage dans vos programmes.
Même si l’implémentation par défaut (copie superficielle) de clone est adéquate, vous devez toujours implémenter l’interface Cloneable, redéfinir clone comme public, appeler super.clone(). Voici un exemple : class Employee implements Cloneable {
Livre Java.book Page 258 Mercredi, 13. février 2008 2:34 14
258
Au cœur de Java 2 - Notions fondamentales
// élever le niveau de visibilité à public, // changer le type de retour public Employee clone() throws CloneNotSupportedException { Return (Employee) super.clone(); } . . . }
INFO Avant Java SE 5.0, la méthode clone avait toujours un type de retour Object. Les types de retours covariants de Java SE 5.0 vous permettent de spécifier le type de retour correct pour vos méthodes clone.
La méthode clone que vous venez de voir n’ajoute aucune fonctionnalité à la copie "shallow" fournie par Object.clone. Elle se contente de rendre la méthode public. Pour réaliser une copie intégrale, vous devrez poursuivre l’exercice et cloner les champs d’instance altérables. Voici un exemple de méthode clone qui crée une copie intégrale : class Employee implements Cloneable { . . . public Employee clone() throws CloneNotSupportedException { // appeler Object.clone() Employee cloned = (Employee) super.clone(); // cloner les champs altérables cloned.hireDay = (Date) hireDay.clone() return cloned; } }
La méthode clone de la classe Object menace de lancer une exception CloneNotSupportedException, et ce dès que clone est appelée sur un objet dont la classe n’implémente pas l’interface Cloneable. Bien entendu, les classes Employee et Date implémentent l’interface Cloneable, l’exception ne sera donc pas déclenchée. Toutefois, le compilateur ne le sait pas. Nous avons donc déclaré l’exception : public Employee clone() throws CloneNotSupportedException
Vaudrait-il mieux l’intercepter ? public Employee clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { return null; } // ceci n’arriverait pas, puisque nous utilisons Cloneable }
Livre Java.book Page 259 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
259
Ceci convient bien pour les classes final. Dans les autres cas, il vaut mieux laisser le spécificateur throws à sa place. Les sous-classes ont alors l’option de lancer une exception CloneNotSupportedException si elles ne prennent pas en compte le clonage. Vous devez prendre garde lorsque vous clonez des sous-classes. Par exemple, une fois que vous avez défini la méthode clone pour la classe Employee, n’importe qui peut aussi cloner les objets Manager. La méthode clone Employee peut-elle assurer cette tâche ? Cela dépend des champs de la classe Manager. Dans notre cas, cela ne pose pas de problème, car le champ bonus est du type primitif. Mais Manager pourrait avoir acquis des champs qui exigent une copie intégrale ou qui ne peuvent pas être clonés. Il n’est absolument pas garanti que l’implémenteur de la sous-classe dispose d’un clone fixe pour réaliser l’action adéquate. Vous devez donc vous assurer que la méthode clone est déclarée comme protégée (protected) dans la classe Object. Mais vous n’aurez pas ce luxe si vous souhaitez que les utilisateurs de vos classes puissent appeler clone. Devez-vous alors implémenter clone dans vos propres classes ? Si vos clients doivent réaliser des copies intégrales, probablement oui. Certains auteurs considèrent toutefois qu’il vaut mieux éviter totalement clone et implémenter à sa place une autre méthode dans ce but. Nous convenons que clone est plutôt étrange, mais vous rencontrerez les mêmes problèmes en utilisant une autre méthode. De toute façon, le clonage est moins commun que vous pourriez le penser. Moins de 5 % des classes de la bibliothèque standard implémentent clone. Le programme du Listing 6.2 clone un objet Employee, puis invoque deux méthodes d’altération. La méthode raiseSalary change la valeur du champ salary, alors que la méthode setHireDay change l’état du champ hireDay. Aucune de ces altérations n’affecte l’objet original, car clone a été définie pour faire une copie intégrale. INFO Tous les types de tableaux possèdent une méthode clone qui est public et non protected. Vous pouvez l’utiliser pour créer un nouveau tableau qui contiendra des copies de tous les éléments. Par exemple, int[] luckyNumbers = { 2, 3, 5, 7, 11, 13 }; int[] cloned = (int[]) luckyNumbers.clone(); cloned[5] = 12; // ne modifie pas luckyNumbers[5]
INFO Le Chapitre 1 du Volume II montre un autre mécanisme pour cloner les objets à l’aide de la fonction de sérialisation d’objet de Java. Ce mécanisme est facile à implémenter et sûr, mais il n’est pas très efficace.
Listing 6.2 : CloneTest.java import java.util.*; /** * Ce programme présente le clonage. * @version 1.10 2002-07-01 * @author Cay Horstmann */ public class CloneTest {
Livre Java.book Page 260 Mercredi, 13. février 2008 2:34 14
260
Au cœur de Java 2 - Notions fondamentales
public static void main(String[] args) { try { Employee original = new Employee("John Q. Public", 50000); original.setHireDay(2000, 1, 1); Employee copy = original.clone(); copy.raiseSalary(10); copy.setHireDay(2002, 12, 31); System.out.println("original=" + original); System.out.println("copy=" + copy); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } } class Employee implements Cloneable { public Employee(String n, double s) { name = n; salary = s; hireDay = new Date(); } public Employee clone() throws CloneNotSupportedException { // appeler Object.clone() Employee cloned = (Employee) super.clone(); // cloner les champs altérables cloned.hireDay = (Date) hireDay.clone(); return cloned; } /** * Affecte une date donnée au jour d’embauche (hireday) * @param year L’année du jour d’embauche * @param month Le mois du jour d’embauche * @param day Le jour d’embauche */ public void setHireDay(int year, int month, int day) { Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime(); // Exemple de mutation de champ d’instance hireDay.setTime(newHireDay.getTime()); } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; }
Livre Java.book Page 261 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
261
public String toString() { return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay() + "]"; } private String name; private double salary; private Date hireDay; }
Interfaces et callbacks Un pattern habituel de la programmation est celui des callbacks. Dans ce pattern, vous indiquez l’action à réaliser en cas de survenue d’un événement particulier. Vous pourriez vouloir, par exemple, qu’une action particulière survienne lorsque l’on clique sur un bouton ou que l’on sélectionne un élément de menu. Toutefois, comme vous n’avez pas encore vu comment implémenter les interfaces utilisateur, nous envisagerons une situation similaire, mais plus simple. Le package javax.swing contient une classe Timer, utile pour être averti de l’expiration d’un délai imparti. Par exemple, si une partie de votre programme contient une horloge, vous pouvez demander à être averti à chaque seconde, de manière à pouvoir mettre à jour l’affichage de l’horloge. Lorsque vous construisez un minuteur, vous définissez l’intervalle de temps et lui indiquez ce qu’il doit faire lorsque le délai est écoulé. Comment indiquer au minuteur ce qu’il doit faire ? Dans de nombreux langages de programmation, vous fournissez le nom d’une fonction que le minuteur doit appeler périodiquement. Toutefois, les classes de la bibliothèque Java adoptent une approche orientée objet. Vous transférez un objet d’une classe quelconque. Le minuteur appelle alors l’une des méthodes de cet objet. Transférer un objet est une opération plus flexible que transférer une fonction car l’objet peut transporter des informations complémentaires. Bien entendu, le minuteur doit savoir quelle méthode appeler. Vous devez spécifier un objet d’une classe qui implémente l’interface ActionListener du package java.awt.event. Voici cette interface : public interface ActionListener { void actionPerformed(ActionEvent event); }
Le minuteur appelle la méthode actionPerformed lorsque le délai a expiré. INFO C++ Comme vous l’avez vu au Chapitre 5, Java possède l’équivalent des pointeurs de fonction, à savoir les objets Method. Ils sont toutefois difficiles à utiliser, plus lents et la sécurité des types ne peut pas être vérifiée au moment de la compilation. Dès que vous utilisez un pointeur de fonction en C++, envisagez d’utiliser une interface en Java.
Livre Java.book Page 262 Mercredi, 13. février 2008 2:34 14
262
Au cœur de Java 2 - Notions fondamentales
Supposons que vous souhaitiez afficher le message "At the tone, the time is …" (à la tonalité, il sera…), suivi d’un bip, et ce toutes les 10 secondes. Définissez une classe qui implémente l’interface ActionListener. Vous placerez alors toutes les instructions que vous voulez voir exécuter dans la méthode actionPerformed : class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); Toolkit.getDefaultToolkit().beep(); } }
Remarquez le paramètre ActionEvent de la méthode actionPerformed. Il apporte des informations sur l’événement, comme l’objet source qui l’a généré (voir le Chapitre 8 pour en savoir plus). Toutefois, il n’est pas important d’obtenir des informations détaillées sur ce programme et vous pouvez ignorer le paramètre en toute sécurité. Construisez ensuite un objet de cette classe et transmettez-le au constructeur Timer : ActionListener listener = new TimePrinter(); Timer t = new Timer(10000, listener);
Le premier paramètre du constructeur Timer correspond au délai qui doit s’écouler entre les notifications, mesuré en millièmes de seconde. Nous voulons être avertis toutes les 10 secondes. Le deuxième paramètre est l’objet écouteur. Enfin, vous démarrez le minuteur : t.start();
Toutes les 10 secondes, un message du type At the tone, the time is Thu Apr 13 23:29:08 PDT 2000
s’affiche, suivi d’un bip. Le Listing 6.3 fait fonctionner le minuteur et son écouteur. Une fois le minuteur démarré, le programme affiche un message et attend que l’utilisateur clique sur OK pour s’arrêter. Entre-temps, l’heure actuelle s’affiche par intervalles de 10 secondes. Soyez patient lorsque vous exécutez le programme. La boîte de dialogue "Quit program?" (fermer le programme ?) s’affiche immédiatement, mais le premier message du minuteur n’apparaît qu’après 10 secondes. Sachez que le programme importe la classe javax.swing.Timer par nom, en plus d’importer javax.swing.* et java.util.*. Ceci annule l’ambiguïté qui existait entre javax.swing.Timer et java.util.Timer, une classe non liée pour programmer les tâches d’arrière-plan. Listing 6.3 : TimerTest.java /** * @version 1.00 2000-04-13 * @author Cay Horstmann */ import java.awt.*;
Livre Java.book Page 263 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
263
import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; // résoudre le conflit avec java.util.Timer public class TimerTest { public static void main(String[] args) { ActionListener listener = new TimePrinter(); // construit un minuteur qui appelle l’écouteur // toutes les 10 secondes Timer t = new Timer(10000, listener); t.start(); JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); } } class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); Toolkit.getDefaultToolkit().beep(); } } javax.swing.JOptionPane 1.2
•
static void showMessageDialog(Component parent, Object message)
Affiche une boîte de dialogue avec une invite et un bouton OK. La boîte de dialogue est centrée sur le composant parent. Si parent est null, la boîte de dialogue est centrée à l’écran. javax.swing.Timer 1.2 • Timer(int interval, ActionListener listener)
Construit un minuteur qui avertit l’écouteur lorsque les millièmes de seconde de l’intervalle se sont écoulés. •
void start()
Démarre le minuteur. Une fois lancé, il appelle actionPerformed sur ses écouteurs. •
void stop()
Arrête le minuteur. Une fois arrêté, il n’appelle plus actionPerformed sur ses écouteurs. javax.awt.Toolkit 1.0 • static Toolkit getDefaultToolkit()
Récupère la boîte à outils par défaut. Une boîte à outils contient des informations sur l’environnement de l’interface graphique utilisateur. •
void beep()
Emet un bip.
Livre Java.book Page 264 Mercredi, 13. février 2008 2:34 14
264
Au cœur de Java 2 - Notions fondamentales
Classes internes Une classe interne est une classe qui est définie à l’intérieur d’une autre classe. Trois raisons justifient l’emploi de classes internes : m
Les méthodes de classe internes peuvent accéder aux données, à partir de la portée où elles sont définies, y compris les données qui pourraient être des données privées.
m
Les classes internes peuvent être cachées aux autres classes du même package.
Les classes internes anonymes sont utiles pour définir des callbacks sans écrire beaucoup de code. Nous allons diviser ce sujet assez complexe en plusieurs étapes : m
m
A partir de la section suivante, vous verrez une classe interne simple qui accède à un champ d’instance de sa classe externe.
m
A la section "Règles particulières de syntaxe pour les classes internes", nous verrons les règles de syntaxe spéciales pour les classes internes.
m
A la section "Utilité, nécessité et sécurité des classes internes", nous étudierons les classes internes pour voir comment les traduire en classes ordinaires. Les lecteurs délicats pourront sauter cette section.
m
A la section "Classes internes locales", nous discuterons des classes internes locales qui peuvent accéder aux variables locales dans la portée qui les englobe.
m
A la section "Classes internes anonymes", nous présenterons les classes internes anonymes et montrerons comment les utiliser habituellement pour implémenter les callbacks.
m
Enfin, à partir de la section "Classes internes statiques", vous verrez comment utiliser les classes internes statiques pour les classes d’aide imbriquées. INFO C++
Le langage C++ permet l’emploi de classes imbriquées. Une classe imbriquée se situe dans la portée de la classe qui l’englobe. Voici un exemple typique ; une classe de liste liée définit une classe permettant de stocker les liens et une classe qui détermine une position d’itération : class LinkedList { public: class Iterator // une classe imbriquée { public: void insert(int x); int erase(); . . . }; . . . private: class Link // une classe imbriquée { public: Link* next; int data; }; . . . };
Livre Java.book Page 265 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
265
L’imbrication est une relation entre les classes, non entre les objets. Un objet LinkedList n’a pas de sous-objets de types Iterator ou Link. Cela procure deux avantages : le contrôle de nom et le contrôle d’accès. Puisque le nom Iterator est imbriqué dans la classe LinkedList, il est connu à l’extérieur sous la forme LinkedList::Iterator et ne peut pas entrer en conflit avec une autre classe baptisée Iterator. En Java, cet avantage est moins important, car les packages Java procurent un contrôle de nom équivalent. Remarquez que la classe Link se trouve dans la partie private de la classe LinkedList. Elle est absolument invisible au reste du code. Pour cette raison, il n’y a aucun risque à déclarer ses champs public. Ils ne sont accessibles qu’aux méthodes de la classe LinkedList (qui a le besoin légitime d’y accéder). Ils sont invisibles à l’extérieur de LinkedList. En Java, ce genre de contrôle n’était pas possible avant l’arrivée des classes internes. Les classes internes de Java possèdent cependant une caractéristique supplémentaire qui les rend plus riches, et donc plus utiles que les classes imbriquées de C++. Un objet d’une classe interne possède une référence implicite à l’objet de la classe externe qui l’a instancié. Grâce à ce pointeur, il peut accéder à tous les champs de l’objet externe. Nous verrons dans ce chapitre les détails de ce mécanisme. En Java, les classes internes static ne sont pas dotées de ce pointeur. Elles sont exactement équivalentes aux classes imbriquées de C++.
Accéder à l’état d’un objet à l’aide d’une classe interne La syntaxe des classes internes est assez complexe. C’est pourquoi nous utiliserons un exemple simple, bien que peu réaliste, pour démontrer l’usage des classes internes. Nous allons refactoriser l’exemple TimerTest et extraire une classe TalkingClock. Une horloge parlante se construit avec deux paramètres : l’intervalle entre les annonces et une balise pour activer ou désactiver le bip : public class TalkingClock { public TalkingClock(int interval, boolean beep) public void start() { . . . }
{ . . . }
private int interval; private boolean beep; public class TimePrinter implements ActionListener // une classe interne { . . . } }
Remarquez la classe TimePrinter, qui se trouve à l’intérieur de la classe TalkingClock. Cela ne signifie pas que chaque TalkingClock possède un champ d’instance TimePrinter. Comme vous le verrez, les objets TimePrinter sont construits par les méthodes de la classe TalkingClock. Voici la classe TimePrinter plus en détail. Sachez que la méthode actionPerformed vérifie la balise du bip avant d’émettre le son : private class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (beep) Toolkit.getDefaultToolkit().beep(); } }
Livre Java.book Page 266 Mercredi, 13. février 2008 2:34 14
266
Au cœur de Java 2 - Notions fondamentales
Une chose surprenante se passe. La classe TimePrinter n’a pas de champ d’instance ni de variable nommée beep. En fait, beep fait référence au champ de l’objet TalkingClock qui a créé TimePrinter. C’est une innovation. Traditionnellement, une méthode pouvait référencer les champs de l’objet qui l’invoquait. Une méthode de la classe interne a accès à la fois à ses propres champs et à ceux de l’objet externe créateur. Pour que tout cela fonctionne, un objet d’une classe interne obtient toujours une référence implicite à l’objet qui l’a créé (voir Figure 6.3). Cette référence est invisible dans la définition de la classe interne. Pour faire la lumière sur ce concept, nous allons appeler la référence à l’objet externe outer. La méthode actionPerformed est alors équivalente à ce qui suit : public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (outer.beep) Toolkit.getDefaultToolkit().beep(); }
La référence de classe externe est définie dans le constructeur. Le compilateur modifie tous les constructeurs de classe interne, en ajoutant un paramètre pour la référence de classe externe. Etant donné que TimePrinter ne définit aucun constructeur, le compilateur synthétise un constructeur par défaut, générant un code comme celui-ci : public TimePrinter(TalkingClock clock) // Code généré automatiquement { outer = clock; }
Figure 6.3 Un objet d’une classe interne possède une référence à un objet d’une classe externe.
TimePrinter outer =
TalkingClock interval = beep =
1000 true
Notez bien que outer n’est pas un mot clé du langage Java. Nous l’avons uniquement utilisé pour illustrer le mécanisme mis en œuvre dans une classe interne. Lorsqu’un objet TimePrinter est construit dans la méthode start, le compilateur passe la référence this au constructeur dans l’horloge parlante courante : ActionListener listener = new TimePrinter( this); // paramètre ajouté automatiquement
Livre Java.book Page 267 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
267
Le Listing 6.4 décrit le programme complet qui teste la classe interne. Examinez de nouveau le contrôle d’accès. Si la classe TimePrinter avait été une classe régulière, il aurait fallu accéder à la balise beep par l’intermédiaire d’une méthode publique de la classe TalkingClock. L’emploi d’une classe interne constitue une amélioration. Il n’est pas nécessaire de fournir des méthodes d’accès qui n’intéressent qu’une seule autre classe. INFO Nous aurions pu déclarer la classe TimePrinter comme private. Dans ce cas, seules les méthodes TalkingClock auraient pu construire les objets TimePrinter. Seules les classes internes peuvent être privées. Les classes ordinaires ont toujours une visibilité soit publique, soit sur le package.
Listing 6.4 : InnerClassTest.java import import import import import
java.awt.*; java.awt.event.*; java.util.*; javax.swing.*; javax.swing.Timer;
/** * Ce programme présente l’utilisation des classes internes. * @version 1.10 2004-02-27 * @author Cay Horstmann */ public class InnerClassTest { public static void main(String[] args) { TalkingClock clock = new TalkingClock(1000, true); clock.start(); // laisser le programme fonctionner jusqu’à ce que l’utilisateur // clique sur "OK" JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); } } /** * Une horloge qui affiche l’heure à intervalles réguliers. */ class TalkingClock { /** * Construit une horloge parlante * @param interval L’intervalle entre les messages * (en millièmes de seconde) * @param beep true si l’horloge doit sonner */ public TalkingClock(int interval, boolean beep) { this.interval = interval; this.beep = beep; }
Livre Java.book Page 268 Mercredi, 13. février 2008 2:34 14
268
Au cœur de Java 2 - Notions fondamentales
/** * Lance l’horloge. */ public void start() { ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); } private int interval; private boolean beep; public class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (beep) Toolkit.getDefaultToolkit().beep(); } } }
Règles particulières de syntaxe pour les classes internes Dans la section précédente, nous avons explicité la référence de classe externe d’une classe interne en la baptisant outer. En réalité, la syntaxe correcte pour la référence externe est un peu plus complexe. L’expression ClasseExterne.this
indique la référence de classe externe. Vous pouvez par exemple, écrire la méthode actionPerformed de la classe interne TimePrinter de la façon suivante : public void actionPerformed(ActionEvent event) { ... if (TalkingClock.this.beep) Toolkit.getDefaultToolkit().beep(); }
Inversement, vous pouvez écrire le constructeur de l’objet interne plus explicitement, à l’aide de la syntaxe : objetExterne.new ClasseInterne(paramètres de construction)
Par exemple, ActionListener listener = this.new TimePrinter();
Ici, la référence à la classe externe de l’objet TimePrinter nouvellement construit est définie par la référence this de la méthode qui crée l’objet de la classe interne. C’est le cas le plus courant. Comme toujours, l’indication this. est redondante. Néanmoins, il est également possible de donner à la référence de la classe externe une autre valeur en la nommant explicitement. Par exemple, si TimePrinter est une classe interne publique, vous pouvez construire un objet TimePrinter pour n’importe quelle horloge parlante : TalkingClock jabberer = new TalkingClock(1000, true); TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
Livre Java.book Page 269 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
269
Notez que vous faites référence à une classe interne de la façon suivante ClasseExterne.ClasseInterne
lorsqu’elle se trouve être hors de la portée de la classe externe.
Utilité, nécessité et sécurité des classes internes Lorsque les classes internes ont été ajoutées au langage Java dans Java 1.1, de nombreux programmeurs les ont considérées comme une nouvelle fonctionnalité majeure qui était hors de propos dans la philosophie Java. La syntaxe est complexe (nous le verrons en examinant les classes internes anonymes dans la suite de ce chapitre). Il n’est pas évident de saisir l’interaction des classes internes avec d’autres caractéristiques du langage comme le contrôle d’accès et la sécurité. En ajoutant une fonctionnalité élégante et intéressante plutôt que nécessaire, Java a-t-il commencé à suivre la voie funeste de tant d’autres langages, en se dotant d’une caractéristique élégante et intéressante, mais pas nécessaire ? Nous ne donnerons pas une réponse définitive, mais notez que les classes internes constituent un phénomène qui est lié au compilateur et non à la machine virtuelle. Les classes internes sont traduites en fichiers de classe réguliers, avec des signes $ délimitant les noms des classes externes et internes et la machine virtuelle Java ne les reconnaît pas comme une particularité. Par exemple, la classe TimePrinter à l’intérieur de la classe TalkingClock est traduite en un fichier de classe TalkingClock$TimePrinter.class. Pour le constater, faites cette expérience : exécutez le programme ReflectionTest du Chapitre 5 et donnez-lui comme classe de réflexion la classe TalkingClock$TimePrinter. Vous pouvez aussi simplement employer l’utilitaire javap : javap –private nomClasse
INFO Si vous utilisez UNIX, n’oubliez pas d’échapper le caractère $ si vous fournissez le nom de classe sur la ligne de commande. En fait, exécutez le programme ReflectionTest ou javap sous la forme : java ReflectionTest TalkingClock\$TimePrinter
ou javap –private TalkingClock\$TimePrinter
Vous obtenez donc l’affichage suivant : public class TalkingClock$TimePrinter { public TalkingClock$TimePrinter(TalkingClock); public void actionPerformed(java.awt.event.ActionEvent); final TalkingClock this$0; }
Vous pouvez voir que le compilateur a généré un champ d’instance supplémentaire, this$0, pour la référence à la classe externe (le nom this$0 est synthétisé par le compilateur — vous ne pouvez pas y faire référence dans le code source). Vous pouvez aussi voir le paramètre TalkingClock ajouté pour le constructeur.
Livre Java.book Page 270 Mercredi, 13. février 2008 2:34 14
270
Au cœur de Java 2 - Notions fondamentales
Si le compilateur peut effectuer automatiquement cette transformation, ne pourrait-on pas simplement programmer manuellement le même mécanisme ? Essayons. Nous allons faire de TimePrinter une classe régulière, extérieure à la classe TalkingClock. Lors de la construction d’un objet TimePrinter, nous lui passerons la référence this de l’objet qui le crée : class TalkingClock { . . . public void start() { ActionListener listener = new TimePrinter(this); Timer t = new Timer(interval, listener); t.start(); } } class TimePrinter implements ActionListener { public TimePrinter(TalkingClock clock) { outer = clock; } . . . private TalkingClock outer; }
Examinons maintenant la méthode actionPerformed. Elle doit pouvoir accéder à outer.beep. if (outer.beep) . . . // ERREUR
Nous venons de rencontrer un problème. La classe interne peut accéder aux données privées de la classe externe, mais notre classe externe TimePrinter ne le peut pas. Nous voyons bien que les classes internes sont intrinsèquement plus puissantes que les classes régulières, puisqu’elles ont un privilège d’accès supérieur. Il est légitime de se demander comment les classes internes peuvent acquérir ce privilège d’accès supérieur, alors qu’elles sont traduites en classes régulières simplement dotées de noms particuliers — la machine virtuelle ne les distingue pas. Pour résoudre ce mystère, utilisons de nouveau le programme ReflectionTest afin d’espionner la classe TalkingClock : class TalkingClock { public TalkingClock(int, boolean); static boolean access$0(TalkingClock); public void start(); private int interval; private boolean beep; }
Remarquez la méthode statique access$0 ajoutée par le compilateur à la classe externe. Elle renvoie le champ beep de l’objet transféré en tant que paramètre. Elle est appelée par les méthodes de la classe interne. L’instruction if (beep)
Livre Java.book Page 271 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
271
dans la méthode actionPerformed de la classe TimePrinter réalise, en fait, l’appel suivant : if (access$0(outer));
Y a-t-il un risque pour la sécurité ? Bien sûr. Il est facile à un tiers d’invoquer la méthode access$0 pour lire le champ privé beep. Bien entendu, access$0 n’est pas un nom autorisé pour une méthode Java. Néanmoins, pour des pirates familiers de la structure des fichiers de classe, il est facile de produire un fichier de classe avec des instructions (machine virtuelle) qui appellent cette méthode, par exemple en utilisant un éditeur hexadécimal. Les méthodes d’accès secrètes ayant une visibilité au niveau du package, le code d’attaque devrait être placé dans le même package que la classe attaquée. En résumé, si une classe interne accède à un champ privé, il est possible d’accéder à ce champ par le biais de classes ajoutées au package de la classe externe, mais une telle opération exige du talent et de la détermination. Un programmeur ne peut pas obtenir accidentellement un tel privilège d’accès ; pour y parvenir, il doit intentionnellement créer ou modifier un fichier de classe. INFO Les constructeurs et méthodes synthétisés peuvent être assez complexes (passez cette info si vous n’avez pas le courage d’aborder ce sujet). Supposons que nous transformions TimePrinter en classe interne privée. Il n’existe pas de classe privée dans la machine virtuelle, le compilateur produit donc une chose formidable, une classe visible par le package avec un constructeur privé private TalkingClock$TimePrinter(TalkingClock);
Bien entendu, personne ne peut appeler le constructeur. Il existe donc un second constructeur visible par le package : TalkingClock$TimePrinter(TalkingClock, TalkingClock$1);
qui appelle le premier. Le compilateur traduit le constructeur dans la méthode start de la classe TalkingClock en new TalkingClock$TimePrinter(this, null)
Classes internes locales Si vous examinez attentivement le code de l’exemple TalkingClock, vous constaterez que vous n’avez besoin qu’une seule fois du nom du type TimePrinter : lorsque vous créez un objet de ce type dans la méthode start. Dans une telle situation, vous pouvez définir les classes localement à l’intérieur d’une seule méthode : public void start() { class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (beep) Toolkit.getDefaultToolkit().beep(); } }
Livre Java.book Page 272 Mercredi, 13. février 2008 2:34 14
272
Au cœur de Java 2 - Notions fondamentales
ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); }
Les classes locales ne sont jamais déclarées avec un spécificateur d’accès (c’est-à-dire public ou private). Leur portée est toujours restreinte au bloc dans lequel elles sont déclarées. Les classes locales présentent l’immense avantage d’être complètement cachées au monde extérieur, et même au reste du code de la classe TalkingClock. A part start, aucune méthode ne connaît l’existence de la classe TimePrinter.
Accès aux variables final à partir de méthodes externes Les classes locales ont un autre avantage sur les autres classes internes. Elles peuvent non seulement accéder aux champs de leurs classes externes, mais également aux variables locales ! Ces variables locales doivent être déclarées final. Voici un exemple typique. Déplaçons les paramètres interval et beep du constructeur TalkingClock à la méthode start : public void start(int interval, final boolean beep) { class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (beep) Toolkit.getDefaultToolkit().beep(); } } ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); }
Notez que la classe TalkingClock n’a plus besoin de stocker une variable d’instance beep. Elle fait simplement référence à la variable paramètre beep de la méthode start. Cela n’est peut-être pas si surprenant. La ligne if (beep) . . .
est située au plus profond de la méthode start, alors pourquoi ne pourrait-elle pas avoir accès à la variable beep ? Afin de comprendre ce problème délicat, examinons de plus près le flux d’exécution : 1. La méthode start est appelée. 2. La variable objet listener est initialisée par un appel au constructeur de la classe interne TimePrinter. 3. La référence à listener est passée au constructeur de Timer, le temporisateur est démarré et la méthode start se termine. A ce moment, la variable paramètre beep de la méthode start n’existe plus. 4. Une seconde plus tard, la méthode actionPerformed exécute if (beep) . . .
Livre Java.book Page 273 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
273
Pour que le code de la méthode actionPerformed fonctionne, la classe TimePrinter doit avoir fait une copie de la valeur de paramètre beep avant qu’il ne disparaisse en tant que variable locale de la méthode start. Et c’est exactement ce qui se passe. Dans notre exemple, le compilateur synthétise le nom TalkingClock$1TimePrinter pour la classe interne locale. Si vous utilisez le programme ReflectionTest pour espionner la classe TalkingClock$1TimePrinter, vous obtiendrez ce qui suit : class TalkingClock$1TimePrinter { TalkingClock$1TimePrinter(TalkingClock, boolean); public void actionPerformed(java.awt.event.ActionEvent); final boolean val$beep; final TalkingClock this$0; }
Remarquez le paramètre boolean du constructeur et la variable d’instance val$beep. Lorsqu’un objet est créé, la valeur beep est passée au constructeur et stockée dans le champ val$beep. Le compilateur détecte l’accès des variables locales, crée des champs d’instance pour chacune d’elles et copie les variables locales dans le constructeur afin que les champs d’instance soient initialisés. Du point de vue du programmeur, l’accès aux variables locales est assez plaisant. Il simplifie vos classes internes en réduisant le nombre des champs d’instance que vous devez programmer explicitement. Comme nous l’avons déjà signalé, les méthodes d’une classe locale peuvent uniquement faire référence à des variables locales déclarées final. C’est la raison pour laquelle le paramètre beep a été déclaré final dans notre exemple. Une variable locale déclarée final ne peut pas être modifiée après avoir été initialisée. Ainsi, nous avons la garantie que la variable locale et sa copie dans la classe locale auront bien la même valeur. INFO Vous avez déjà vu des variables final utilisées en tant que constantes, à l’image de ce qui suit : public static final double SPEED_LIMIT = 55;
Le mot clé final peut être appliqué aux variables locales, aux variables d’instance et aux variables statiques. Dans tous les cas, cela signifie la même chose : cette variable ne peut être affectée qu’une seule fois après sa création. Il n’est pas possible d’en modifier ultérieurement la valeur — elle est définitive. Cela dit, il n’est pas obligatoire d’initialiser une variable final lors de sa définition. Par exemple, la variable paramètre final beep est initialisée une fois après sa création, lorsque la méthode start est appelée (si elle est appelée plusieurs fois, chaque appel crée son propre paramètre beep). La variable d’instance val$beep, que nous avons vue dans la classe interne TalkingClock$1TimePrinter, est définie une seule fois, dans le constructeur de la classe interne. Une variable final qui n’est pas initialisée lors de sa définition est souvent appelée variable finale vide.
La restriction final est assez peu pratique. Supposons, par exemple, que vous souhaitiez actualiser un compteur dans la portée. Ici, nous voulons compter la fréquence d’appel de la méthode compareTo pendant le tri. int counter = 0; Date[] dates = new Date[100];
Livre Java.book Page 274 Mercredi, 13. février 2008 2:34 14
274
Au cœur de Java 2 - Notions fondamentales
for (int i = 0; i < dates.length; i++) dates[i] = new Date() { public int compareTo(Date other) { counter++; // ERREUR return super.compareTo(other); } }; Arrays.sort(dates); System.out.println(counter + " comparisons.");
Vous ne pouvez pas déclarer counter comme final car il est évident que vous devez l’actualiser. Vous ne pouvez pas non plus le remplacer par un Integer car les objets Integer sont inaltérables. Le recours consisterait à utiliser un tableau de longueur 1 : final int[] counter = new int[1]; for (int i = 0; i < dates.length; i++) dates[i] = new Date() { public int compareTo(Date other) { counter[0]++; return super.compareTo(other); } };
La variable de tableau est toujours déclarée final, mais cela signifie simplement que vous ne pouvez pas lui faire référencer un autre tableau. Libre à vous d’altérer les éléments du tableau. Lorsque les classes internes ont été inventées, le compilateur de prototype a automatiquement effectué cette transformation pour toutes les variables locales modifiées dans la classe interne. Certains programmeurs craignaient malgré tout que le compilateur produise des tas d’objets dans leur dos ; la restriction final a donc été adoptée à la place. Une prochaine version du langage Java pourrait d’ailleurs bien inverser cette décision.
Classes internes anonymes Lors de l’utilisation de classes internes locales, vous pouvez souvent aller plus loin. Si vous ne souhaitez créer qu’un seul objet de cette classe, il n’est même pas nécessaire de donner un nom à la classe. Une telle classe est appelée classe interne anonyme : public void start(int interval, final boolean beep) { ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (beep) Toolkit.getDefaultToolkit().beep(); } }; Timer t = new Timer(interval, listener); t.start(); }
Livre Java.book Page 275 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
275
Il s’agit là d’une syntaxe assez obscure qui signifie : créer un nouvel objet d’une classe qui implémente l’interface ActionListener, où la méthode actionPerformed requise est celle définie entre les accolades { }. En général, la syntaxe est : new SuperType(paramètres de construction) { méthodes et données de la classe interne }
SuperType peut être ici une interface telle que ActionListener ; la classe interne implémente alors cette interface. SuperType peut également être une classe, et dans ce cas la classe interne étend cette classe. Une classe interne anonyme ne peut pas avoir de constructeurs, car le nom d’un constructeur doit être identique à celui de la classe (et celle-ci n’a pas de nom). Au lieu de cela, les paramètres de construction sont donnés au constructeur de la superclasse. En particulier, chaque fois qu’une classe interne implémente une interface, elle ne peut pas avoir de paramètres de construction. Il faut néanmoins toujours fournir les parenthèses, comme dans cet exemple : new TypeInterface() { méthodes et données }
Il faut y regarder à deux fois pour faire la différence entre la construction d’un nouvel objet d’une classe régulière et la construction d’un objet d’une classe interne anonyme qui étend cette classe. Person queen = // un objet Person count = // un objet
new Person("Mary"); Person new Person("Dracula") { ... }; d’une classe interne étendant Person
Si la parenthèse fermante de la liste de paramètres du constructeur est suivie d’une accolade ouvrante, cela définit une classe interne anonyme. Les classes internes anonymes sont-elles une brillante idée, ou plutôt un excellent moyen d’écrire du code hermétique ? Sans doute les deux. Lorsque le code d’une classe interne est très court — quelques lignes de code simple — cela peut faire gagner un peu de temps. Mais c’est exactement le genre d’économie qui vous amène à concourir pour le prix du code Java le plus obscur. Le Listing 6.5 contient le code source complet du programme d’horloge parlante avec une classe interne anonyme. Si vous comparez ce programme à celui du Listing 6.4, vous verrez que le code avec la classe interne anonyme est plus court, et, heureusement, avec un peu de pratique, aussi facile à comprendre. Listing 6.5 : AnonymousInnerClassTest.java import import import import import
java.awt.*; java.awt.event.*; java.util.*; javax.swing.*; javax.swing.Timer;
/** * Ce programme présente les classes internes anonymes. * @version 1.10 2004-02-27 * @author Cay Horstmann */
Livre Java.book Page 276 Mercredi, 13. février 2008 2:34 14
276
Au cœur de Java 2 - Notions fondamentales
public class AnonymousInnerClassTest { public static void main(String[] args) { TalkingClock clock = new TalkingClock(); clock.start(1000, true); // laisse le programme fonctionner jusqu’à ce que l’utilisateur // clique sur "OK" JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); } } /** * Une horloge qui affiche l’heure à intervalles réguliers. */ class TalkingClock { /** * Démarre l’horloge. * @param interval L’intervalle entre les messages * (en millièmes de seconde) * @param beep true si l’horloge doit émettre un bip */ public void start(int interval, final boolean beep) { ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent event) { Date now = new Date(); System.out.println("At the tone, the time is " + now); if (beep) Toolkit.getDefaultToolkit().beep(); } }; Timer t = new Timer(interval, listener); t.start(); } }
Classes internes statiques On désire parfois utiliser une classe interne pour cacher simplement une classe dans une autre, sans avoir besoin de fournir à la classe interne une référence à un objet de la classe externe. A cette fin, la classe interne est déclarée static. Voici un exemple typique qui montre les raisons d’un tel choix. Prenons le calcul des valeurs minimale et maximale d’un tableau. Bien entendu, on écrit normalement une méthode pour calculer le minimum et une autre pour calculer le maximum. Lorsque ces deux méthodes sont appelées, le tableau est parcouru deux fois. Il serait plus efficace de parcourir le tableau une seule fois et de calculer simultanément les deux valeurs : double min = Double.MAX_VALUE; double max = Double.MIN_VALUE; for (double v : values)
Livre Java.book Page 277 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
277
{ if (min > v) min = v; if (max < v) max = v; }
Cependant, la méthode doit renvoyer deux nombres. Pour ce faire, nous déclarons une classe Pair qui stocke deux valeurs numériques : class Pair { public Pair(double f, double s) { first = f; second = s; } public double getFirst() { return first; } public double getSecond() { return second; } private double first; private double second; }
La fonction minmax peut alors renvoyer un objet de type Pair : class ArrayAlg { public static Pair minmax(double[] values) { . . . return new Pair(min, max); } }
L’appelant de la fonction utilise ensuite les méthodes getFirst et getSecond pour récupérer les réponses : Pair p = ArrayAlg.minmax(d); System.out.println("min = " + p.getFirst()); System.out.println("max = " + p.getSecond());
Bien sûr, le nom Pair est un terme très courant et, dans un grand projet, il se peut qu’un autre programmeur ait eu la même idée brillante, mais sa classe Pair contient une paire de chaînes de caractères. Ce conflit potentiel de noms peut être évité en faisant de Pair une classe interne publique dans ArrayAlg. La classe sera alors connue du public sous le nom ArrayAlg.Pair : ArrayAlg.Pair p = ArrayAlg.minmax(d);
Quoi qu’il en soit, et contrairement aux autres classes internes employées dans les exemples précédents, nous ne voulons pas avoir une référence à un autre objet au sein d’un objet Pair. Cette référence peut être supprimée en déclarant la classe interne comme static : class ArrayAlg { public static class Pair { . . . } . . . }
Livre Java.book Page 278 Mercredi, 13. février 2008 2:34 14
278
Au cœur de Java 2 - Notions fondamentales
Seules les classes internes peuvent évidemment être déclarées static. Une classe interne static ressemble exactement à n’importe quelle autre classe interne, avec cette différence, cependant, qu’un objet d’une classe interne statique ne possède pas de référence à l’objet externe qui l’a créé. Dans notre exemple, nous devons utiliser une classe interne statique, car l’objet de la classe interne est construit dans une méthode statique : public static Pair minmax(double[] d) { . . . return new Pair(min, max); }
Si Pair n’avait pas été déclaré static, le compilateur aurait indiqué qu’aucun objet implicite de type ArrayAlg n’était disponible pour initialiser l’objet de la classe interne. INFO On utilise une classe interne statique lorsque la classe interne n’a pas besoin d’accéder à un objet de la classe externe. On emploie aussi le terme classe imbriquée pour désigner les classes internes statiques.
INFO Les classes internes qui sont déclarées dans une interface sont automatiquement statiques et publiques.
Le Listing 6.6 contient le code source complet de la classe ArrayAlg et de la classe imbriquée Pair. Listing 6.6 : StaticInnerClassTest.java /** * Ce programme présente l’utilisation de classes internes statiques. * @version 1.01 2004-02-27 * @author Cay Horstmann */ public class StaticInnerClassTest { public static void main(String[] args) { double[] d = new double[20]; for (int i = 0; i < d.length; i++) d[i] = 100 * Math.random(); ArrayAlg.Pair p = ArrayAlg.minmax(d); System.out.println("min = " + p.getFirst()); System.out.println("max = " + p.getSecond()); } } class ArrayAlg { /** * Une paire de nombres à virgule flottante */ public static class Pair {
Livre Java.book Page 279 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
/** * Construit une paire à partir de * deux nombres à virgule flottante * @param f Le premier nombre * @param s Le second nombre */ public Pair(double f, double s) { first = f; second = s; } /** * Renvoie le premier nombre de la paire * @return le premier nombre */ public double getFirst() { return first; } /** * Renvoie le second nombre de la paire * @return le second nombre */ public double getSecond() { return second; } private double first; private double second; } /** * Calcule à la fois le minimum et le maximum d’un tableau * @param values Un tableau de nombres à virgule flottante * @return une paire dont le premier élément est le minimum et * dont le second élément est le maximum */ public static Pair minmax(double[] values) { double min = Double.MAX_VALUE; double max = Double.MIN_VALUE; for (double v : values) { if (min > v) min = v; if (max < v) max = v; } return new Pair(min, max); } }
279
Livre Java.book Page 280 Mercredi, 13. février 2008 2:34 14
280
Au cœur de Java 2 - Notions fondamentales
Proxies Dans cette dernière section du chapitre, nous allons étudier les proxies, une fonctionnalité devenue disponible avec la version 1.3 de Java SE. Vous utilisez un proxy pour créer, au moment de l’exécution, de nouvelles classes qui implémentent un jeu donné d’interfaces. Les proxies ne sont nécessaires que si vous ne savez pas, au moment de la compilation, les interfaces que vous devez implémenter. Cette situation se produit rarement pour les programmeurs d’application, mais n’hésitez pas à passer cette section si les difficultés ne vous intéressent pas. Cependant, pour certaines applications système, la souplesse que procurent les proxies peut avoir une importance capitale. Supposons que vous vouliez construire un objet d’une classe qui implémente une ou plusieurs interfaces dont vous ne connaissez peut-être pas la nature exacte au moment de la compilation. C’est là un problème ardu. Pour construire une classe réelle, vous pouvez simplement utiliser la méthode newInstance ou la réflexion pour trouver un constructeur. Mais vous ne pouvez pas instancier une interface. Vous devez définir une nouvelle classe dans un programme qui s’exécute. Pour résoudre ce problème, certains programmes génèrent du code, le placent dans un fichier, invoquent le compilateur puis chargent le fichier de classe résultant. Cette procédure est lente, bien entendu, et demande aussi le déploiement du compilateur avec le programme. Le mécanisme de proxy est une meilleure solution. La classe proxy peut créer des classes entièrement nouvelles au moment de l’exécution. Une telle classe proxy implémente les interfaces que vous spécifiez. En particulier, elle possède les méthodes suivantes : m
toutes les méthodes requises par les interfaces spécifiées ;
m
toutes les méthodes définies dans la classe Object (toString, equals, etc.).
Néanmoins, vous ne pouvez pas définir de nouveau code pour ces méthodes au moment de l’exécution. A la place, vous devez fournir un gestionnaire d’invocation. Ce gestionnaire est un objet de toute classe implémentant l’interface InvocationHandler. Cette interface possède une seule méthode : Object invoke(Object proxy, Method method, Object[] args)
Chaque fois qu’une méthode est appelée sur l’objet proxy, la méthode invoke du gestionnaire d’invocation est appelée, avec l’objet Method et les paramètres de l’appel original. Le gestionnaire d’invocation doit alors trouver comment gérer l’appel. Pour créer un objet proxy, vous appelez la méthode newProxyInstance de la classe Proxy. Cette méthode a trois paramètres : m
Un chargeur de classe. Dans le cadre du modèle de sécurité Java, il est possible d’utiliser différents chargeurs de classe pour les classes système, les classes qui sont téléchargées à partir d’Internet, etc. Nous verrons les chargeurs de classes au Chapitre 9 du Volume II. Pour l’instant, nous spécifierons null pour utiliser le chargeur de classe par défaut.
m
Un tableau d’objets Class, un pour chaque interface à implémenter.
m
Un gestionnaire d’invocation.
Deux questions restent en suspens. Comment définissons-nous le gestionnaire ? Et que pouvonsnous faire de l’objet proxy résultant ? Les réponses dépendent évidemment du problème que nous voulons résoudre avec le mécanisme de proxy. Les proxies peuvent être employés dans bien des cas, par exemple : m
le routage d’appels de méthode vers des serveurs distants ;
Livre Java.book Page 281 Mercredi, 13. février 2008 2:34 14
Chapitre 6
Interfaces et classes internes
281
m
l’association d’événements de l’interface utilisateur avec des actions, dans un programme qui s’exécute ;
m
la trace des appels de méthode à des fins de débogage.
Dans notre exemple de programme, nous allons utiliser les proxies et les gestionnaires d’invocation pour tracer les appels de méthode. Nous définissons une classe enveloppe TraceHandler qui stocke un objet enveloppé (wrapped). Sa méthode invoke affiche simplement le nom et les paramètres de la méthode à appeler, puis appelle la méthode avec l’objet enveloppé en tant que paramètre implicite : class TraceHandler implements InvocationHandler { public TraceHandler(Object t) { target = t; } public Object invoke(Object proxy, Method m, Object[] args) throws Throwable { // afficher le nom et les paramètres de la méthode . . . // invoquer la méthode return m.invoke(target, args); } private Object target; }
Voici comment vous construisez un objet proxy qui déclenche l’activité de trace chaque fois que l’une de ses méthodes est appelée : Object value = . . .; // construire l’enveloppe (wrapper) InvocationHandler handler = new TraceHandler(value); // construire le proxy pour une ou plusieurs interfaces Class[] interfaces = new Class[] { Comparable.class }; Object proxy = Proxy.newProxyInstance(null, interfaces, handler);
Maintenant, chaque fois qu’une méthode de l’une des interfaces sera appelée sur le proxy, le nom de la méthode et ses paramètres seront affichés, puis la méthode sera invoquée sur value. Dans le programme du Listing 6.7, les objets proxy sont employés pour réaliser la trace d’une recherche binaire. Un tableau est rempli avec les valeurs entières de proxies de 1 à 1 000. Puis la méthode binarySearch de la classe Arrays est invoquée pour rechercher un entier aléatoire dans le tableau. Enfin, l’élément correspondant s’affiche : Object[] elements = new Object[1000]; // remplir les éléments avec des valeurs de proxies de 1 à 1000 for (int i = 0; i < elements.length; i++) { Integer value = i + 1; elements[i] = Proxy.newInstance(. . .); // proxy pour la valeur; } // construire un entier aléatoire Integer key = new Random().nextInt(elements.length) + 1;
Livre Java.book Page 282 Mercredi, 13. février 2008 2:34 14
282
Au cœur de Java 2 - Notions fondamentales
// rechercher la clé (key) int result = Arrays.binarySearch(elements, key); // afficher la correspondance si trouvée if (result >= 0) System.out.println(elements[result]);
La classe Integer implémente l’interface Comparable. Les objets proxy appartiennent à une classe qui est définie au moment de l’exécution (son nom est du style $Proxy0). Cette classe implémente également l’interface Comparable. Sa méthode compareTo appelle la méthode invoke du gestionnaire de l’objet proxy. INFO Comme vous l’avez vu plus tôt dans ce chapitre, depuis Java SE 5.0 la classe Integer implémente en fait Comparable. Toutefois, au moment de l’exécution, tous les types génériques sont effacés et le proxy est construit avec l’objet de classe, pour la classe brute Comparable.
La méthode binarySearch réalise des appels du style : if (elements[i].compareTo(key) < 0) . . .
Puisque nous avons complété le tableau avec des objets proxy, les appels à compareTo appellent la méthode invoke de la classe TraceHandler. Cette méthode affiche le nom de la méthode et ses paramètres, puis invoque compareTo sur l’objet Integer enveloppé. Enfin, à la fin du programme, nous appelons : System.out.println(elements[result]);
La méthode println appelle toString sur l’objet proxy, et cet appel est aussi redirigé vers le gestionnaire d’invocation. Voici la trace complète d’une exécution du programme : 500.compareTo(288) 250.compareTo(288) 375.compareTo(288) 312.compareTo(288) 281.compareTo(288) 296.compareTo(288) 288.compareTo(288) 288.toString()
Remarquez l’algorithme de recherche dichotomique qui coupe en deux l’intervalle de recherche à chaque étape. Vous voyez que la méthode toString est mise en proxy, même si elle n’appartient pas à l’interface Comparable. Vous le découvrirez à la prochaine section, certaines méthodes Object sont toujours mises en proxy. Listing 6.7 : ProxyTest.java import java.lang.reflect.*; import java.util.*;