Java en concentré

javaNut.book Page xvii Dimanche, 29. janvier 2006 10:04 22
Préface
Préface
Cet ouvrage est un manuel de référence destiné aux programmeurs Java™. Sa place de
prédilection se situe à côté de votre clavier pendant que vous programmez. La première
partie de ce livre se compose d’une introduction rapide et directe au langage de programmation Java ainsi qu’aux API (Application Programming Interfaces, c’est-à-dire interfaces de
programmation pour les applications) qui forment le noyau de la plate-forme Java. La
seconde partie consiste en un guide de référence qui détaille de manière succincte chaque
classe et chaque interface formant ces API de base. Ce livre couvre les versions 1.0, 1.1, 1.2,
1.3, 1.4 et 5.0 de Java.
Modifications apportées à la cinquième édition
La cinquième édition de ce livre couvre Java 5.0. Ce numéro de version largement supérieur à celui de la version précédente atteste du grand nombre de nouveautés apparues
dans le langage. Les trois nouveautés les plus importantes sont les types génériques, les
types énumérés et les annotations, qui font l’objet d’un chapitre entièrement nouveau. Les
programmeurs Java expérimentés qui souhaitent se familiariser immédiatement avec ces
nouveautés peuvent passer directement au chapitre 4.
Parmi les autres nouveautés de Java 5.0, citons :
•
L’instruction for/in, qui permet d’itérer facilement sur les tableaux et les collections
(cette instruction est parfois appelée « foreach »).
•
Les conversions autoboxing et auto-unboxing, qui convertissent automatiquement les
valeurs primitives en objets d’encapsulation, et vice-versa (par exemple, des valeurs
int en objets Integer).
•
Les méthodes varargs, qui permettent de définir et d’invoquer des méthodes acceptant un nombre arbitraire d’arguments.
javaNut.book Page xviii Dimanche, 29. janvier 2006 10:04 22
xviii
Préface
•
Les valeurs de retour covariantes, qui permettent à une classe de redéfinir une
méthode d’une super-classe et de restreindre le type de retour de cette méthode.
•
La déclaration import static, qui permet d’importer les membres statiques d’un type
dans l’espace de noms d’un programme.
Bien que toutes ces caractéristiques soient nouvelles avec Java 5.0, aucune d’entre elles
n’est suffisamment complexe pour justifier un chapitre indépendant. C’est pourquoi la
présentation de ces nouveautés est intégrée au chapitre 2.
Outre ces changements apportés au langage, Java 5.0 inclut également des modifications
apportées à la plate-forme Java. Parmi les améliorations les plus importantes, citons :
•
Les classes de collection du paquetage java.util ont été converties en types génériques, prenant ainsi en charge les collections à typage fort. Cet aspect est traité au
chapitre 4.
•
Le paquetage java.util inclut également une nouvelle classe nommée Formatter.
Cette classe permet de produire du texte formaté à la façon de C, grâce aux méthodes
printf() et format(). Des exemples d’utilisation se trouvent au chapitre 5. L’entrée
du guide de référence consacrée à la classe java.util.Formatter présente ces
nombreuses options de formatage dans une table détaillée.
•
Le nouveau paquetage java.util.concurrent inclut de nombreuses classes utilitaires
pour la programmation à threads multiples. Le chapitre 5 en propose des exemples
d’utilisation.
•
Le paquetage java.lang possède trois nouveaux sous-paquetages : java.lang.annotation, java.lang.instrument et java.lang.management. Ces paquetages prennent en
charge les annotations, ainsi que l’instrumentation, la gestion et le suivi d’un interpréteur Java en cours d’exécution. Bien que la présence de ces sous-paquetage au sein
du paquetage java.lang témoigne de leur importance, ils ne sont pas couramment
utilisés. Des exemples d’annotations se trouvent au chapitre 4 et un exemple simple
d’instrumentation et de gestion se trouve au chapitre 5.
•
De nouveaux paquetages ont été ajoutés à la hiérarchie de javax.xml.
javax.xml.validation prend en charge la validation de documents à l’aide de
schémas. javax.xml.xpath prend en charge le langage de requête XPath.
javax.xml.namespace offre une prise en charge simplifiée des espaces de noms XML.
Des exemples de validation et d’utilisation de XPath se trouvent au chapitre 5.
Afin de faire place nette pour toutes ces nouveautés, je me suis permis d’élaguer certaines
parties des versions précédentes de ce livre. Ainsi, j’ai supprimé du guide de référence la
présentation des paquetages java.beans, java.beans.beancontext, java.security.acl et
org.ietf.jgss. Les standards liés aux JavaBeans ne se sont pas véritablement imposés dans
le noyau des API Java et semblent n’être pertinents que pour Swing et les API graphiques
apparentées. Ils n’ont donc plus leur place dans ce livre. Le paquetage java.security.acl
est obsolète depuis Java 1.2 et je me suis permis de le supprimer. Quant au paquetage
org.ietf.jgss, il n’intéresse que peu de lecteurs.
javaNut.book Page xix Dimanche, 29. janvier 2006 10:04 22
Contenu de ce livre
xix
Outre la suppression du paquetage java.beans du guide de référence, j’ai également
supprimé le chapitre qui leur était consacré dans la première partie du livre. Les règles
d’attribution des noms propres aux JavaBeans demeurent cependant utiles et ont été
déplacées au chapitre 7.
Contenu de ce livre
Les huit premiers chapitres de ce livre décrivent le langage Java, la plate-forme Java et les
outils de développement Java qui sont fournis avec le JDK (pour Java Development Kit,
c’est-à-dire kit de développement Java) de Sun. Les cinq premiers chapitres sont essentiels ;
les trois suivants traitent des thèmes qui n’intéresseront pas tous les programmeurs Java.
Chapitre 1 : Introduction
Ce chapitre donne une vue d’ensemble du langage Java et de la plate-forme Java et
présente les principales caractéristiques ainsi que les avantages de Java. Il se termine
par un exemple de programme Java et invite le nouveau programmeur Java à
l’analyser ligne par ligne.
Chapitre 2 : La syntaxe Java
Ce chapitre présente le langage de programmation Java en détail, y compris certains
changements propres à Java 5.0. Il s’agit d’un chapitre long et circonstancié. Les
programmeurs Java expérimentés peuvent l’utiliser comme référence du langage. Les
programmeurs maîtrisant bien des langages tels que C et C++ doivent être en mesure
de comprendre la syntaxe de Java en lisant ce chapitre. Cependant, ce chapitre ne
présuppose pas des années d’expérience en programmation ni même une familiarité
avec C ou C++. Même les programmeurs débutants bénéficiant d’une expérience
modeste doivent être capables d’apprendre la programmation Java en étudiant ce
chapitre avec attention.
Chapitre 3 : La programmation orientée objet en Java
Ce chapitre décrit comment la syntaxe Java de base traitée au chapitre 2 est utilisée
pour écrire des programmes orientés objet en Java. Ce chapitre ne présuppose
aucune expérience préalable en programmation orientée objet. Il peut être utilisé
comme tutoriel par les nouveaux programmeurs ou comme guide de référence par
les programmeurs Java expérimentés.
Chapitre 4 : Nouveautés du langage Java 5.0
Ce chapitre documente les trois nouveautés les plus importantes de Java 5.0 : les
types génériques, les types énumérés et les annotations. Si vous connaissez les éditions
précédentes de ce livre, vous pouvez passer directement à ce chapitre.
Chapitre 5 : La plate-forme Java
Ce chapitre consiste en une vue d’ensemble des API Java essentielles traitées dans ce
livre. Il contient de nombreux petits exemples qui montrent comment exécuter des
tâches courantes avec les classes et interfaces formant la plate-forme Java. Les
programmeurs qui débutent en Java, et particulièrement ceux qui apprennent mieux
par l’exemple, apprécieront particulièrement ce chapitre.
javaNut.book Page xx Dimanche, 29. janvier 2006 10:04 22
xx
Préface
Chapitre 6 : La sécurité en Java
Ce chapitre explique l’architecture de la sécurité en Java permettant à du code non
fiable de s’exécuter dans un environnement sécurisé depuis lequel il ne peut pas
infliger de dommages au système hôte. Il est important pour tous les programmeurs
Java de posséder des connaissances de base relatives aux mécanismes de sécurité en
Java.
Chapitre 7 : Conventions de programmation et de documentation en Java
Ce chapitre couvre les conventions de programmation Java importantes et largement
adoptées, y compris les conventions d’attribution de noms propres aux JavaBeans. Il
explique également comment rendre votre code Java auto-documenté en incluant
des commentaires de documentation spécialement formatés.
Chapitre 8 : Outils de développement Java
Le JDK fourni par Sun comprend un certain nombre d’outils de développement Java
utiles, principalement l’interpréteur Java et le compilateur Java. Ce chapitre décrit ces
outils.
Ces huit premiers chapitres vous enseignent le langage Java et vous donnent le niveau suffisant pour utiliser activement les API de Java. La seconde partie du livre est composée
d’un guide de référence succinct mais détaillé des API, formaté pour un confort d’utilisation optimal. Donnez-vous la peine de lire la section Comment utiliser ce guide de référence,
qui apparaît au début de la section de référence ; elle explique comment en tirer le
meilleur parti. Notez également que les chapitres du guide de référence sont suivis d’un
dernier chapitre intitulé Index des classes, méthodes et des champs. Cet index particulier vous
permet de chercher le nom d’une classe et de trouver le paquetage dans lequel il se trouve,
ou de chercher le nom d’une méthode ou d’un champ et de découvrir la classe dans
laquelle il ou elle est définie.
Ouvrages apparentés
O’Reilly consacre une collection entière de livres à la programmation Java, y compris
plusieurs ouvrages qui accompagnent celui-ci. Les compagnons du présent ouvrage sont :
Java Examples in a Nutshell
Ce livre contient des centaines d’exemples complets et fonctionnels illustrant de
nombreuses tâches courantes de programmation Java, en utilisant le noyau des API,
les classes distribuées et les classes graphiques. Exemples en Java in a Nutshell ressemble
au chapitre 4 du présent ouvrage, mais largement étendu en largeur et en profondeur, où tous les extraits de code sont complétés sous la forme d’exemples
fonctionnels. Il s’agit d’un livre particulière valable pour les lecteurs qui apprennent
facilement en expérimentant du code existant.
javaNut.book Page xxi Dimanche, 29. janvier 2006 10:04 22
Exemples en ligne
xxi
Java Enterprise in a Nutshell
Ce livre représente un tutoriel succint et un guide de référence des API distribuées de
Java, telles que JDBC, RMI, JNDI et CORBA. Il traite également des outils tels que
Hibernate, Struts, ant, JUnit et XDoclet.
J2ME in a Nutshell
Ce livre représente un tutoriel et un guide de référence des API graphiques, réseau et
d’accès aux bases de données de la plate-forme Java 2, Édition Micro (J2ME).
Vous pouvez trouver une liste complète des livres traitant de Java publiés par O’Reilly &
Associates à l’adresse http://java.oreilly.com/1. Les livres qui se concentrent sur les API Java de
base, comme le fait le présent ouvrage, se composent de :
Learning Java, de Pat Niemeyer et Jonathan Knudsen
Une introduction exhaustive à Java, avec un accent porté sur la programmation Java
côté client.
Java Swing, de Marc Loy, Robert Eckstein, Dave Wood, James Elliott et Brian Cole
Ce livre, qui propose une excellente présentation des API de Swing, est incontournable pour les développeurs d’interfaces utilisateur graphiques.
Java Threads, de Scott Oaks et Henry Wong
Java facilite la programmation en threads mais son utilisation correcte peut s’avérer
délicate. Ce livre explique tout ce que vous devez connaître sur le sujet.
Java I/O, de Elliotte Rusty Harold
L’architecture des entrées/sorties Java basée sur les flux est un concept d’une rare
beauté. Ce livre la traite avec la précision qu’elle mérite.
Java Network Programming, de Elliotte Rusty Harold
Ce livre traite en profondeur des API Java relatives à l’interconnexion de réseaux.
Java Security, de Scott Oaks
Ce livre explique en détail les mécanismes de contrôle d’accès de Java et explore également les mécanismes d’authentification des signatures numériques et des message digest.
Java Cryptography, de Jonathan Knudsen
Ce livre décrit de façon approfondie l’Extension de Cryptographie Java, les paquetages
javax.crypto.*, et tout ce que vous devez savoir à propos de la cryptographie en Java.
Exemples en ligne
Les exemples de ce livre sont disponibles en ligne et peuvent être téléchargés depuis la
page web du livre.
1. NdT : ou, pour les traductions françaises, http://www.digitbooks.fr
javaNut.book Page xxii Dimanche, 29. janvier 2006 10:04 22
xxii
Préface
Conventions utilisées dans ce livre
Nous utilisons les conventions typographiques suivantes dans ce livre :
Le Monde italic
Utilisé pour mettre l’accent sur un terme ainsi que pour signifier la première
apparition d’un terme. Le style italique est également utilisé pour les commandes, les
adresses email, les sites web, les sites FTP, les noms de fichiers et de répertoires et les
newsgroups.
Le Monde bold
Occasionnellement utilisé pour faire référence à des touches particulières du clavier
ou à des parties de l’interface utilisateur, telles que le bouton Retour ou le menu
Options.
TheSansMono Condensed
Utilisé pour tout extrait de code Java et généralement pour tout ce que vous saisirez
de manière littérale en programmant, y compris les mots clés, les types de données,
les constantes, les noms de méthodes, les variables, les noms de classes et les noms
d’interfaces.
TheSansMono Condensed italic
Utilisé avec les noms d’arguments des fonctions et généralement pour indiquer
l’endroit où un élément devra être remplacé par une valeur concrète dans votre
programme.
Le Monde Sans
Utilisé dans les résumés des classes Java au sein du guide de référence. Cette police de
caractères très étroite nous permet de placer beaucoup d’informations sur la page
sans trop de sauts de ligne gênants. Cette police est également utilisée avec des
extraits de code dans les descriptions du guide de référence.
Le Monde Sans bold
Utilisé pour mettre en évidence les noms des classes, des méthodes, des champs, des
propriétés et des constructeurs dans le guide de référence, ce qui facilite le survol des
résumés des classes.
Le Monde Sans italic
Utilisé avec les noms des paramètres des méthodes et les commentaires au sein du
guide de référence.
Contact
Aidez-nous à améliorer les éditions futures de ce livre en nous rapportant les erreurs, imprécisions, bogues, instructions équivoques ou embrouillées et même les bonnes vieilles fautes
de frappe que vous y trouveriez. Faites-nous également savoir quelles mesures nous devrions
prendre pour rendre ce livre plus utile à vos yeux. Nous étudierons sérieusement vos
javaNut.book Page xxiii Dimanche, 29. janvier 2006 10:04 22
Comment le guide de référence est-il généré ?
xxiii
commentaires et essayerons d’introduire les suggestions raisonnables dans nos éditions
futures. Vous pouvez nous contacter en écrivant à :
Éditions Digit Books
15, rue Fréminville
29200 Brest
Comment le guide de référence est-il généré ?
À l’attention du lecteur pointilleux ou tout simplement curieux, cette section explique
comment ont été créés les guides de référence de Java in a Nutshell et des ouvrages apparentés, dans leur version américaine.
Le système de génération du guide de référence à évolué a l’unisson de Java lui-même. Le
système actuel fait partie d’un système commercial mis au point pour faciliter la navigation dans une documentation (visitez http://www.davidflanagan.com/Jude/ pour de plus
amples informations). Le programme fonctionne en deux étapes : la première étape
consiste à rassembler et à organiser les informations relatives aux API, puis la seconde
étape à afficher ces informations sous la forme de chapitres dans le guide de référence.
Dans la première étape, le système commence par lire les fichiers de classe de toutes les
classes et et de toutes les interfaces à documenter. Quasiment toutes les informations
relatives aux API du guide de référence sont disponibles dans ces fichiers de classe. La seule
exception notable concerne les noms des arguments des méthodes qui ne sont pas enre-
javaNut.book Page xxiv Dimanche, 29. janvier 2006 10:04 22
xxiv
Préface
gistrés dans les fichiers de classe. Ces noms d’arguments sont obtenus en analysant le
fichier source Java de chaque classe et de chaque interface. Là où les fichiers source ne
sont pas disponibles, j’obtiens les noms des arguments des méthodes en analysant la
documentation des API générée par javadoc. Les analyseurs que j’utilise pour extraire les
informations relatives aux API à partir des fichiers source et des fichiers javadoc sont
créés par le biais du générateur d’analyseurs Antlr développé par Terrence Parr du Magelang Institute. (voir http://www.antlr.org/ pour plus de détails à propos de ce puissant outil
de programmation.)
Une fois que les informations relatives aux API sont obtenues par lecture des fichiers de
classe, des fichiers source et des fichiers javadoc, le programme prend un peu de temps
pour trier et établir des références croisées de l’ensemble. Puis il enregistre les informations relatives aux API dans un seul grand fichier de données.
Dans la seconde étape, le système lit les informations relatives aux API à partir du fichier
de données et produit les chapitres d’un guide de référence en utilisant un format XML
personnalisé. Une fois que j’ai généré les données de sortie XML, je les transmets à
l’équipe de production de O’Reilly & Associates. Ils les traitent et les convertissent en code
source troff. Le code source troff est traité au moyen du programme GNU groff (ftp://
ftp.gnu.org/gnu/groff/) et d’un ensemble personnalisé de macros troff afin de produire
le résultat PostScript directement envoyé à l’imprimeur.
Remerciements
De nombreuses personnes m’ont aidé à créer ce livre et je leur en suis reconnaissant. J’ai
une dette envers les très nombreux lecteurs des deux premières éditions qui m’ont
communiqué leurs commentaires, suggestions, comptes-rendus de bogues ou leurs éloges.
Leurs multiples petites contributions sont éparpillées au sein du livre. Mes excuses vont
cependant à tous ceux qui m’ont fait de nombreuses et bonnes suggestions qui n’ont pu
être incorporées dans cette édition.
Deb Cameron a été l’éditrice de la cinquième édition de ce livre. Deb n’a pas seulement
édité le nouveau contenu de cette édition, mais a aussi pris le temps de relire et de
suggérer des mises à jour du contenu existant. Deb s’est montée patiente lorsque mon
travail sur ce livre a pris une direction inattendue et m’a donné de judicieux conseils pour
me remettre sur le droit chemin. La quatrième édition fut éditée par Bob Eckstein, un
éditeur consciencieux doté d’un solide sens de l’humour. Paula Ferguson, amie et
collègue, a été l’éditrice des trois premières éditions de ce livre. Sa lecture attentive et ses
suggestions toujours pratiques ont amélioré le livre.
Les nouveautés de cette édition ont été relues par un certain nombres d’ingénieurs de
première qualité. Gilad Bracha, de Sun, a relu les portions consacrées aux types génériques. Josh Bloch, un ancien employé de Sun qui travaille désormais chez Google, a relu les
portions consacrées aux types énumérés et aux annotations. Josh était déjà relecteur pour
les troisième et quatrième éditions de ce livre et ses commentaires avisés m’ont toujours
été d’un très grand secours. Je recommande vivement le livre de Josh, Effective Java
Programming Guide (Addison Wesley). Neal Gafter qui, tout comme Josh, a quitté Sun
javaNut.book Page xxv Dimanche, 29. janvier 2006 10:04 22
Remerciements
xxv
pour Google, a répondu à de nombreuses questions concernant les annotations et les
types génériques. David Biesack de SAS, Changshin Lee de l’entreprise coréenne Tmax
Soft et Tim Peierls furent mes collègues au sein du groupe d’experts JSR-201 responsable
de plusieurs changements du langage dans Java 5.0. Ils ont relus les portions consacrées
aux types génériques et énumérés. Joseph Bowbeer, Brian Goetz et Bill Pugh étaient
membres des groupes d’experts JSR-166 et JSR-133 et m’ont aidé à comprendre la
programmation à threads multiples du paquetage java.util.concurrency. Iris Garcia de
Sun a répondu à mes questions concernant la classe java.util.Formatter, dont elle est
l’auteur. J’adresse mes remerciements les plus sincères à tous ces ingénieurs pour leur
travail attentif. Toutes les erreurs qui pourraient encore se trouver dans ce livre me sont
bien évidemment imputables.
La quatrième édition fut également relue par un certains nombres d’ingénieurs de chez
Sun ou d’ailleurs. Josh Bloch a relu les portions consacrées aux assertions et à l’API des
préférences. Bob Eckstein a relu les parties consacrées à XML. Graham Hamilton a relu
l’API de tenue des journaux de bord. Ron Hitchens a relu tout ce qui concerne la nouvelle
API d’entrées/sorties. Jonathan Knudsen (également un auteur O’Reilly) a relu les
portions consacrées à JSSE et Charlie Lai celles consacrées à JAAS. Ram Marti a relu le
texte de JGSS. Philipp Milne, un ancien employé de Sun aujourd’hui chez Dresdner
Kleinwort Wasserstein, a relu les parties traitant le mécanisme de persistence des JavaBeans. Mark Reinhold a relu le paquetage java.nio. Mark mérite des remerciements
particuliers pour avoir été un relecteur des deuxième, troisième et quatrième éditions de
ce livre. Andreas Sterbenz et Brad Wetmore ont relu les parties consacrées à JSSE.
La troisième édition a aussi grandement bénéficié des contributions de relecteurs qui
connaissent de manière intime la plate-forme Java. Joshua Block, l’un des principaux
auteurs de la structure des collections Java, a revu mes descriptions des classes et des interfaces relatives aux collections. L’aide de Joshua a également été précieuse lorsqu’il a discuté
avec moi des classes Timer et TimerTask de Java 1.3. Mark Reinhold, créateur du paquetage
java.lang.ref, m’a expliqué son œuvre et a relu ma documentation. Scott Oaks a revu mes
descriptions des classes et des interfaces Java relatives à la sécurité et à la cryptographie.
Joshua, Mark et Scott sont tous ingénieurs chez Sun Microsystems et je leur suis très
reconnaissant pour le temps qu’ils ont consacré à ce livre. La documentation du paquetage javax.crypto et de ses sous-paquetages a également été revue par Jon Eaves. Jon a
travaillé sur une implémentation de l’Extension Cryptographique de Java (qui est disponible à l’adresse http://www.ava.net.au/) et ses commentaires ont été utiles. Jon travaille à
présent chez Fluent Technologies (http://www.fluent.com.au/) en tant que consultant dans les
domaines traitant de Java et du commerce électronique. Enfin, le chapitre 1 a été amélioré
par les commentaires de relecteurs qui ne connaissaient pas encore la plate-forme Java :
Christina Byrne l’a revu avec l’œil de la programmatrice novice et Judita Byrne de
Virginia Power a offert ses commentaires de programmatrice COBOL professionnelle.
Pour la deuxième édition, John Zukowski a revu le contenu du guide de référence AWT
Java 1.1 et George Reese la majeure partie du nouveau contenu restant. La deuxième
édition a également bénéficié d’une équipe de relecteurs techniques de rêve issus de Sun.
John Rose, auteur de la spécification des classes internes de Java, a revu le chapitre relatif
aux classes internes. Mark Reinhold, auteur des nouvelles classes traitant des f lux de carac-
javaNut.book Page xxvi Dimanche, 29. janvier 2006 10:04 22
xxvi
Préface
tères dans java.io, a revu ma documentation relative à ces classes. Nakul Saraiya,
concepteur de la nouvelle API de Réflexion Java, a revu ma documentation du paquetage
java.lang.reflect. Je suis très reconnaissant envers ces ingénieurs et architectes ; grâce à eux
ce livre a gagné en qualité et en précision.
Mike Loukides a fourni des conseils de haut niveau pour la première édition de ce livre.
Eric Raymond et Troy Downing ont revu cette première édition – ils m’ont aidé à repérer
mes erreurs et omissions et m’ont donné de bons conseils pour rendre le livre plus utile
aux programmeurs Java.
L’équipe de production de O’Reilly & Associates a fourni son excellent travail habituel en
faisant naître un livre des fichiers électroniques que je lui ai remis. Mes remerciements
vont à tous.
Comme toujours, mes remerciements et mon amour vont à Christie.
David Flanagan
http://www.davidflanagan.com
Mars 2005
javaNut.book Page 1 Dimanche, 29. janvier 2006 10:04 22
Chapitre 3 La programmation orientée objet en Java
PARTIE I
Introduction à Java
Cette première partie est une introduction au langage et à la plate-forme Java. Ces chapitres vous fourniront les informations nécessaires pour une bonne prise en main de Java.
Chapitre 1, Introduction
Chapitre 2, La syntaxe Java
Chapitre 3, La programmation orientée objet en Java
Chapitre 4, Nouveautés du langage 5.0
Chapitre 5, La plate-forme Java
Chapitre 6, La sécurité en Java
Chapitre 7, Conventions de programmation et de documentation en Java
Chapitre 8, Outils de développement Java
javaNut.book Page 2 Dimanche, 29. janvier 2006 10:04 22
javaNut.book Page 3 Dimanche, 29. janvier 2006 10:04 22
Introduction
Chapitre 1 : Introduction
CHAPITRE 1
Introduction
Bienvenue dans l’univers Java. Ce chapitre commence par expliquer ce qu’est Java, puis
décrit certaines caractéristiques qui le distinguent d’autres langages de programmation.
Ensuite, il fait un bref compte rendu de la structure de ce livre, avec un accent particulier
sur les nouveautés de Java 5.0. Enfin, sous forme d’introduction concrète au langage, il
vous promène dans un programme Java simple que vous pouvez saisir, compiler et
exécuter.
Qu’est-ce que Java ?
Lorsque l’on parle de Java, il est important de faire la distinction entre le langage de
programmation Java, la machine virtuelle Java et la plate-forme Java. Le langage de
programmation Java est le langage dans lequel les applications Java (y compris les applets,
les servlets et les composants) sont écrites. Lorsqu’un programme Java est compilé, il est
converti en byte-code correspondant au langage machine portable d’une architecture
processeur à une autre connue sous le nom de machine virtuelle Java, également appelée
Java VM ou JVM, c’est-à-dire Java Virtual Machine en anglais. La VM Java peut être mise
en œuvre sous forme matérielle mais elle est généralement mise en œuvre sous la forme
d’un programme logiciel qui interprète et exécute le byte-code.
La plate-forme Java se distingue à la fois du langage Java et de la machine virtuelle Java.
La plate-forme Java correspond à un ensemble prédéfini de classes Java qui existent sur
chaque installation Java ; ces classes sont disponibles pour tous les programmes Java. La
plate-forme Java est parfois mentionnée sous le nom d’environnement d’exécution Java
ou de noyau des API Java (API pour Application Programming interfaces, c’est-à-dire interfaces de programmation d’applications). La plate-forme Java peut être étendue au moyen
d’extensions standard facultatives. Ces API étendues existent dans certaines installations
Java mais il n’est pas garanti qu’elles se trouvent dans toutes les installations.
javaNut.book Page 4 Dimanche, 29. janvier 2006 10:04 22
4
Chapitre 1 : Introduction
Le langage de programmation Java
Le langage de programmation Java est un langage orienté objet de pointe dont la syntaxe
est similaire à celle du langage C. Les concepteurs du langage se sont efforcés de rendre le
langage Java puissant tout en essayant d’éviter les caractéristiques trop complexes qui ont
entravé d’autres langages orientés objet tels que C++. En gardant le langage simple, ses
concepteurs ont également facilité la tâche des programmeurs pour écrire du code robuste
et sans bogue. Grâce à sa conception élégante et à ses caractéristiques de langage moderne,
le langage Java est devenu incroyablement populaire auprès des programmeurs, qui considèrent généralement que travailler avec Java est un plaisir, après avoir peiné avec des
langages plus difficiles et moins puissants.
Java 5.0, la version la plus récente du langage Java1, inclut un certain nombre de
nouveautés, y compris les types génériques, qui augmentent à la fois la complexité et la
puissance du langage. Les programmeurs Java plus expérimentés ont accueilli ces
nouveautés avec enthousiasme, en dépit de la complexité supplémentaire qu’elles
apportent.
La machine virtuelle Java
La machine virtuelle Java, ou interpréteur Java, représente la pièce maîtresse de toute
installation Java. À dessein, les programmes Java sont portables, mais ils ne le sont que
pour des plates-formes sur lesquelles un interpréteur Java existe. Sun fournit des implémentations de VM avec son propre système d’exploitation Solaris ainsi que pour les
plates-formes Microsoft Windows et Linux. De nombreux autres constructeurs, y compris
Apple et divers constructeurs Unix, fournissent des interpréteurs Java pour leurs platesformes respectives. Cependant, la machine virtuelle Java n’existe pas que pour les ordinateurs de bureau. Elle a été portée sur des set-top box2, et des versions sont même
disponibles sur des périphériques équipés de Windows CE ou PalmOS.
Bien que les interpréteurs ne soient généralement pas considérés comme des systèmes à
haute performance, la performance de la VM Java est remarquablement bonne et s’est
accrue de manière constante au fil des versions du langage. Les versions les plus récentes
s’exécutent spectaculairement vite. On relèvera tout particulièrement une technologie liée
à la VM appelée juste-à-temps (JIT, pour just-in-time), par laquelle le byte-code Java est
converti à la volée en langage machine natif de la plate-forme sur laquelle tourne le
programme, augmentant la vitesse d’exécution des portions de code exécutées de manière
répétitive.
La plate-forme Java
La plate-forme Java est aussi importante que le langage de programmation Java et que la
machine virtuelle Java. Tous les programmes écrits dans le langage Java dépendent de
l’ensemble des classes prédéfinies qui forment la plate-forme Java. Les classes Java sont
1. Java 5.0 représente un changement significatif dans la numérotation des versions du langage de Sun. La version précédente de Java était la version 1.4, raison pour laquelle Java 5.0 est parfois informellement appelée Java 1.5.
2. NdT : une set-top box est une unité qui permet à une télévision de se transformer en interface utilisateur pour Internet.
javaNut.book Page 5 Dimanche, 29. janvier 2006 10:04 22
Qu’est-ce que Java ?
5
Il est important de comprendre ce que signifie le terme plate-forme. Pour un
programmeur informatique, une plate-forme est définie par les API sur lesquelles il
peut s’appuyer lors de la rédaction de programmes. Ces API sont généralement définies par le système d’exploitation de l’ordinateur cible. Par conséquent, un
programmeur écrivant un programme à exécuter sous Microsoft Windows doit
utiliser un jeu d’API différent qu’un programmeur écrivant le même programme
pour un système Unix. À cet égard, Windows et Unix représentent des plates-formes
distinctes.
Java n’est pas un système d’exploitation. Néanmoins, la plate-forme Java – en particulier
la plate-forme Java 2 – fournit des API dont l’ampleur et la portée sont comparables à
celles définies par un système d’exploitation. Avec la plate-forme Java 2, vous pouvez
écrire des applications en Java sans faire le sacrifice des caractéristiques avancées à la
disposition des programmeurs rédigeant des applications natives ciblées pour un système
d’exploitation sous-jacent particulier. Une application écrite sur la plate-forme Java
s’exécute sur tout système d’exploitation prenant en charge cette plate-forme. Cela signifie
que vous n’avez pas à créer des versions distinctes de votre programme adaptées à
Windows, Mac OS et Unix, par exemple. Un seul programme Java s’exécute sur tous ces
systèmes d’exploitation, ce qui explique pourquoi « écrire une fois, exécuter partout » est
la devise de Sun pour Java.
La plate-forme Java ne représente pas un système d’exploitation mais aux yeux des
programmeurs, elle représente une cible de développement alternative qui, à ce titre,
s’avère très populaire. La plate-forme Java réduit la dépendance des programmeurs visà-vis du système d’exploitation sous-jacent et, en permettant aux programmes de
s’exécuter au-dessus de n’importe quel système d’exploitation, elle augmente la liberté
des utilisateurs finaux dans leur choix d’un système d’exploitation.
Les versions de Java
Au moment où ces lignes sont rédigées, il existe six versions principales de Java. Il s’agit
de :
Java 1.0
Il s’agit de la première version publique de Java. Elle contient 212 classes organisées
en 8 paquetages. Cette version offrait simplicité et élégance, mais elle est totalement
dépassée aujourd’hui.
Java 1.1
Avec cette version, la taille de la plate-forme Java a doublé pour passer à 504 classes
réparties en 23 paquetages. Elle a introduit les classes internes, qui représentent un
3. Une classe est un module de code Java qui définit une structure de données et un ensemble de méthodes (également
appelées procédures, fonctions ou sous-routines) qui agissent sur ces données.
Introduction
organisées en groupes apparentés connus sous le nom de paquetages3. La plate-forme Java
définit des paquetages pour des fonctionnalités concernant les entrées/sorties, l’interconnexion de réseaux, les composants graphiques, la création d’interfaces utilisateur, la
sécurité et plus encore.
javaNut.book Page 6 Dimanche, 29. janvier 2006 10:04 22
6
Chapitre 1 : Introduction
changement important dans le langage Java et elle présente des améliorations de
performance significatives de la VM Java. Cette version est cependant dépassée
aujourd’hui.
Java 1.2
Il s’agit d’une version importante de Java, qui a triplé la taille de la plate-forme pour
atteindre 1520 classes réparties en 59 paquetages. Parmi les nouveautés les plus
importantes, citons l’API des collections permettant de travailler avec des ensembles,
des listes et des dictionnaires d’objets, ainsi que la nouvelle API Swing pour développer des interfaces utilisateur graphiques. En raison des nombreuses
caractéristiques ajoutées dans la version 1.2, la plate-forme fut renommée « plateforme Java 2 ». Cependant, le terme « Java 2 » était simplement une marque de
fabrique et pas un véritable numéro de version.
Java 1.3
Il s’agit principalement d’une version de maintenance, consacrée à la correction de
bogues, à l’amélioration de la stabilité et des performances (notamment grâce à la
machine virtuelle de haute performance « HotSpot »). Les nouveautés apportées à la
plate-forme incluent les API JNDI et Java Sound, précédemment disponibles sous
forme d’extensions. Les nouvelles classes les plus intéressantes sont probablement les
classes java.util.Timer et java.lang.reflect.Proxy. Au total, la version 1.3 de la
plate-forme Java contient 1842 classes réparties en 76 paquetages.
Java 1.4
Il s’agissait d’une autre version majeure ajoutant d’importantes fonctionnalités et
accroissant la taille de la plate-forme de 62 %, pour atteindre 2 991 classes et interfaces dans 135 paquetages. Parmi les nouveautés, citons une API d’entrée/sortie de
bas niveau et de haute performance ; la prise en charge des mises en correspondance
de motifs à l’aide d’expressions régulières ; une API de tenue des journaux de bord ;
une API pour la gestion des préférences ; de nouvelles classes de collections ; un
mécanisme de persistance basé sur XML pour les JavaBeans ; la prise en charge de
l’analyse syntaxique XML en utilisant les API DOM et SAX ; l’authentification des
utilisateurs avec l’API JAAS ; la prise en charge des connexions réseau sécurisées en
utilisant le protocole SSL ; la prise en charge de la cryptographie ; une nouvelle API
pour lire et écrire les fichiers d’images ; un API pour l’impression depuis le réseau ;
une poignée de nouveaux composants GUI dans l’API Swing ; une architecture
glisser/déposer simplifiée pour Swing. Outre ces modifications apportées à la plateforme, la version 1.4 de Java ajoute l’instruction assert au langage.
Java 5.0
La version la plus récente de Java introduit un certain nombre de changements dans
le noyau du langage-même, y compris les types génériques, les types énumérés, les
annotations, les méthodes à arguments variables (varargs), « l’autoboxing » et une
nouvelle instruction for/in. En raison de ces changements majeurs apportés au
langage, le numéro de version a été incrémenté. Logiquement, cette version aurait dû
s’appeler Java 2.0 si Sun n’avait pas déjà utilisé le terme Java 2 à des fins de marketing pour présenter Java 1.2.
javaNut.book Page 7 Dimanche, 29. janvier 2006 10:04 22
Les avantages clés de Java
7
Consultez la préface pour obtenir la liste des changements apportés à cette édition du
livre, y compris des pointeurs vers les nouveautés du langage et de la plate-forme.
Pour écrire des programmes en Java, vous devez obtenir le kit de développement Java
(JDK, pour Java Development Kit). Sun publie une nouvelle version du JDK pour chaque
nouvelle version de Java. Ne confondez pas JDK avec l’environnement d’exécution Java
(JRE, pour Java Runtime Environment). L’environnement JRE contient tout ce dont vous
avez besoin pour exécuter des programmes Java, mais il ne contient pas les outils nécessaires au développement de programmes Java (avant tout le compilateur).
Outre l’édition standard de Java utilisée par la plupart des développeurs Java et documentée dans ce livre, Sun publie aussi la plate-forme Java 2, Enterprise Edition (ou J2EE)
pour les développeurs de systèmes distribués, et la plate-forme Java 2, Micro Edition
(J2ME), pour les appareils électroniques, par exemple les assistants personnels numériques et les téléphones cellulaires. Consultez Java Enterprise in a Nutshell (édition française)
et Java Micro Edition in a Nutshell (tous deux chez O’Reilly) pour plus d’informations sur
ces autres éditions.
Les avantages clés de Java
Pourquoi utiliser Java ? Cela vaut-il la peine d’apprendre un nouveau langage et une
nouvelle plate-forme ? Cette section explore quelques avantages clés de Java.
Écrire une fois, exécuter partout
Sun fait de la devise « écrire une fois, exécuter partout » la proposition centrale de la
plate-forme Java. Traduite du jargon des affaires, cette maxime signifie que la promesse la
plus importante du langage Java consiste à n’écrire votre application qu’une seule fois
– pour la plate-forme Java – puis à être en mesure de l’exécuter partout.
Partout, sous-entendu partout où la plate-forme Java est prise en charge. Heureusement,
la prise en charge de Java devient omniprésente. Java est intégré, ou en phase d’intégration, dans pratiquement tous les systèmes d’exploitation principaux. Il est embarqué au
sein des navigateurs web populaires, ce qui le place virtuellement sur chaque PC connecté
à Internet dans le monde. Il est même embarqué dans les unités électroniques telles que
les set-top box de télévision, les assistants personnels numériques et les téléphones
cellulaires.
Introduction
Outre les changements apportés au langage, Java 5.0 ajoute également plusieurs
éléments à la plate-forme Java. Cette version inclut 3562 classes et interfaces au sein
de 166 paquetages. Les additions notables incluent des utilitaires pour la programmation concurrente, un cadre de gestion à distance et des classes pour une gestion et
une instrumentation à distance de la VM Java elle-même.
javaNut.book Page 8 Dimanche, 29. janvier 2006 10:04 22
8
Chapitre 1 : Introduction
Sécurité
Un autre avantage clé de Java tient à ses caractéristiques en matière de sécurité. Autant le
langage que la plate-forme ont été pensés dès leurs origines avec la notion de sécurité à
l’esprit. La plate-forme Java permet aux utilisateurs de télécharger du code non fiable sur
un réseau et de l’exécuter dans un environnement sécurisé au sein duquel il ne peut pas
commettre le moindre dommage : il ne peut pas infecter le système hôte avec un virus, ne
peut ni lire, ni écrire dans les fichiers du disque dur, etc. Cette seule aptitude rend la plateforme Java unique.
Java 1.2 a poussé le modèle de sécurité un peu plus loin. Elle crée des niveaux de sécurité
et des restrictions hautement configurables qu’elle étend au-delà des applets. Dès Java 1.2,
tout code Java, qu’il s’agisse d’une applet, d’une servlet, d’un composant JavaBean ou
d’une application Java complète, peut être exécuté avec des permissions réduites qui
l’empêchent de s’attaquer au système hôte.
Les caractéristiques de sécurité du langage et de la plate-forme Java ont fait l’objet d’un
examen approfondi par des experts en sécurité du monde entier. Alors que le langage
faisait ses premiers pas, plusieurs bogues liés à la sécurité (certains d’entre eux potentiellement sérieux) furent découverts et corrigés. En raison des promesses de Java en matière de
sécurité, la découverte d’un nouveau bogue dans ce domaine représente une nouvelle
importante. Gardez toutefois à l’esprit qu’aucune autre plate-forme dominante ne peut
apporter des garanties de sécurité dont la robustesse approche celles de Java. Personne ne
peut affirmer que des failles de sécurité ne seront pas découvertes dans le futur, mais si la
sécurité de Java n’est pas encore parfaite, elle s’est révélée suffisamment puissante pour un
usage pratique quotidien et certainement supérieure à toute autre alternative.
Programmation centrée sur les réseaux
La devise d’entreprise de Sun a toujours été « Le réseau est l’ordinateur ». Les concepteurs
de la plate-forme Java croient en l’importance de l’interconnexion des réseaux et ils ont
conçu la plate-forme Java de telle sorte qu’elle soit centrée sur le réseau. Du point de vue
du programmeur, Java facilite incroyablement le travail avec des ressources disséminées
sur un réseau ainsi que la création d’applications réseau utilisant des architectures client/
serveur ou multi-utilisateurs.
Des programmes dynamiques et extensibles
Java est à la fois dynamique et extensible. Le code Java est organisé en unités orientées
objet appelées classes. Les classes sont enregistrées dans des fichiers séparés et sont chargées dans l’interpréteur Java uniquement en cas de nécessité. Cela signifie qu’une
application peut décider à l’exécution quelles classes sont nécessaires et qu’elle peut les
charger au besoin. Cela signifie également qu’un programme peut s’étendre dynamiquement en chargeant les classes dont il a besoin pour étendre ses fonctionnalités.
La conception centrée sur le réseau de la plate-forme Java signifie qu’une application Java
peut s’étendre dynamiquement en chargeant de nouvelles classes depuis un réseau. Une
javaNut.book Page 9 Dimanche, 29. janvier 2006 10:04 22
Les avantages clés de Java
9
Internationalisation
Le langage Java ainsi que la plate-forme Java ont été conçus dès le départ avec à l’esprit
une ouverture sur le reste du monde. À l’époque de sa création, Java était le seul langage
de programmation couramment utilisé possédant des caractéristiques d’internationalisation intégrées plutôt qu’ajoutées après coup. Alors que la plupart des langages de
programmation utilisent les caractères encodés sur 8 bits qui ne permettent de représenter que les alphabets anglais et les langues d’Europe de l’ouest, Java utilise les
caractères Unicode sur 16 bits qui représentent les alphabets phonétiques ainsi que les
jeux de caractères idéographiques du monde entier. Cependant, les caractéristiques
d’internationalisation de Java ne sont pas limitées à la représentation de bas niveau des
caractères. Ces caractéristiques imprègnent la plate-forme Java, facilitant la rédaction de
programmes internationaux avec Java plutôt qu’avec n’importe quel autre
environnement.
Performances
Comme je l’ai décrit précédemment, les programmes Java sont compilés sous une forme
intermédiaire portable connue sous le nom de byte-code, plutôt que sous la forme
d’instructions en langage machine natif. La machine virtuelle Java exécute un programme
Java en interprétant ces instructions byte-code portables. Cette architecture signifie que
les programmes Java sont plus rapides que les programmes ou les scripts rédigés dans des
langages purement interprétés, mais ils restent d’habitude plus lents que les programmes
C et C++ compilés en langage machine natif. Gardez cependant à l’esprit que, bien que les
programmes Java soient compilés sous forme de byte-code, toute la plate-forme Java n’est
pas implémentée avec du byte-code interprété. Pour des raisons d’efficacité, les portions
de la plate-forme Java exigeantes en termes de calcul – telles que les méthodes de manipulation des chaînes de caractères – sont implémentées en code machine natif.
Bien que les versions primitives de Java souffrent de problèmes de performance, la vitesse
de la VM Java s’est remarquablement améliorée avec chaque nouvelle sortie. La VM a été
finement paramétrée et optimisée de diverses manières. De plus, la plupart des mises en
œuvre comprennent un compilateur juste-à-temps (JIT) qui convertit sur-le-champ le
byte-code Java en instructions machine natives. En utilisant des compilateurs JIT sophistiqués, les programmes Java peuvent s’exécuter à des vitesses comparables à celles
d’applications C et C++ natives.
Java est un langage portable et interprété ; les programmes Java s’exécutent presque
aussi rapidement que les programmes C et C++ natifs et non portables. Par le passé, les
questions de performances poussaient certains programmeurs à éviter Java. À présent,
avec les améliorations apportées dans Java 1.2, 1.3, 1.4 et 5.0, les problèmes de performances ne doivent plus rebuter quiconque.
Introduction
application qui tire avantage de ces caractéristiques ne représente plus un bloc de code
monolithique. Au lieu de cela, elle se transforme en une collection de composants logiciels capables de dialoguer. Ainsi, Java rend possible un nouveau paradigme de
conception et de développement d’applications.
javaNut.book Page 10 Dimanche, 29. janvier 2006 10:04 22
10
Chapitre 1 : Introduction
Efficacité du programmeur et délai d’arrivée au marché
La raison finale, et peut-être la plus importante, justifiant l’utilisation de Java vient
du fait que les programmeurs l’aiment. Java est un langage élégant combiné à un jeu
d’API puissant et bien conçu. Les programmeurs aiment programmer en Java et sont
généralement impressionnés par la rapidité avec laquelle ils peuvent obtenir des résultats. Les études ont constamment montré qu’une migration vers Java augmente
l’efficacité des programmeurs. Parce que Java est un langage simple et élégant possédant
un jeu d’API bien conçu et intuitif, les programmeurs écrivent un code meilleur
comprenant moins de bogues qu’avec d’autres plates-formes, réduisant encore le temps
de développement.
Un exemple de programme
L’exemple 1-1 montre un programme Java de calcul factoriel.4 Les nombres au début de
chaque ligne ne font pas partie du programme ; ils ont été ajoutés pour faciliter les références lorsque nous disséquerons le programme ligne par ligne.
Exemple 1-1 : Factorial.java : un programme de calcul factoriel
1 /**
2 * Ce programme calcule la valeur factorielle d’un nombre
3 */
4 public class Factorial {
// Définit une classe
5 public static void main(String[] args) { // Ici débute le programme
6
int input = Integer.parseInt(args[0]); // Capture les données d’entrée de l’utilisateur
7
double result = factorial(input);
// Calcule la valeur factorielle
8
System.out.println(result);
// Affiche le résultat
9 }
// Ici s’achève la méthode main()
10
11 public static double factorial(int x) {
// Cette méthode calcule x!
12
if (x < 0)
// Contrôle si la donnée d’entrée est valable
13
return 0.0;
// si elle ne l’est pas, retourne 0
14
double fact = 1.0;
// Début du processus avec une valeur initiale
15
while(x > 1) {
// Boucle jusqu’à ce que x soit égal à 1
16
fact = fact * x;
// multiplie par x à chaque itération
17
x = x - 1;
// puis décrémente x
18
}
// Retourne au début de la boucle
19
return fact;
// Retourne le résultat
20 }
// factorial() s’achève ici
21}
// La classe s’achève ici
Compilation et exécution du programme
Avant de voir comment le programme fonctionne, nous devons d’abord parler de son
exécution. Afin de compiler et d’exécuter le programme, vous avez besoin d’un kit de
développement Java (JDK, pour Java Development Kit). Sun Microsystems a créé le langage
4. Le factoriel d’un nombre entier se calcule par le produit de ce nombre avec tous les entiers positifs inférieurs à ce nombre. Donc, par exemple, le factoriel de 4, que l’on écrit également 4!, correspond à 4 fois 3 fois 2 fois 1, soit 24. Par
définition, 0! est égal à 1.
javaNut.book Page 11 Dimanche, 29. janvier 2006 10:04 22
Un exemple de programme
11
Le JDK de Sun ne représente pas le seul environnement de programmation Java utilisable.
gcj, par exemple, est un compilateur Java distribué sous licence GNU. Un certain nombre
de sociétés commercialisent des environnements de développement intégrés (IDE, pour
integrated development environments). Il existe également d’excellents IDE libres. Ce livre
présuppose que vous utilisez le JDK de Sun et ses outils en ligne de commande. Si vous
utilisez un produit provenant d’un autre fournisseur, lisez la documentation de ce fournisseur pour apprendre comment compiler et exécuter un programme simple, tel que celui
proposé dans l’exemple 1-1.
Une fois votre environnement de programmation Java installé, la première étape en vue
de l’exécution de notre programme consiste à le saisir. En utilisant votre éditeur de texte
préféré, saisissez le programme tel qu’il est présenté dans l’exemple 1-1. Omettez les
numéros de lignes étant donné qu’ils ne se trouvent là qu’à des fins de référence. Notez
que Java est un langage sensible au respect des majuscules/minuscules, ce qui signifie que
vous devez taper les lettres minuscules en minuscules et les lettres majuscules en majuscules. Vous remarquerez que de nombreuses lignes de ce programme s’achèvent par des
points-virgules. Il s’agit d’une erreur courante que d’oublier ces caractères mais le
programme ne fonctionnera pas sans eux, aussi soyez prudent ! Si vous n’êtes pas un
dactylographe rapide, vous pouvez omettre tout ce qui se trouve entre les caractères // et
la fin d’une ligne. Il s’agit de commentaires ; ils se trouvent là pour votre aide et sont
ignorés par Java6.
Lorsque vous écrivez des programmes Java, vous devez utiliser un éditeur de texte qui
sauvegarde les fichiers dans un format textuel pur, non pas un traitement de texte qui
prend en charge les polices de caractères et les règles de formatage et qui sauvegarde les
fichiers dans un format propriétaire. Mon éditeur de texte favori sur les systèmes Unix est
emacs. Si vous utilisez un système Windows, vous devez utiliser Notepad ou WordPad,
pour autant que vous ne possédiez pas un éditeur de programmation plus spécialisé
(certaines versions de GNU Emacs, par exemple, sont disponibles pour Windows). Si vous
utilisez un IDE, ce dernier comprend probablement un éditeur de texte approprié ;
consultez la documentation fournie avec le produit. Lorsque vous avez achevé la saisie du
programme, enregistrez-le dans un fichier nommé Factorial.java. C’est une étape
importante ; le programme ne fonctionnera pas si vous le sauvegardez avec un nom
différent.
5. D’autres entreprises, telles qu’Apple, ont acquis une licence et porté le JDK sur leur propre système d’exploitation.
Dans le cas d’Apple, cet arrangement génère un délai quant à la disponibilité du JDK le plus récent sur leur plate-forme.
6. Il est conseillé de saisir cet exemple à la main afin de vous habituer au langage. Cependant, si vous ne voulez vraiment
pas le saisir, vous pouvez le télécharger, avec tous les autres exemples du livre, à l’adresse http://www.oreilly.com/catalog/
javanut5/.
Introduction
Java et fournit un JDK gratuit pour son système d’exploitation Solaris ainsi que pour les
plates-formes Linux et Microsoft Windows5. Au moment où ces lignes sont rédigées, la
version actuelle du JDK de Sun peut être téléchargée à l’adresse http://java.sun.com/. Soyez
certains d’obtenir le JDK et non l’environnement d’exécution Java JRE (pour Java Runtime
Environment). JRE vous permet d’exécuter des programmes Java existants, mais pas
d’écrire et de compiler les vôtres.
javaNut.book Page 12 Dimanche, 29. janvier 2006 10:04 22
12
Chapitre 1 : Introduction
Après avoir écrit un programme tel que celui-là, la prochaine étape consiste à le compiler.
Avec le JDK de Sun, le compilateur Java s’appelle javac. javac est un outil en ligne de
commande, ce qui signifie que vous ne pouvez l’utiliser que depuis une fenêtre de
terminal telle qu’une fenêtre MS-DOS sur un système Windows ou une fenêtre xterm sur
un système Unix. Compilez le programme en tapant la ligne de commande suivante :
c:\>javac Factorial.java
Si cette commande affiche un quelconque message d’erreur, vous avez probablement
commis une erreur lors de la saisie du programme. S’il n’affiche pas de message d’erreur,
la compilation a réussi et javac crée un fichier nommé Factorial.class. Il s’agit de la
version compilée du programme.
Une fois que vous avez compilé un programme Java, vous devez encore l’exécuter. À la
différence d’autres langages, les programmes Java ne sont pas compilés en langage
machine natif, donc ils ne peuvent pas être directement exécutés par le système. En lieu et
place, ils sont exécutés par un autre programme connu sous le nom d’interpréteur Java.
Dans le JDK de Sun, l’interpréteur est un programme en ligne de commande appelé, de
manière assez appropriée, java. Pour exécuter le programme de calcul factoriel, tapez :
c:\>java Factorial 4
java est la commande qui exécute l’interpréteur Java, Factorial est le nom du programme
Java qui doit être exécuté par l’interpréteur et 4 représente la donnée d’entrée - le nombre
pour lequel nous souhaitons que l’interpréteur calcule la valeur factorielle. Le programme
affiche une seule ligne de sortie, nous indiquant que la factorielle de 4 est 24 :
c:\>java Factorial 4
24.0
Félicitations ! Vous venez d’écrire, compiler et exécuter votre premier programme Java.
Essayez de l’exécuter à nouveau pour calculer les valeurs factorielles d’autres nombres.
Analyse du programme
Maintenant que vous avez exécuté le programme de calcul factoriel, analysons-le ligne par
ligne pour découvrir comment fonctionne un programme Java.
Commentaires
Les trois premières lignes du programme représentent un commentaire. Java les ignore
mais elles indiquent à un programmeur ce que fait le programme. Un commentaire
commence par les caractères /* et se termine par les caractères */. Une quantité de texte
quelconque, y compris sur des lignes multiples, peut apparaître entre ces caractères. Java
prend également en charge un autre type de commentaire que vous découvrez sur les
lignes 4 à 21. Si les caractères // apparaissent dans un programme Java, Java les ignore,
ainsi que tout autre texte qui apparaît entre ces caractères et la fin de la ligne.
javaNut.book Page 13 Dimanche, 29. janvier 2006 10:04 22
Un exemple de programme
13
La ligne 4 représente le début du programme. Elle indique que nous définissons une
classe appelée Factorial. Cela explique pourquoi le programme doit être enregistré dans un
fichier nommé Factorial.java. Ce nom de fichier indique que le fichier contient le code
source Java d’une classe nommée Factorial. Le mot public est un modificateur ; il indique
que la classe est publiquement disponible et que n’importe qui peut l’utiliser. L’accolade
ouvrante ({) marque le début du corps de la classe, qui s’étend jusqu’à la ligne 21 sur
laquelle nous trouvons l’accolade fermante (}) correspondante. Le programme contient
un certain nombre de paires d’accolades ; les lignes sont indentées pour faire ressortir
l’emboîtement au sein de ces accolades.
Une classe représente l’unité fondamentale de la structure d’un programme Java, aussi
n’est-il pas surprenant que la première ligne de notre programme déclare une classe. Tous
les programmes Java sont des classes, bien que certains programmes utilisent de
nombreuses classes plutôt qu’une seule. Java est un langage de programmation orienté
objet et les classes représentent un élément fondamendal du paradigme orienté objet.
Chaque classe définit un type d’objet unique. Cependant, l’exemple 1-1 ne représente pas
vraiment un programme orienté objet, raison pour laquelle je n’entrerai pas maintenant
dans les détails des classes et des objets. Il s’agit du thème du chapitre 3, La programmation
orientée objet en Java. Pour l’heure, tout ce que vous devez comprendre est qu’une classe
définit un jeu de membres qui interagissent. Ces membres peuvent être des champs, des
méthodes ou d’autres classes. La classe Factorial contient deux membres qui sont tous deux
des méthodes. Ils sont décrits dans les sections qui suivent.
Définition d’une méthode
La ligne 5 commence par la définition d’une méthode de notre classe Factorial. Une
méthode correspond à une partie nommée de code Java. Un programme Java peut
appeler, ou invoquer, une méthode afin d’exécuter le code qu’elle contient. Si vous avez
programmé avec d’autres langages, vous avez probablement rencontré des méthodes
auparavant, mais on les appelait peut-être fonctions, procédures ou sous-routines.
L’intérêt des méthodes est qu’elles possèdent des paramètres et des valeurs de retour.
Lorsque vous appelez une méthode, vous lui passez des données sur lesquelles vous
souhaitez qu’elle agisse puis elle vous retourne un résultat. Une méthode ressemble à une
fonction algébrique :
y = f(x)
Dans ce cas, la fonction mathématique f exécute un calcul sur la valeur représentée par x
et renvoie une valeur que nous représentons par y.
Les mots clés public et static de la ligne 5 sont des modificateurs. public signifie que la
méthode est accessible publiquement ; chacun peut l’utiliser. La signification du modificateur static n’est pas importante ici ; elle sera expliquée au chapitre 3. Le mot clé void (en
français, vide) spécifie la valeur de retour de la méthode. Dans ce cas, elle spécifie que
cette méthode ne possède pas de valeur de retour.
Introduction
Définition d’une classe
javaNut.book Page 14 Dimanche, 29. janvier 2006 10:04 22
14
Chapitre 1 : Introduction
Le mot main (qui signifie principal en français) est le nom de la méthode7. main correspond à un nom particulier. Lorsque vous exécutez l’interpréteur Java, ce dernier lit et
place en mémoire la classe que vous spécifiez puis cherche une méthode appelée main()8.
Lorsque l’interpréteur trouve cette méthode, il s’en sert pour débuter l’exécution du
programme. Lorsque la méthode main() s’achève, le programme est terminé et l’interpréteur Java stoppe son exécution. En d’autres termes, la méthode main() représente le point
d’entrée principal dans un programme Java. Cependant, il n’est habituellement pas suffisant pour une méthode d’être nommée main(). La méthode doit être déclarée public static
void
exactement comme indiqué sur la ligne 5. En fait, la seule partie de la ligne 5 que
vous pouvez modifier est le mot args (diminutif d’arguments) que vous pouvez remplacer
par l’identificateur de votre choix. Vous utiliserez cette ligne dans tous vos programmes
Java, aussi apprenez-la par cœur dès maintenant !
À la suite du nom de la méthode main() se trouve une liste de paramètres de méthode,
délimitée par des parenthèses. Notre méthode main() ne possède qu’un seul paramètre.
String[] spécifie le type du paramètre, à savoir un tableau de chaînes de caractères (c’est-àdire une liste numérotée de chaînes de texte). args spécifie le nom du paramètre. Dans
l’équation algébrique f(x), x permet simplement de faire référence à une valeur inconnue.
args poursuit le même but pour la méthode main(). Comme nous le verrons plus tard, le
nom args est utilisé dans le corps de la méthode pour faire référence à la valeur inconnue
transmise à la méthode.
Comme je viens de l’expliquer, la méthode main() est une méthode particulière appelée
par l’interpréteur Java lorsqu’il commence à exécuter une classe (ou un programme) Java.
Lorsque vous invoquez l’interpréteur Java de la manière suivante :
C:\>java Factorial 4
la chaîne de caractères « 4 » est transmise à la méthode main() comme valeur associée au
paramètre nommé args. De façon plus précise, un tableau de chaînes de caractères contenant une seule entrée, « 4 », est transmis à main(). Si nous invoquons le programme de la
manière suivante :
C:\>java Factorial 4 3 2 1
alors un tableau de quatre chaînes de caractères, « 4 », « 3 », « 2 » et « 1 » est passé à la
méthode main() comme valeur associée au paramètre nommé args. Notre programme ne
s’intéresse qu’à la première chaîne de caractères dans le tableau, aussi les autres chaînes
sont-elles ignorées.
7. Tous les programmes Java qui sont exécutés directement par l’interpréteur Java doivent posséder une méthode main().
Les programmes de ce genre sont souvent appelés des applications. Il est possible d’écrire des programmes qui ne sont
pas exécutés directement par l’interpréteur, mais qui sont chargés dynamiquement dans un autre programme Java
déjà en cours d’exécution.
Un exemple concerne les applets, qui sont des programmes exécutés par un navigateur web, ainsi que les servlets, qui
sont des programmes exécutés par un serveur web. Les applets sont traités dans Java Foundation Classes in a Nutshell,
édition française (O’Reilly) et les servlets dans Java Enterprise in a Nutshell (O’Reilly). Au sein du présent ouvrage, nous
ne considérons que les applications.
8. Par convention, lorsque ce livre fait référence à une méthode, il fait suivre le nom de la méthode par une paire de parenthèses. Comme vous le verrez, les parenthèses représentent une partie importante de la syntaxe d’une méthode et
elles sont utilisées ici pour distinguer les noms des méthodes des noms des classes, des champs, des variables, etc.
javaNut.book Page 15 Dimanche, 29. janvier 2006 10:04 22
Un exemple de programme
15
Déclaration d’une variable et analyse des données d’entrée
La première instruction de la méthode main(), à la ligne 6, déclare une variable et lui
assigne une valeur. Dans tout langage de programmation, une variable est simplement un
nom symbolique associé à une valeur. Nous avons déjà vu que, dans ce programme, le
nom args fait référence aux valeurs des paramètres transmis à la méthode main(). Les paramètres d’une méthode représentent un type de variable. Il s’avère également possible
pour les méthodes de déclarer des variables « locales » supplémentaires. Les méthodes
peuvent utiliser les variables locales pour enregister et référencer des valeurs intermédiaires qu’elles utilisent pendant leurs opérations.
Il s’agit exactement de l’approche adoptée sur la ligne 6. Cette ligne commence par les
mots int input qui déclare une variable nommée input et spécifie que la variable est du
type int ; cela signifie qu’il s’agit d’un nombre entier9. Java peut travailler avec plusieurs
types de valeurs différents, y compris les nombres entiers, réels ou à virgule f lottante, les
caractères (par exemple les lettres, les chiffres) et les chaînes de caractères. Java est un
langage fortement typé, ce qui signifie que toutes les variables doivent posséder un type
spécifié et ne peuvent faire référence qu’à des valeurs de ce type. Notre variable input fait
toujours référence à un nombre entier ; elle ne peut pas faire référence à un nombre à
virgule flottante ou à une chaîne de caractères. Les paramètres des méthodes sont également typés. Rappelez-vous que le paramètre args était du type String[].
Si l’on continue avec la ligne 6, on découvre que la déclaration de variable int input est
suivie par le caractère =. Il s’agit de l’opérateur d’affectation en Java ; il définit la valeur
d’une variable. Lorsque vous lisez du code Java, ne lisez pas = comme « égal à » mais lisezle plutôt comme « reçoit la valeur ». Comme nous le verrons au chapitre 2, la syntaxe Java,
il existe un opérateur différent pour exprimer l’égalité.
La valeur affectée à notre variable input est Integer.parseInt(args[0]). Il s’agit d’une
invocation de méthode. Cette première instruction de la méthode main() invoque une
autre méthode dont le nom est Integer.parseInt(). Comme vous pouvez l’imaginer,
cette méthode « analyse » (parse en anglais) un entier ; cela signifie qu’elle convertit une
représentation d’un nombre entier sous forme de chaîne de caractères (string en anglais),
par exemple « 4 », en un véritable nombre entier (integer en anglais). La méthode
9. NdT : int est l’abbréviation de integer, c’est-à-dire entier
Introduction
Enfin, le dernier élément de la ligne 5 est une accolade ouvrante. Elle marque le début
du corps de la méthode main(), lequel s’étend jusqu’à l’accolade fermante correspondante, à la ligne 9. Les méthodes sont composées d’instructions que l’interpréteur Java
exécute en ordre séquentiel. Dans notre cas, les lignes 6, 7 et 8 représentent trois
instructions qui forment le corps de la méthode main(). Chaque instruction se termine
par un point-virgule qui la sépare de la prochaine instruction. Il s’agit d’une partie
importante de la syntaxe de Java ; les programmeurs débutants oublient souvent les
points-virgules.
javaNut.book Page 16 Dimanche, 29. janvier 2006 10:04 22
16
Chapitre 1 : Introduction
Integer.parseInt() ne fait pas partie du langage Java mais représente un élément de base
de l’API ou Application Programming Interface (pour interface de programmation d’applications) Java. Chaque programme Java peut utiliser l’ensemble puissant des classes et des
méthodes définies par ces API essentielles. La deuxième moitié de ce livre prend la forme
d’un guide de référence qui documente ces API essentielles.
Lorsque vous appelez une méthode, vous lui transmettez des valeurs (appelés arguments)
qui sont affectées aux paramètres correspondants définis par la méthode, puis la méthode
retourne elle-même une valeur. L’argument transmis à Integer.parseInt() est args[0].
Rappelez-vous que args est le nom du paramètre de main() ; il spécifie un tableau (ou
liste) de chaînes de caractères. Les éléments d’un tableau sont numérotés séquentiellement et le premier porte toujours le numéro 0. Nous ne nous intéressons qu’à la première
chaîne de caractères du tableau args, aussi utilisons-nous l’expression args[0] pour faire
précisément référence à cette chaîne de caractères. Donc, lorsque nous invoquons le
programme tel que montré précédemment, la ligne 6 prend la première chaîne de caractères spécifiée après le nom de la classe, soit « 4 », et la transmet à la méthode nommée
Integer.parseInt(). Cette méthode convertit la chaîne de caractères en un nombre entier
équivalent et renvoie cet entier comme valeur de retour. Enfin, l’entier retourné est
affecté à la variable nommée input.
Calcul du résultat
L’instruction de la ligne 7 ressemble beaucoup à l’instruction de la ligne 6. Elle déclare
une variable et lui affecte une valeur. La valeur affectée à la variable est calculée par
l’invocation d’une méthode. La variable s’appelle result et est du type double. double
correspond à un nombre à virgule flottante en double précision. La variable reçoit une
valeur calculée par la méthode factorial(). La méthode factorial(), cependant, ne fait
pas partie de l’API Java standard. Elle est définie comme partie intégrante de notre
programme aux lignes 11 à 19. L’argument transmis à factorial() n’est autre que la
valeur à laquelle fait référence la variable input qui a été calculée à la ligne 6. Nous considérerons le corps de la méthode factorial() brièvement, mais vous pouvez deviner
d’après son nom que cette méthode prend une valeur d’entrée, calcule la factorielle de
cette valeur puis retourne le résultat.
Affichage du résultat
La ligne 8 appelle simplement une méthode nommée System.out.println(). Cette
méthode couramment utilisée fait partie de l’API essentielle de Java ; elle indique à l’interpréteur Java qu’il y a lieu d’afficher une valeur. Dans ce cas, la valeur qu’elle affiche est la
valeur référencée par la variable nommée result. Il s’agit du résultat de notre calcul factoriel. Si la variable input contient la valeur 4, la variable result contient la valeur 24 et la
ligne 8 provoque l’affichage de cette valeur.
La méthode System.out.println() n’a pas de valeur de retour, aussi n’y a-t-il pas de déclaration de variable ou d’opérateur d’affectation dans cette instruction, étant donné qu’il n’y
a aucune valeur à assigner à quoi que ce soit. En d’autres termes, tout comme la méthode
main() de la ligne 5, System.out.println() est déclarée void.
javaNut.book Page 17 Dimanche, 29. janvier 2006 10:04 22
Un exemple de programme
17
La ligne 9 ne contient qu’un seul caractère, }. Ce dernier marque la fin de la méthode.
Lorsque l’interpréteur Java arrive à cet endroit, il a terminé l’exécution de la méthode
main() et stoppe donc son exécution. La fin de la méthode main() représente également la
frontière de la portée des variables input et result déclarées au sein de main(), ainsi que
du paramètre args de main(). Ces noms de variables et de paramètres n’ont un sens qu’au
sein de la méthode main() et ne peuvent pas être utilisés ailleurs dans le programme, à
moins que d’autres parties du programme ne déclarent des variables ou des paramètres
différents qui possèdent par hasard le même nom.
Lignes vides
La ligne 10 est un ligne vide. Vous pouvez insérer des lignes vides, des espaces et des tabulateurs n’importe où dans un programme et vous devez même généreusement les utiliser
pour améliorer la lisibilité du code. Une ligne vide à cet endroit sépare la méthode main()
de la méthode factorial() qui débute à la ligne 11. Vous remarquerez que le programme
utilise également des espaces et des tabulateurs afin d’indenter les diverses lignes de code.
Ce type d’indentation est facultatif ; il accentue la structure du programme et améliore
nettement la lisibilité du code.
Une autre méthode
La ligne 11 marque le début de la définition de la méthode factorial() utilisée par la
méthode main(). Comparez cette ligne à la ligne 5 et notez les points communs ainsi que
les différences. La méthode factorial() possède les mêmes modificateurs public et static
que la méthode main(). Elle prend un seul paramètre de type entier que nous appelons x.
À la différence de la méthode main() qui ne possède pas de valeur de retour (void), factorial() retourne une valeur de type double. L’accolade ouvrante marque le début du corps
de la méthode qui englobe les accolades emboîtées des lignes 15 et 18 et se poursuit
jusqu’à la ligne 20 sur laquelle se trouve l’accolade fermante correspondante. Le corps de
la méthode factorial(), tout comme le corps de la méthode main(), est formé d’instructions que l’on trouve aux lignes 12 à 19.
Contrôle de validité des données d’entrée
Dans la méthode main(), nous avons vu des déclarations de variables, des affectations ainsi
que des invocations de méthodes. L’instruction de la ligne 12 est différente. Il s’agit d’une
instruction if (en français, if signifie si) dont le rôle est d’exécuter une autre instruction
de manière conditionnelle. Nous avons vu plus tôt que l’interpréteur Java exécute les
trois instructions de la méthode main() les unes après les autres. Il les exécute toujours de
cette manière, exactement dans cet ordre. Une instruction if est une instruction de
contrôle de flux ; elle peut inf luencer la manière dont l’interpréteur exécute un
programme.
Le mot clé if est suivi d’une expression entre parenthèses et d’une instruction. L’interpréteur Java commence par évaluer l’expression. Si celle-ci est vérifiée (valeur booléenne
true), l’interpréteur exécute l’instruction. Cependant, si l’expression est fausse (false),
l’interpréteur passe l’instruction et passe à la suivante. La condition de l’instruction if de
Introduction
Fin d’une méthode
javaNut.book Page 18 Dimanche, 29. janvier 2006 10:04 22
18
Chapitre 1 : Introduction
la ligne 12 s’exprime par x < 0. Elle contrôle que la valeur transmise à la méthode
factorial() est inférieure à zéro. Si tel est le cas, l’expression est considérée comme vraie
(true) et l’instruction de la ligne 13 est exécutée. La ligne 12 ne se termine pas par un
point-virgule car l’instruction de la ligne 13 fait partie de l’instruction if. Les pointsvirgules ne sont nécessaires qu’à la fin d’une instruction.
La ligne 13 représente une instruction return. Elle indique que la valeur de retour de la
méthode factorial() est 0.0. return est également une instruction de contrôle de f lux.
Lorsque l’interpréteur Java rencontre un return, il stoppe l’exécution de la méthode
courante et retourne immédiatement la valeur spécifiée. Une instruction return peut être
autonome mais dans le cas présent, l’instruction return fait partie de l’instruction if de la
ligne 12. L’indentation de la ligne 13 aide à accentuer ce fait. (Java ignore l’indentation
mais elle s’avère très utile pour les humains qui lisent du code Java !) La ligne 13 n’est
exécutée que si l’expression de la ligne 12 est vraie (true).
Avant de continuer, nous devrions prendre un peu de recul et discuter en premier lieu de
la nécessité des lignes 12 et 13. Il est erroné d’essayer de calculer la factorielle d’un nombre
négatif, aussi ces lignes contrôlent-elles que la valeur d’entrée x est valable. Si ce n’est pas le
cas, ces lignes forcent factorial() à retourner un résultat invalide mais cohérent, 0.0.
Une variable importante
La ligne 14 représente une autre déclaration de variable ; elle déclare une variable
nommée fact, de type double, et lui affecte la valeur initiale 1.0. Cette variable contient la
valeur de la factorielle que nous calculons lors des instructions qui suivent. Dans Java, les
variables peuvent être déclarées n’importe où ; leur déclaration n’est pas limitée au début
d’une méthode ou d’un bloc de code.
Boucle et calcul factoriel
La ligne 15 présente un nouveau type d’instruction : la boucle while (en français, while
signifie tant que). À la manière d’une instruction if, une instruction while est formée
d’une expression entre parenthèses et d’une instruction. Lorsque l’interpréteur Java
rencontre une instruction while, il évalue l’expression associée. Si l’évaluation de cette
expression retourne la valeur vraie (true), l’interpréteur exécute l’instruction. L’interpréteur répète ce processus, évaluant l’expression et exécutant l’instruction si l’expression est
vraie jusqu’à ce que l’expression soit évaluée comme étant fausse (false). L’expression de la
ligne 15 s’exprime par x > 1, aussi l’instruction while se met-elle en boucle tant que le
paramètre x contient une valeur plus grande que 1. En d’autres termes, la boucle se répète
jusqu’à ce que x contienne une valeur inférieure ou égale à 1. Nous pouvons présupposer
de cette expression que si l’on veut que la boucle s’achève un jour, la valeur de x doit être
modifiée d’une manière ou d’une autre par l’instruction que la boucle exécute.
La différence principale entre l’instruction if des lignes 12-13 et la boucle while des lignes
15-18 vient du fait que l’instruction associée à la boucle while est une instruction
composée. Une instruction composée est formée de zéro, une ou plusieurs instructions
groupées entre accolades. Le mot clé while de la ligne 15 est suivi d’une expression entre
parenthèses puis par une accolade ouvrante. Cela signifie que le corps de la boucle est
javaNut.book Page 19 Dimanche, 29. janvier 2006 10:04 22
Un exemple de programme
19
Le corps de la boucle while est formé par les instructions des lignes 16 et 17. La ligne 16
multiplie la valeur de fact par la valeur de x et enregistre le résultat dans fact. La ligne 17
est du même genre. Elle soustrait 1 de la valeur de x et enregistre le résultat dans x. Le
caractère * sur la ligne 16 est important : il représente l’opérateur de multiplication. Et,
comme vous le devinerez probablement, le - sur la ligne 17 représente l’opérateur de
soustraction. Un opérateur est un élément clé de la syntaxe de Java : il exécute un calcul
sur un ou deux opérandes afin de produire une nouvelle valeur. Les opérandes et les
opérateurs se combinent pour former des expressions telles que fact * x ou x - 1. Nous
avons vu d’autres opérateurs au sein du programme. La ligne 15, par exemple, utilise
l’opérateur « plus grand que » (>) dans l’expression x > 1 qui compare la valeur de la
variable x à 1. La valeur de cette expression est une valeur de vérité booléenne - soit true
(vrai) ou false (faux) en fonction du résultat de la comparaison.
Afin de comprendre cette boucle while, il est utile de penser de la même façon que l’interpréteur Java. Supposons que nous essayions de calculer la factorielle de 4. Avant le début
de la boucle, fact possède la valeur 1.0 et x la valeur 4. Après que le corps de la boucle a
été exécuté une fois – après la première itération – fact possède la valeur 4.0 et x la valeur
3. Après la seconde itération, fact possède la valeur 12.0 et x la valeur 2. Après la troisième
itération, fact possède la valeur 24.0 et x la valeur 1. Lorsque l’interpréteur teste la condition de boucle après la troisième itération, il constate que l’expression x > 1 n’est plus
vérifiée, aussi stoppe-t-il l’exécution de la boucle et le programme reprend à la ligne 19.
Retourner le résultat
La ligne 19 représente une autre instruction return, comparable à celle que nous avons
rencontrée à la ligne 13. Celle-ci ne retourne pas une valeur constante telle que 0.0 mais
retourne plutôt la valeur de la variable fact. Si la valeur de x transmise dans la fonction
factorial() est 4, alors, comme nous l’avons vu précédemment, la valeur de fact est
égale à 24.0, aussi s’agit-il de la valeur retournée. Rappelez-vous que la méthode factorial() a été invoquée à la ligne 7 du programme. Lorsque cette instruction return est
exécutée, le contrôle retourne à la ligne 7, où la valeur de retour est affectée à la variable
nommée result.
Exceptions
Si vous avez effectué cette analyse de l’exemple 1-1 ligne par ligne jusqu’à son terme, vous êtes
sur le bon chemin pour comprendre les fondements du langage Java10. Il s’agit d’un
programme simple, bien que non trivial, qui illustre de nombreuses caractéristiques de Java.
Il existe une caractéristique supplémentaire importante de la programmation Java que je
souhaite présenter mais qui n’apparaît pas dans l’énoncé du programme lui-même.
Rappelez-vous que le programme calcule la factorielle du nombre que vous spécifiez sur la
Introduction
formé de toutes les instructions entre cette accolade ouvrante et l’accolade fermante
correspondante de la ligne 18. Plus tôt dans ce chapitre, j’ai indiqué que toutes les instructions Java se terminent par des points-virgules. Cependant, cette règle ne s’applique pas
aux instructions composées comme vous pouvez le constater par l’absence de pointvirgule à la fin de la ligne 18. Les instructions au sein d’un instruction composée (lignes 16
et 17) s’achèvent par des points-virgules, bien évidemment.
javaNut.book Page 20 Dimanche, 29. janvier 2006 10:04 22
20
Chapitre 1 : Introduction
ligne de commande. Que se passe-t-il si vous exécutez le programme sans spécifier de
nombre ?
C:\> java Factorial
java.lang.ArrayIndexOutOfBoundsException: 0
at Factorial.main(Factorial.java:6)
C:\>
Et que se passe-t-il si vous spécifiez une valeur qui n’est pas un nombre ?
C:\>java Factorial dix
java.lang.NumberFormatException: dix
at java.lang.Integer.parseInt(Integer.java)
at java.lang.Integer.parseInt(Integer.java)
at Factorial.main(Factorial.java:6)
Dans les deux cas, une erreur se produit ou, dans la terminologie de Java, une exception
est levée. Lorsqu’une exception est levée, l’interpréteur Java affiche un message qui
explique de quel type d’exception il s’agit et à quel moment elle s’est produite (les deux
exceptions ci-dessus se sont produites à la ligne 6). Dans le premier cas, l’exception est
levée parce qu’il n’y a pas de chaîne de caractères dans la liste d’arguments args, signifiant par là que nous essayons d’accéder avec args[0] à une chaîne de caractères
inexistante. Dans le deuxième cas, l’exception est levée parce que Integer.parseInt() est
incapable de convertir la chaîne de caractères « dix » en un nombre. Nous en apprendrons davantage au sujet des exceptions dans le chapitre 2 et nous verrons comment les
traiter élégamment lorsqu’elles se produisent.
10. Si vous n’avez pas saisi tous les détails de ce programme de calcul factoriel, ne vous inquiétez pas. Nous traiterons les
détails du langage Java de manière plus minutieuse dans les chapitres 2 et 3. Cependant, si vous avez l’impression de
ne rien comprendre à cette analyse ligne par ligne, vous pourriez également avoir le sentiment que les prochains chapitres vous dépassent complètement. Dans ce cas, vous devez probablement étudier ailleurs les fondements du langage
Java puis revenir à ce livre pour renforcer vos connaissances et, bien sûr, pour l’utiliser comme guide de référence. Une
ressource qui pourrait vous sembler intéressante pour l’apprentissage du langage est le tutoriel Java en ligne de Sun,
disponible à l’adresse http://java.sun.com/docs/books/tutorial/.