Polycope java enseignant
Upcoming SlideShare
Loading in...5
×
 

Polycope java enseignant

on

  • 2,686 views

Cours POO très interessant niveau débutant

Cours POO très interessant niveau débutant

Statistics

Views

Total Views
2,686
Views on SlideShare
2,686
Embed Views
0

Actions

Likes
0
Downloads
106
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Polycope java enseignant Polycope java enseignant Document Transcript

    • Version enseignant Module IP1 Programmation Orient´e Objets e Le Langage JAVA Amaury Habrard Universit´ de Provence Aix-Marseille I e amaury.habrard@lif.univ-mrs.fr
    • 2
    • Table des mati`res e1 Avant propos 72 Introduction : le langage JAVA 9 2.1 Pr´sentation . . . . . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 9 2.2 Historique du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.2.1 Quelques mots cl´s . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 10 2.3 Java et la programmation orient´e objet . . . . . . . . . . e . . . . . . . . . . . . . . 10 2.3.1 Le concept d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.3.2 Ind´pendance vis ` vis de la plateforme . . . . . . e a . . . . . . . . . . . . . . 11 2.4 Structure d’un programme JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.4.1 Que contient un fichier source ? . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.4.2 Execution d’un programme Java . . . . . . . . . . . . . . . . . . . . . . . . 12 2.4.3 La machine virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.4.4 La m´thode main . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 12 2.4.5 Utilisation d’arguments dans la fonction main . . . . . . . . . . . . . . . . . 13 2.5 Installation et utilisation de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.6 Types, expressions et structures de contrˆle fondamentales o . . . . . . . . . . . . . . 15 2.6.1 les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 La notion de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 le type entier (int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Les flottants/r´els (float ou double) . . . . . . . . e . . . . . . . . . . . . . . 16 Le type caract`re (char) . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 16 Le type bool´en (boolean) . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 16 Initialisations et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.6.2 Op´rateurs et expressions . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 17 Op´rateurs arithm´tiques . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 17 Op´rateurs de comparaison . . . . . . . . . . . . . e . . . . . . . . . . . . . . 17 Op´rateurs logiques . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 18 Op´rateurs d’affectation . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 18 Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Op´rateur conditionnel . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 19 Priorit´ des op´rateurs . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 19 2.6.3 Les structures de contrˆle . . . . . . . . . . . . . . o . . . . . . . . . . . . . . 20 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Les instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . 24 2.6.4 Les ´l´ments sp´cifiques au langage JAVA . . . . . ee e . . . . . . . . . . . . . . 25 2.7 Une premi`re introduction au type String . . . . . . . . . e . . . . . . . . . . . . . . 25 2.8 R`gles d’´criture d’un programme JAVA . . . . . . . . . e e . . . . . . . . . . . . . . 26 3
    • 4 ` TABLE DES MATIERES 2.8.1 Les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.8.2 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 2.8.3 Mots cl´s r´serv´s . . . . . . . . . . . . . . . . . e e e . . . . . . . . . . . . . . . 27 2.8.4 Remarques globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 2.8.5 Commentaires sur le rendu d’un programme Java . . . . . . . . . . . . . . . 27 2.8.6 Liens sur la programmation JAVA . . . . . . . . . . . . . . . . . . . . . . . 28 2.8.7 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.9 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.9.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.9.2 Mots crois´s . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . 313 La notion d’objets : d´finition et utilisation e 33 3.1 Introduction au d´veloppement objets . . . . . . . . . . . e . . . . . . . . . . . . . . 33 3.2 La notion de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.2.1 Exemple de classe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.2.2 Cr´ation d’un objet ` l’aide d’une classe . . . . . . e a . . . . . . . . . . . . . . 36 3.2.3 Exemple d’utilisation dans un programme complet . . . . . . . . . . . . . . 37 3.3 La notion de constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 3.4 Affectation et comparaison d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 3.4.1 La r´f´rence null . . . . . . . . . . . . . . . . . . . ee . . . . . . . . . . . . . . 40 3.5 Le ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 3.6 L’encapsulation de donn´es . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 41 3.7 Champs et m´thodes statiques . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 43 3.7.1 Variables statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.7.2 Les m´thodes statiques . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 45 3.8 Surd´finition/surcharge de m´thodes . . . . . . . . . . . . e e . . . . . . . . . . . . . . 46 3.8.1 Surd´finition de constructeurs . . . . . . . . . . . . e . . . . . . . . . . . . . . 47 3.9 La copie d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 3.10 Autor´f´rencement : le mot cl´ this . . . . . . . . . . . . ee e . . . . . . . . . . . . . . 49 3.11 Remarques sur la d´finition de m´thodes . . . . . . . . . . e e . . . . . . . . . . . . . . 51 3.11.1 M´thodes de type proc´dures et fonctions . . . . . e e . . . . . . . . . . . . . . 51 3.11.2 Les arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 3.11.3 Les variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 3.11.4 La r´cursivit´ . . . . . . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 53 3.12 Les paquetages (packages) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 3.12.1 Attribution d’une classe ` un paquetage . . . . . . a . . . . . . . . . . . . . . 53 3.12.2 Utilisation d’une classe situ´e dans une paquetage e . . . . . . . . . . . . . . 54 3.12.3 Droits d’acc`s . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 55 3.13 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 3.13.1 D´claration et cr´ation . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 55 3.13.2 Tableau en argument ou en retour . . . . . . . . . . . . . . . . . . . . . . . 58 3.13.3 Les tableaux ` plusieurs indices . . . . . . . . . . . a . . . . . . . . . . . . . . 59 3.14 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 3.14.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 3.14.2 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 3.14.3 Compilateur 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 3.14.4 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 3.14.5 Compilateur 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 3.14.6 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 68 3.14.7 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 69
    • `TABLE DES MATIERES 54 Les concepts d’H´ritage et de Polymorphisme e 71 4.1 Pr´sentation et d´finition . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . 71 4.2 Construction et initialisation des objets d´riv´s e e . . . . . . . . . . . . . . . . . . . . 74 4.3 Red´finition, surd´finition et h´ritage . . . . . . e e e . . . . . . . . . . . . . . . . . . . . 76 4.3.1 Red´finition . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . 76 4.3.2 La surchage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 4.3.3 En r´sum´ . . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . 77 4.4 Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 4.4.1 Tableaux h´t´rog`nes d’objets . . . . . . ee e . . . . . . . . . . . . . . . . . . . . 79 4.4.2 R`gles du polymorphisme en Java . . . e . . . . . . . . . . . . . . . . . . . . 80 4.5 La super-classe Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 4.6 Acc`s par membres prot´g´s : protected . . . e e e . . . . . . . . . . . . . . . . . . . . 82 4.7 M´thodes et classes finales . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . 82 4.8 Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 4.9 Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 4.9.1 D´finition et mise en œuvre . . . . . . . e . . . . . . . . . . . . . . . . . . . . 84 4.9.2 Int´rˆt des interfaces . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . 85 4.10 Connaˆ la classe et les types d’un objet . . . ıtre . . . . . . . . . . . . . . . . . . . . 85 4.10.1 L’op´rateur instanceof . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . 85 4.10.2 La class Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 4.11 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 4.11.1 Classes abstraites - classes concr`tes . . e . . . . . . . . . . . . . . . . . . . . 87 4.11.2 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 4.11.3 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 4.11.4 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905 La gestion d’exceptions 91 5.1 Pr´sentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . 91 5.2 Gestion de plusieurs exceptions et transmission d’informations . . . . . . . . . . . 92 5.3 D´rivation et red´clenchement d’exceptions . . . . . . . . . . . e e . . . . . . . . . . . 95 5.4 Le bloc finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 5.5 Les exceptions standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 5.6 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.6.1 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.6.2 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . 1016 Les chaˆınes de caract`res en Java e 103 6.1 Le type String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.1.1 Les chaˆ ınes de caract`res sont des objets . . . . . e . . . . . . . . . . . . . . . 103 6.1.2 Affichage d’une chaˆ . . . . . . . . . . . . . . . ıne . . . . . . . . . . . . . . . 103 6.1.3 Longueur d’une chaˆ . . . . . . . . . . . . . . . ıne . . . . . . . . . . . . . . . 103 6.1.4 acc`s aux caract`res . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . . 103 6.1.5 Concat´nation : l’op´rateur + . . . . . . . . . . . e e . . . . . . . . . . . . . . . 104 6.1.6 Recherche dans une chaˆ : la m´thode indexOf ıne e . . . . . . . . . . . . . . . 104 6.1.7 La comparaison de chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Tester l’´galit´ de deux chaˆ e e ınes . . . . . . . . . . . . . . . . . . . . . . . . . 104 Comparer deux chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.1.8 Modification d’un caract`re . . . . . . . . . . . . e . . . . . . . . . . . . . . . 105 6.1.9 Extraction de sous-chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.1.10 Passage en majuscules/minuscules . . . . . . . . . . . . . . . . . . . . . . . 105 6.1.11 Conversion d’une chaˆ vers un type primitif . . ıne . . . . . . . . . . . . . . . 105 6.1.12 Conversion d’un type primitif vers une chaˆ . . ıne . . . . . . . . . . . . . . . 105 6.1.13 Chaˆınes et tableaux de caract`res . . . . . . . . . e . . . . . . . . . . . . . . . 106 6.1.14 Tableau de chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
    • 6 ` TABLE DES MATIERES 6.2 La classe StringBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.3 La classe StringTokenizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067 Les entr´es/sorties e 109 7.1 Les fichiers, la classe File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.1.1 Les champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.1.2 Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.1.3 Les m´thodes . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.2 Les flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 7.3 Lecture/´criture . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1118 Quelques ´l´ments de l’API ee 113 8.1 La classe Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 8.2 Les classes enveloppes pour les valeurs primitives . . . . . . . . . . . . . . . . . . . 113 8.3 Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 8.3.1 D´finition . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . 114 8.3.2 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 L’ancienne classe Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 8.3.3 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 8.3.4 Les algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 Recherche de maximum ou minimum . . . . . . . . . . . . . . . . . . . . . . 118 Algorithme de tris et m´langes . . . . . . e . . . . . . . . . . . . . . . . . . . 119 8.3.5 Les tables associatives (HashMap) . . . . . . . . . . . . . . . . . . . . . . . . 120 8.4 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 8.4.1 El´ments disponibles a partir de Java 1.5 e ` . . . . . . . . . . . . . . . . . . . 123 Boucle for am´lior´e . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . 123 8.4.2 G´n´ricit´ . . . . . . . . . . . . . . . . . . e e e . . . . . . . . . . . . . . . . . . . 123 8.4.3 R´flection et Manipulation des types . . . e . . . . . . . . . . . . . . . . . . . 123 8.5 Les autres ´l´ments de l’API . . . . . . . . . . . ee . . . . . . . . . . . . . . . . . . . 125
    • Chapitre 1Avant propos Ce polycopi´ de cours a pour objectif d’introduire les concepts fondamentaux de la program- emation objet ` l’aide du langage java. Il est compos´ de 4 chapitres de cours et de 3 chapitre a epr´sentant des ´l´ments de la biblioth`que du langage. A l’issue de chaque chapitre de cours, un e ee eensemble d’exercices originaux sont propos´s. Ces exercices sont compl´mentaires au exercices de e etravaux dirig´s et au travaux pratiques. Ils ont pour objectif de faire travailler les notions vues en ecours sous une forme diff´rente et d’insister sur le vocabulaire sp´cifique ` java ou ` la program- e e a amation objets, il est donc fortement conseill´ de chercher s´rieusement ces exercices. Voici un bref e edescriptif des diff´rents chapitres : e – Chapitre 2 : chapitre d’introduction pr´sentant le langage dans sa globalit´, son historique e e et les principes de bases pour ´crire un premier programme. On y d´taille tous les types e e primitifs, les structures de contrˆles et quelques structures fondamentales du langage. On o pr´sente ´galement les conventions ` suivre lorsque l’on programme en Java. e e a – Chapitre 3 : ce chapitre pr´sente la philosophie du langage : l’objet. On d´taille les diff´rentes e e e structures permettant de d´clarer et de cr´er les objets ainsi que les implications de chacune e e d’elles. – Chapitre 4 : on y introduit des concepts fondamentaux de la programmation objet l’h´ritagee et le polymorphisme. Ils font la force de ce type de programmation en permettant notam- ment une meilleure lisibilit´ des programmes et une plus grande facilit´ de r´utilisation de e e e l’existant. – Chapitre 5 : dans ce chapitre la gestion d’erreurs via la notion d’exception est pr´sent´e. Ce e e type de gestion est propre au langage java. – Chapitre 6 : premier chapitre pr´sentant une partie de la biblioth`que. On parle de l’acc`s ` e e e a des fonctions math´matiques, de l’utilisation de listes ou de tables associatives et quelques e algorithmes utilisables. – Chapitre 7 : pr´sentation des ´l´ments permettant de lire des flux et notamment de lire et e ee d’´crire dans des fichiers. e – Chapitre 8 : d´tail de toutes les classes de la biblioth`que permettant de g´rer des chaˆ e e e ınes de caract`res, type fondamental et traiter de mani`re sp´cifique en Java. e e e Ce document en est ` sa deuxi`me version, il existe de mani`re certaine des coquilles, des a e efautes de frappes, des oublis de mot, des erreurs de code involontaire, des copier/coller non perti-nents, . . . Dans le but d’am´liorer ce document, merci de signaler toutes ces erreurs. Si vous avez equelques suggestions pour am´liorer certaines parties, corriger certaines affirmations, elles sont les ebienvenues. Bonne lecture et bon travail ! 7
    • 8 CHAPITRE 1. AVANT PROPOS
    • Chapitre 2Introduction : le langage JAVA2.1 Pr´sentation e Java est une technologie compos´e d’un langage de programmation orient´ objet et d’un en- e evironnement d’ex´cution. Pr´alablement nomm´ Oak, il a ´t´ cr´´ par James Gosling et Patrick e e e e e eeNaughton chez Sun Microsystems avec le soutien de Bill Joy. Le langage Java fut officiellement pr´sent´ le 23 mai 1995 au SunWorld. e e Java est ` la fois un langage de programmation et une plateforme d’ex´cution. Le langage Java a ea la particularit´ principale d’ˆtre portable sur plusieurs syst`mes d’exploitation tels que Windows, e e eMacOS ou Linux. C’est la plateforme qui garantit la portabilit´ des applications d´velopp´es en e e eJava. Le langage reprend en grande partie la syntaxe du langage C++, tr`s utilis´ par les infor- e ematiciens. N´anmoins, Java a ´t´ ´pur´ des concepts les plus subtils du C++ et ` la fois les e ee e e aplus d´routants, tels que les pointeurs. Les concepteurs ont privil´gi´ l’approche orient´e objet de e e e esorte qu’en Java, tout est objet ` l’exception des primitives (nombres entiers, nombres ` virgule a aflottante, etc.). Java permet de d´velopper des applications autonomes mais aussi, et surtout, des applications eclient-serveur. Cˆt´ client, les applets sont ` l’origine de la notori´t´ du langage. C’est surtout cˆt´ o e a ee o eserveur que Java s’est impos´ dans le milieu de l’entreprise grˆce aux servlets, le pendant serveur e ades applets, et plus r´cemment les JSP (Java Server Pages) qui peuvent se substituer ` PHP et e aASP. Les applications Java peuvent ˆtre ex´cut´es sur tous les syst`mes d’exploitation pour lesquels a e e e e´t´ d´velopp´e une plateforme Java, dont le nom technique est JRE (Java Runtime Environment -ee e eEnvironnement d’ex´cution Java). Cette derni`re est constitu´e d’une JVM (Java Virtual Machine e e e- Machine Virtuelle Java), le programme qui interpr`te le code Java et le convertit en code natif. eMais le JRE est surtout constitu´ d’une biblioth`que standard ` partir de laquelle doivent ˆtre e e a ed´velopp´s tous les programmes en Java. C’est la garantie de portabilit´ qui a fait la r´ussite de e e e eJava dans les architectures client-serveur en facilitant la migration entre serveurs, tr`s difficile epour les gros syst`mes. e Dans le cadre de ce cours notre objectif sera d’´tudier les concepts fondamentaux de la pro- egrammation objet ` l’aide du langage java. Le but est d’acqu´rir les bases permettant ensuite de a ed´velopper des applications plus consistantes. e2.2 Historique du langage – Naissance ≡ 1991 : conception d’un langage applicable ` de petits appareils ´lectriques (on a e parle de code embarqu´) par la soci´t´ Sun Microsystem. La syntaxe est proche du C++, e ee utilisant le concept de machine virtuelle. Le code source est traduit dans un langage universel disposant de fonctionnalit´s communes ` toutes les machines. Ce code interm´diaire est dit e a e 9
    • 10 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA form´ de byte code et est compact et portable sur n’importe quelle machine : il suffit qu’elle e dispose d’un programme permettant d’interpr´ter le langage, on parle de machine virtuelle. e Ce projet s’appelait Oak. – Et´ 1992 : premi`re pr´sentation interne des possibilit´s de Oak. Un appareil appel´ ”Star e e e e e Seven” permet de visualiser une animation montrant Duke, l’actuelle mascotte de Java. – 1994 : d´veloppement de HotJava, un navigateur internet enti`rement ´crit en Java capable e e e d’ex´cuter des applets ´crites en byte code. e e – 1995 : lancement officiel de Java 1.0 – 1996 : lancement du JDK 1.0 et des versions 1.01 et 1.02 du langage JAVA (250 classes dans la biblioth`que). e – 1998 : version 1.1 du JDK (500 classes). – 1999 : version 1.2 JDK que l’on appelle Java2 (1500 classes) – 2000 : version de J2SE (Java 2 Standard Edition) 1.3 (1800 classes) – 2002 : version de J2SE (Java 2 Standard Edition) 1.4 (2700 classes), applications web et entreprises. – 2003 : version de J2EE (Java 2 Entreprise Edition) 1.4. – 2004 : version du J2SE 1.5 ´galement appel´ J2SE 5.0 ou Java 5 (3500) classes e e – 2006 : version du J2SE 1.6 ´galement appel´ J2SE 6.0 ou Java 6 (3500) classes e e2.2.1 Quelques mots cl´s e – JRE : Java Runtime Environnement logiciel permettant d’ex´cuter des applications java. e – JDK : Java Development Kit logiciel permettant de concevoir et d’ex´cuter des applications e java. – J2SDK : Java 2 Software Development Kit mˆme chose que pr´c´demment. e e e – API : Application Programming Interface (interface de programmation) qui d´finit la mani`re e e dont un composant informatique peut communiquer avec un autre. Dans le cas de Java, ce terme d´signe une biblioth`que de classes et de fonctionnalit´s mises ` disposition du e e e a programmeur. – J2EE : Java 2 Platform, Enterprise Edition Java 2 Platform, Enterprise Edition est une sp´cification pour le langage de programmation Java de Sun plus particuli`rement des- e e tin´e aux applications d’entreprise. Dans ce but, toute impl´mentation de cette sp´cification e e e contient un ensemble d’extension au cadre d’applications Java standard (J2SE, Java 2 standard edition) afin de faciliter la cr´ation d’applications r´parties. Voici quelques API e e pr´sentes dans cette extension : Servlets, JSP, JDBC, JAXB, RMI, . . . e – javac programme contenu dans le JDK pour compiler des programmes java. – java nom du langage programme contenu dans le JDK ou JRE pour lancer des programmes java. – javadoc programme contenu dans le JDK pour cr´er automatiquement une documentation e HTML ` partir de sources java. a – jar programme contenu dans le JDK pour compresser un (ou des programmes java) dans un seul fichier.2.3 Java et la programmation orient´e objet e La programmation orient´e objets se caract´rise par 3 points importants : e e – une programmation structur´e, e – fiabilit´ des logiciels accrue, e – facilite la r´utilisation du code existant. e
    • 2.4. STRUCTURE D’UN PROGRAMME JAVA 112.3.1 Le concept d’objets En programmation imp´rative (par exemple le langage C), un programme est form´ de diff´rentes e e eproc´dures et structures de donn´es g´n´ralement ind´pendantes des proc´dures. e e e e e e En programmation orient´e objets, on met en œuvre diff´rents objets. Chaque objet associe e edes donn´es et des m´thodes agissant exclusivement sur les donn´es de l’objet. e e e – On parle de m´thodes plutˆt que de proc´dures. e o e – On utilise indiff´remment le mot champ, donn´e ou encore attribut pour les variables as- e e soci´es ` l’objet. e a L’encapsulation de donn´es : il n’est pas possible d’agir directement sur les donn´es d’un objet, e eil est n´cessaire de passer par des m´thodes associ´es ` l’objet. Ces m´thodes jouent le rˆle d’in- e e e a e oterface obligatoire. L’appel d’une m´thode peut ˆtre vu comme l’envoi d’un message ` un objet. e e aVu de l’ext´rieur, un objet se caract´rise uniquement par ses sp´cification (donn´es attributs) et e e e eses m´thodes. e La notion de classe : – elle g´n´ralise la notion de type de donn´e, e e e – elle permet de d´crire un ensemble d’objets ayant une structure de donn´es commune et e e disposant de mˆmes m´thodes. e e – Les objets apparaissent comme des variables d’un type de classe donn´e, on parle d’instances e de classe. La notion d’h´ritage. Elle permet de d´finir une nouvelle classe ` partir d’une autre. On r´utilise e e a ecette derni`re en bloc et on lui ajoute de nouvelles fonctionnalit´s. La conception d’une nouvelle e eclasse, qui h´rite (r´cup`re) toutes les propri´t´s et aptitudes de l’ancienne. Il est ainsi possible e e e eede s’appuyer sur des r´alisations ant´rieures parfaitement au point et les sp´cifier ` volont´. Ceci e e e a efacilite donc la r´utilisation de code ou de logiciel d´j` existant. e ea La programmation objet facilite ´norm´ment la r´alisation d’interfaces graphiques. Chaque e e e´l´ment de l’interface est vu comme un objet, par exemple un objet fenˆtre, plusieurs objets bou-ee etons, un objet ascenseur, etc.2.3.2 Ind´pendance vis ` vis de la plateforme e a La portabilit´ du code. Un programme est portable si un mˆme code source peut ˆtre exploit´ e e e edans des environnements diff´rents moyennant une nouvelle compilation. En Java, il existe la enotion de machine virtuelle java - la JVM (pour Java Virtual Machine) - qui peut ex´cuter le emˆme code sur n’importe quelle plateforme en utilisant un code source sous forme de bytecode : un elangage machine sp´cifique ` la plateforme Java. La cr´ation d’un programme Java s’effectue en e a e2 temps : une phase de compilation qui transforme le code source en bytecode. Le code est ensuiteinterpr´t´ sur une machine virtuelle Java ee2.4 Structure d’un programme JAVA2.4.1 Que contient un fichier source ? Un fichier source porte l’extension .java et contient la d´finition de classe. La d´finition d’une e eclasse est d´finie par 2 accolades. epublic class Chien{//code de la classe JAVA
    • 12 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA} Une classe contient une ou plusieurs m´thodes. Par exemple dans la classe Chien, la m´thode e eaboyer() va contenir des instructions sp´cifiant la fa¸on dont un chien aboie. Les m´thodes sont e c eobligatoirement d´clar´es dans une classe. e epublic class Chien{ void aboyer() { // code de la methode aboyer o` l’on indique comment u // la m´thode doit ^tre ex´cut´e e e e e }}2.4.2 Execution d’un programme Java Source Compilation Execution On compile le(s) fichier(s) source(s) avec le programme L’ex´cution est lanc´e en uti- e e javac, par exemple javac lisant le programme java On cr´e un document source e Toto.java. Si la compilation avec le nom du fichier princi- avec une extension .java, par a r´ussi, un fichier .class e pal du programme sans l’ex- exemple Toto.java Toto.class est cr´´, ce fi- ee tension .class. Par exemple chier est constitu´ de byte e java Toto. code2.4.3 La machine virtuelle Un programme s’ex´cute en lan¸ant la JVM sur le fichier principal (Toto.class). Ce fichier e ccontient du byte code et la JVM traduit ce byte code en code machine compr´hensible par la eplateforme sous-jacente et ex´cute le programme. e Lorsque la JVM d´marre elle cherche la classe sp´cifi´e ` l’ex´cution, puis elle recherche une e e e a em´thode sp´ciale – la m´thode main – qui ressemble exactement ` ceci : e e e apublic static void main(String [] args){ //le code de la methode main} La JVM ex´cute ensuite tout ce qui se trouve entre les accolades{ } de la m´thode main. e e2.4.4 La m´thode main e Toute application java a au moins une m´thode main. Attention, pas une par classe, mais au emoins une par application. La m´thode main correspond ` l’endroit o` le programme commence e a ua` s’ex´cuter. e Voici un exemple de programme complet :public class PremiereAppli{ public static void main(String [] args)
    • 2.4. STRUCTURE D’UN PROGRAMME JAVA 13 { System.out.println("Bonjour ` tous"); a System.out.println("Je m’appelle toto"); }} 1. Enregistrement dans le fichier PremiereAppli.java 2. Compilation javac PremiereAppli.java 3. Lancement du programme java PremiereAppli 4. Le r´sultat du programme consiste ` afficher les 2 lignes suivantes : e a Bonjour a tous ` Je m’appelle toto2.4.5 Utilisation d’arguments dans la fonction main Les arguments de la m´thode main sont plac´s dans le tableau args, qui est un tableau constitu´ e e ede chaˆınes. Lors du lancement d’un programme, les arguments se placent a la suite de l’identificateur de `classe du programme lanc´ et sont s´par´s par un espace. Exemple : e e ejava AfficheArguments Le langage Java Voici le programme correspondant :public class AfficheArguments{ public static void main(String [] args) { for(int i=0;i<args.length;i++) { System.out.println("contenu de args[".i."] : ".args[i]); } }} A l’ex´cution, ce programme affiche le r´sultat suivant : e eargs[0] : Leargs[1] : langageargs[2] : JavaN.B. Les arguments sont pass´s sous la forme de chaˆnes de caract`res, si nous voulons des e ı enombres nous devons convertir les arguments.Exemple.public class Addition2Entiers{ public static void main(String [] args) { int entier1, entier2, resultat; entier1=Integer.parseInt(args[0]); entier2=Integer.parseInt(args[1]);
    • 14 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA resultat = entier1 + entier2; System.out.println("La somme de "+entier1+" et "+entier2+" est : "+resultat); }} Pour lancer le programme : java Addition2Entiers 1 3. Autre exemple.public class ConversionFrancsEuros{ public static void main(String [] args) { final float taux = 6.55957; float somme = 0, resultat; somme=Float.parseFloat(args[0]); resultat = somme / taux; System.out.println("Le resultat de la convertion de "+somme+"francs est "+resultat+" euros."); }}2.5 Installation et utilisation de Java Pour installer un outil de d´veloppement java, il suffit de r´cup´rer un outil de d´veloppement e e e e(JDK ou SDK) sur http://java.sun.com/javase/downloads/index.jsp, puis de lancer le pro-gramme d’installation. Sous linux vous pouvez l’installer dans /usr/local pour le rendre accessiblea` tout le monde, ou sous votre compte. Ensuite nous allons principalement utiliser les programmes situ´s dans le r´pertoire bin - e e/usr/local/jdk1.6.0 06/bin par exemple si vous avez r´cup´r´ la version 06 du jdk 1.5 - javac, e e ejava, javadoc, jar, . . .). Pour faciliter leur utilisation vous pouvez mettre le r´pertoire bin dans evotre variable d’environnement PARH (cf le cours syst`me). e Pour ´crire nos programmes nous aurons seulement besoin d’un ´diteur (par exemple emacs e esous linux, ou tout un autre ´diteur si vous le souhaitez) et d’un terminal (xterm). e Vous pourrez ´ventuellement avoir de besoin de configurer une variable d’environnement CLASSPATH equi indique les r´pertoires o` sont situ´s les programmes java. Ce n’est pas obligatoire, par d´faut e u e eles programmes sont cherch´s dans le r´pertoire courant et il est possible d’indiquer des r´pertoires e e een sp´cifiant des options aux diff´rents programmes disponibles dans le jdk (voire la documentation e eofficielle indiqu´e dans les liens ci-dessous). e Quand vous serez plus exp´riment´ (par exemple ` partir du 4`me TP), vous pourrez essay´ e e a e ed’autres ´diteurs facilitant le d´veloppement de programmes java tels qu’eclipse ou NetBeans. A e evous de les essayer et ´ventuellement d’en adopter un. N´anmoins, il est d’abord conseill´ d’utiliser e e eun ´diteur non sp´cifique pour commencer, puis de passer ` un ´diteur sp´cialis´ une fois que l’on e e a e e emaˆ ıtrise les bases du langage. Pour ceux qui souhaitent essayer leurs programmes sous windows, la proc´dure d’installation est ela mˆme. Il peut cependant ˆtre n´cessaire de cr´er une variable d’environnement suppl´mentaire. e e e e eVoici la proc´dure ` suivre. e a – V´rifier que la variable d’environnement JAVA HOME est sp´cifi´e. e e e
    • ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 15 – Si ce n’est pas le cas allez dans Menu D´marrer → Settings → Control Panel → System → e Advanced, menu variables d’environnement. Entrez le nom de JAVA HOME puis sa valeur (par exemple C :2sdk1.6.0 06/). – Pour v´rifier tapez echo %JAVA HOME dans une console MS-DOS. e Vous pouvez utiliser la mˆme m´thode pour modifier le contenu de la variable PATH ou confi- e egurer CLASSPATH. En guise de terminal vous utiliserez alors une console MS-DOS.2.6 Types, expressions et structures de contrˆle fondamen- o tales Cette partie a pour objectif de pr´senter rapidement l’utilisation des types, des expressions eet des instructions de contrˆle en JAVA. Les ´l´ments abord´s ne sont pas forc´ment toujours o ee e ecaract´ristiques du langage JAVA mais sont n´cessaires pour l’utilisation de n’importe quel lan- e egage de programmation. Lorsque certaines situations sont sp´cifiques au langage JAVA, nous le epr´cisons. e2.6.1 les types primitifs Ils servent ` d´finir les champs (attributs) de toutes les classes que vous pourrez d´finir, ainsi a e eque les variables que vous pourrez utiliser dans les diff´rentes m´thodes. Attention, les types e eprimitifs ne sont pas des classes.La notion de type La m´moire centrale est un ensemble de ” positions binaires ” appel´es. Ces bits sont regroup´s e e een octets, un octet correspondant ` 8 bits. Les ordinateurs (actuels) ne savent repr´senter et traiter a eque des informations repr´sent´es sous forme binaire. Il est donc n´cessaire de savoir comment une e e einformation a ´t´ cod´e pour pouvoir attribuer une signification ` une suite de bits d’un emplace- ee e ament de la m´moire. eIl existe 4 cat´gories de type primitif en JAVA : e – nombres entiers – nombres flottants – caract`res e – bool´ens ele type entier (int) Il sert ` repr´senter les nombres entiers relatifs. Il existe quatre sortes d’entier permettant de a erepr´senter des valeurs diff´rentes. Le tableau suivant d´crit chacun de ces types avec le nom du e e etype, la taille occup´e en m´moire en octets, la valeur minimale et la valeur maximale possible e eavec la constante correspondante dans le langage. Nom Taille Valeur minimale Valeur maximale byte 1 -128 127 Byte.MIN VALUE Byte.MAX VALUE short 2 -32768 32767 Short.MIN VALUE Short.MAX VALUE int 4 -2,147,483,648 2,147,483,647 Integer.MIN VALUE Integer.MAX VALUE long 8 -9,223,372,036,854,775,808 9,223,372,036,854,775,807 Long.MIN VALUE Long.MAX VALUE
    • 16 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVALes constantes peuvent s’´crire sous forme d´cimale (548, -78, +5), ou sous forme hexad´cimale e e een pr´cisant la valeur de 0x ou 0x (0x1A 0X12), ou octale en faisant pr´c´der la valeur de 0 (032, e e e05). Une constante enti`re est forc´ment de l’un des types int ou long. On peut forcer une constante e e` ˆtre du type long en faisant suivre sa valeur de la lettre l ou L, exemple 25L. Le compilateuraerejettera toute constante ayant une valeur sup´rieure la capacit´ du type long. e eLes flottants/r´els (float ou double) e Il en existe deux sortes. Le tableau suivant d´crit chacun d’eux avec leur nom, la taille occup´e e een m´moire en octets, la pr´cision correspondant au nombre de chiffres significatifs pris en compte e edans la partie d´cimale, la valeur minimale et la valeur maximale possible avec la constante ecorrespondante dans le langage. Nom Taille Pr´cision e Valeur absolue minimale Valeur absolue maximale float 4 7 −1.40239046 × 10−45 3, 40282347 × 1038 Float.MIN VALUE Float.MAX VALUE double 8 15 4.9506564584124654 × 10− 324 1, 797693134862316 × 10308 Double.MIN VALUE Double.MAX VALUE Pour les constantes, il existe deux notations : – la notation d´cimale : 12.43 -0.38 -.38 4. .27 e – la notation exponentielle : 4.25E4 ou 4.25e+4 pour 4.25 × 104 54.2e-32 pour 54.2 × 10−32 48e13 pour 48 × 1013 Par d´faut toutes les constantes cr´´es sont de type double, pour forcer ` avoir un type float e ee aon fait suivre la valeur de la lettre f, exemple : 12.5fLe type caract`re (char) e Les caract`res, d´sign´s par le type char, sont cod´s sur 2 octets, notation d’une constante e e e ecaract`re : ’a’, ’B’, ’´’, ’+’. Exemple e echar lettre=’a’ ; Certains caract`res avec notation sp´ciale : e e – ’b’ pour le retour arri`re (backspace) e – ’t’ pour une tabulation – ’n’ pour un saut de ligne – ’f’ pour un saut de page – ’r’ pour un retour chariot – ’"’ pour un guillemet – ’’’ pour une apostrophe – ’’ pour .Le type bool´en (boolean) e Il sert ` repr´senter une valeur logique de type vrai ou faux, il existe deux valeurs possibles pour a eun bool´en en java : true et false (pour vrai et faux). Exemple boolean est ordonne=false ;. e Attention, en JAVA, les valeurs logiques ne sont pas repr´sent´es par des valeurs mais par un e etype sp´cifique : le type boolean, toute utilisation de valeur num´rique dans des tests provoquera e eune erreur !Initialisations et constantesVariables Exemples : int n=15 ; ´galement ´quivalent ` int n ; n=15 ;. e e a
    • ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 17 En JAVA, les d´clarations peuvent apparaˆ ` n’importe quel endroit du programme. D’un e ıtre apoint de vue m´thodologique, il est souvent conseill´ d’effectuer la d´claration de toutes les e e evariables (importantes) ensembles au d´but puis de les initialiser avant de les utiliser. eN.B. Les variables n’ayant pas re¸u de valeur ne peuvent pas ˆtre utilis´es sous peine d’aboutir c e ea une erreur de compilation. Il est donc important de penser a initialiser les variables d`s leur` ` ecr´ation. eConstantes : le mot cl´ final Pour indiquer qu’une variable ne peut pas ˆtre modifi´e pendant e e el’ex´cution d’un programme, on peut utiliser le mot cl´ final : e efinal int nombre de mois=12 ;Toute modification de la variable nombre de mois, de valeur initiale 12, sera rejet´e par le compi- elateur.2.6.2 Op´rateurs et expressions eOp´rateurs arithm´tiques e e Il existe cinq op´rateurs principaux : e – + : addition a+b – - : soustraction a-b – / : division a/b – * : multiplication a*b – % : modulo, a % b calcule le reste de la division de a par b. Le probl`me de la conversion de type : efloat x ; float res ;int n ; int p ;res=n*x+p ;La variable n ´tant de type int, x de type float, le compilateur va convertir n en float puis faire le ecalcul. Le r´sultat final sera de type float, comme le montre la Figure 2.1. e n * x + p int float long float * float + float float Fig. 2.1 – Evaluation de res=n*x+p ; La hi´rarchie de conversion permettant de ne pas d´naturer la valeur initiale : int → long e e→ float → double.Note : par d´faut, pour les types byte, char, short, si un de ces types apparaˆ dans une expression, e ıtla valeur est d’abord convertie en int. Exemple :short p1=1, p2=1 ,p3=1 ;float x=2 ;L’´valuation de p1*p2+p3*x est faite comme le montre la Figure 2.2. eOp´rateurs de comparaison e Ils servent ` faire des comparaisons relatives et sont principalement utilis´s dans les tests a econditionnels.
    • 18 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA p1 * p2 + p3 * x int int int * float * float int float float + float Fig. 2.2 – Evaluation de p1*p2+p3*x – < : inf´rieur strictement ` e a – <= : inf´rieur ou ´gal ` e e a – > : sup´rieur ` e a – >= : sup´rieur ou ´gal ` e e a – == : ´gal ` e a – ! = : diff´rent de. eCes op´rateurs peuvent s’utiliser avec des expressions : 2 ∗ a > b + 5, x + y < (a + 2) ∗ 5, . . . eNote : ordre sur les caract`res 0 < 1 < . . . < 9 < A < B < . . . < Z < a < . . . < z . eOp´rateurs logiques e Ces op´rateurs permettent de manipuler des valeurs logiques. e – ! : n´gation e – & : ”ET” – ∧ : ”OU” exclusif – | : ”OU” inclusif – && : ”ET” avec court-circuit – || : ”OU” inclusif avec court-circuitExemples : – (a < b) && (c < d), (a < b) & (c < d) : ces deux expressions prennent la valeur true (vrai) si les deux expressions a < b et c < d sont toutes les deux vraies, la valeur false (faux) dans le cas contraire. – (a < b) || (c < d), (a < b) | (c < d) : prend la valeur true si l’une au moins des deux conditions a < b ou c < d est vraie, la valeur false dans le cas contraire. – (a < b) ∧ (c < d) prend la valeur true si une et une seule des deux conditions a < b et c < d est vraie, la valeur false dans le cas contraire. – !(a < b) prend la valeur true si la condition a < b est fausse, la valeur false dans le cas contraire. Cette expression poss`de en fait la mˆme valeur que a >= b. e e – Les deux op´rateurs && et || poss`dent une propri´t´ int´ressante : leur second op´rande e e ee e e (celui qui figure ` droite de l’op´rateur) n’est ´valu´ que si la connaissance de sa valeur est a e e e indispensable pour d´cider si l’expression est vraie ou fausse. Par exemple, si on a l’expression e (a < b)&&(c < d), on commence par ´valuer (a < b), si le r´sultat est faux on n’´value pas e e e c < d puisque le r´sultat est d´j` connu. Les op´rateurs ∧ et | ´valuent toujours les deux e ea e e op´randes, il est donc plutˆt conseill´ d’utiliser les op´rateurs && et ||. e o e eOp´rateurs d’affectation e – = : exemples c=b+3 ; c=i ;. L’op´rateur poss`de une associativit´ de gauche ` droite, ainsi e e e a dans l’expression i = j = 5 ; on ´value j=5 d’abord, puis i=j, i et j ont ` la fin la mˆme e a e valeur 5. Attention aux probl`mes de conversion, supposons que nous ayons une variable de type int n e et une variable de type float x, l’expression n=x+5 ; est rejet´e par le compilateur. Il faut en e
    • ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 19 fait ´crire n=(int) x + 5 ;. Il est n´cessaire de faire une conversion explicite. Les conversions e e pour lesquelles il n’y a pas besoin de faire une conversion explicite sont les suivantes : – byte → short → int → long → float → double – char → int → long → float → double – L’incr´mentation et la d´cr´mentation. Ces op´rations consistent respectivement ` augmen- e e e e a ter une variable (en g´n´ral enti`re) 1 et ` diminuer une variable de 1 (i = i-1 ; n = n+1 ;). e e e a Ces op´rations sont d´finies par les op´rateurs ++ et -- : i-- ; n++ ; ou --i ; ++n ;. Il existe e e e cependant un diff´rence suivant o` est plac´ l’op´rateur lors de l’´valuation d’une expression, e u e e e s’il est plac´ avant(on parle d’op´rateur pr´fix´) la variable l’op´ration est effectu´e avant e e e e e e l’´valuation de l’expression, s’il est plac´ apr`s (on parle d’op´rateur postfix´) l’op´ration est e e e e e e effectu´e apr`s. e e – n= ++i -5 ; : on affecte d’abord la valeur 6 ` i puis la valeur 1 ` n. a a – n= i++ - 5 ; : on affecte d’abord la valeur 0 ` n puis la valeur 6 ` i. a a – Affectation ´largie, les instructions suivantes sont ´quivalentes : e e – i = i + k ; et i+=k ; Il existe la mˆme chose avec les op´rateurs *, / et -. e eConversion de types Lorsque l’on d´sire convertir un type vers autre qui a une taille de repr´sentation inf´rieure, e e eles r`gles suivantes s’appliquent : e – entier vers entier (long vers int, short vert byte, . . .) les octets les moins significatifs sont conserv´s. e – double vers float : arrondi au plus proche. – flottant vers entier : il y a d’abord un arrondi au plus proche dans le type long ou int, puis on effectue la conversion en conservant les octets les moins significatifs.Op´rateur conditionnel e condition ? etape1 : etape2 ; : si condition est vraie alors etape1 sinon etape 2. Exemple :max = a<b ? a :b ;Si a < b, alors la variable max re¸oit la valeur de la variable a, sinon elle re¸oit la valeur de la c cvariable b.Priorit´ des op´rateurs e e Op´rateurs e associativit´ e () [] . ++(postfix´) –(postfix´) e e g`d a +(unaire) -(unaire) ++(pr´fix´) –(pr´fix´) (unaire) ! cast new e e e e d`g a /% g`d a +- g`d a << >> >>> g`d a < <= > >= instanceof g`d a == != g`d a & g`d a ∧ g`d a — g`d a && g`d a — g`d a ?: g`d a = += -= *= /= %= <<= >>= >>>= & = | = ∧ = d`g a
    • 20 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA2.6.3 Les structures de contrˆle o Dans cette partie, les crochets [] signifient que ce qu’ils renferment est facultatif. Il servent soita` exprimer le fait que pour lier plusieurs instructions ` une structure de contrˆle il est n´cessaire a o ede mettre ces instructions dans un bloc entre accolades ({}) (si on n’a besoin que d’une seuleinstruction on n’a pas besoin de bloc) ; soit ` indiquer qu’une instruction facultative. a Le terme condition correspond ` une expression qui peut ˆtre ´valu´e sous forme logique (vrai a e e eou faux).if L’instruction if (si) est une instruction de choix.if(condition)[{] instruction_1[instruction_2...instruction_n}][else [{] instruction_1[instruction_2...instruction_n}]Exemple :public classTva { public static void main(String [] args) { double taux_tva=21.6; double ht, ttc, net, taux_remise, remise; ht=200.5; ttc=ht * (1.0 + taux_tva/100.0); if(ttc < 1000.0) taux_remise=0.; else if(ttc < 2000) taux_remise=1.; else if(ttc < 5000){ taux_remise=2.; System.out.println("Message: Prix ttc entre 2000 et 5000"); }else{ taux_remise=5.; System.out.println("Message: Prix ttc superieur a 5000"); } remise = ttc * taux_remise/100; net = ttc - remise; System.out.println("Prix ttc: "+ttc); System.out.println("Remise: "+remise); System.out.println("Net a payer: "+net);
    • ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 21 }}switch L’instruction switch (branchement) est une instruction de choix, permettant de tester plusieursvaleurs d’une expression. L’expression peut ˆtre de type byte, short, char ou int. e Syntaxe :switch(expression){ case constante_1: [suite d’instructions1] case constante_2: [suite d’instructions2] case constante_n: [suite d’instructionsn] [default: suite d’instructions]}Exemple :public class ExSwitch{ public static void main(String [] args) { int n; n=Integer.parseInt(args[0]); switch(n) { case 0: System.out.println("zero"); break; case 1: System.out.println("un"); break; case 3: System.out.println("trois"); default: System.out.println("Rien"); System.out.println("Fin"); } System.out.println("Fin du programme"); }}while Il s’agit d’une boucle tant que qui ex´cute un ensemble d’instructions tant qu’une condition eest vraie. Syntaxe :while(condition)[{] instruction_1 [instruction_2 ... instruction_n}]
    • 22 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVAExemplepublic class Boucle{ public static void main(String [] args) { int x=1; System.out.println("Avant la boucle"); while(x<4) { System.out.println("Dans la boucle, la valeur de x est "+x); x=x+1; } System.out.println("Apr`s la boucle"); e }}do-while Il s’agit d’une boucle faire-tant que similaire ` la boucle while sauf que la condition est ´valu´e a e eapr`s chaque parcours de boucle. La boucle do-while est ex´cut´e au moins une fois, alors que la e e eboucle while peut ne jamais ˆtre ex´cut´e. e e e Syntaxe :do [{] instruction_1 [instruction_2 ... instruction_n }] while(condition);N.B. Il y a un point virgule a la fin de l’instruction ! `Exemple :public class Boucle2{ public static void main (String [] args){ int x=1; System.out.println("Avant la boucle"); do{ System.out.println("Dans la boule, la valeur de x est "+x); x=x+1; }while(x<4); System.out.println("Apr`s la boucle"); e }}for L’instruction for est une boucle (pour) dont la syntaxe est divis´e en trois expressions. e Syntaxe :for([initialisation] ; [condition] ; [incr´mentation]) e[{]instruction_1[instruction_2...instruction_n}]
    • ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 23 – initialisation est une d´claration ou une suite d’expressions quelconques s´par´es par des e e e virgules, cette partie est ´valu´e une seule fois avant d’entrer dans la boucle. e e – condition est une expression bool´enne (logique) quelconque, cette partie conditionne la e poursuite de la boucle et est ´valu´e avant chaque parcours. e e – incr´mentation est une suite d’expressions quelconques s´par´es par des virgules, cette e e e partie est ´valu´e ` la fin de chaque parcours. e e aExemple classique :public class ExFor1{ public static void main (String args []) { int i; for(i=1; i<=5; i++) { System.out.println("bonjour"); System.out.println(i + "fois"); } }}Remarque : l’exemple pr´c´dent est ´quivalent ` e e e apublic class ExFor2{ public static void main (String args []) { int i; i=1; while(i<=5) { System.out.println("bonjour"); System.out.println(i+"fois"); i++; } }}Autre exemple :public class ExFor3{ public static void main(String args []) { int i,j; for(i=1, j=3;i<=5; i++, j+=i) { System.out.println("i= " +i+ "j= " +j); } }} Ce dernier exemple pourrait ´galement ˆtre ´crit de la mani`re suivante : e e e epublic class ExFor4
    • 24 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA{ public static void main(String args []) { for(int i=1, j=3;i<=5; i++, j+=i) { System.out.println("i= " +i+ "j= " +j); } }}Les instructions break et continue Ces instructions s’emploient principalement au sein de boucles. L’instruction break (casser) sert ` interrompre le d´roulement d’une boucle en passant ` a e al’instruction situ´e apr`s la boucle. L’ex´cution de cette instruction est conditionn´e par un choix. e e e eExemple :public class ExBreak{ public static void main (String args []) { int i; for(i=1;i<=10;i++) { System.out.println("debut tour"+i); System.out.println("bonjour"); if(i==3) break; System.out.println("fin tour"+i); } System.out.println("apres ma boucle") }}Le r´sultat du programme pr´c´dent est le suivant : e e edebut tour 1bonjourfin tour 1debut tourbonjourfin tour 2debut tour 3bonjourapres la boucle En cas de boucles imbriqu´es, l’instruction break fait sortir de la boucle la plus interne. e L’instruction continue permet de passer directement au tour de boucle suivant. Exemple.public class ExContinue{ public static void main (String args[]) { int i; for(i=1; i<=5; i++)
    • `2.7. UNE PREMIERE INTRODUCTION AU TYPE STRING 25 { System.out.println("debut tour"+i); if (i<4) continue; System.out.println("fin tour"+i); } System.out.println("apres la boucle"); }}Exemple d’ex´cution : edebut tour 1debut tour 2debut tour 3debut tour 4fin tour 4debut tour 5fin tour 5apres la boucle2.6.4 Les ´l´ments sp´cifiques au langage JAVA ee e Parmi les points abord´s ci-dessus, quatre sont plutˆt sp´cifiques au langage JAVA. e o e – Le mot cl´ final qui permet de d´clarer des constantes ` l’aide de variables. e e a – Le type byte qui permet de repr´senter des entiers entre -128 et 127. e – Le type boolean pour repr´senter les valeurs true (vrai) et false (faux). Tous les tests e conditionnels doivent ˆtre compatibles avec le type boolean. Mettre une valeur enti`re dans e e un test provoque une erreur de compilation en JAVA (par exemple if(1)... est interdit en JAVA). – Les conversions de type doivent ˆtre explicites en JAVA chaque que l’on veut convertir un e type g´n´ral vers une repr´sentation plus petite. Exemple : e e e int n=2; float x=1.0; ... n=(int) x; Un autre ´l´ment est trait´ de mani`re sp´cifique en JAVA : le type chaˆ de caract`res ee e e e ıne e(String). Une introduction est propos´e dans la section suivante. e2.7 Une premi`re introduction au type String e En JAVA, les chaˆınes de caract`res sont d´finies par un type sp´cifique : le type String. Nous e e epr´sentons ici une courte introduction, nous reviendrons sur ce type plus tard. eD´claration eString chaineSalutation = "bonjour"; Une chaˆ de caract`re constante se d´clare toujours entre guillemets "... ". ıne e eConnaˆ ıtre la longueur d’une chaˆ ıneint l = chaineSalutation.length();
    • 26 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVAAcc`s ` un caract`re e a echar cara1 = chaineSalutation.charAt(0);char cara1 = chaineSalutation.charAt(2);La variable cara1 contient le caract`re b, la variable cara2 contient le caract`re n. e eConcat´nation : l’op´rateur + e eString ch1 = "Bonjour";String ch2 = " ` tous"; aString ch = ch1 + ch2; La variable ch contient la chaˆ ”Bonjour a tous”. ıne `Impression d’une chaˆ de caract`res ıne eSystem.out.println(chaineSalutation);System.out.println(ch1+ch2);System.out.println(ch);Comparaison de chaˆ ınes La m´thode equals qui teste l’´galit´ de deux chaˆ e e e ınes de caract`res : ech1.equals(ch2) ou ch1.equals("Bonjour"). La m´thode compareTo pour comparer deux chaˆ e ınes de caract`res dans l’ordre lexicographique e(alphab´tique) : ch1.compareTo(ch2) e – renvoie un entier strictement n´gatif si ch1 est situ´e avant ch2 dans l’ordre lexicographique e e – renvoie un entier strictement positif si ch1 est situ´e apr`s ch2 dans l’ordre lexicographique e e – 0 si ch1 contient la mˆme chaˆ que ch2. e ıne2.8 R`gles d’´criture d’un programme JAVA e e Ce document a pour objectif de synth´tiser les r`gles d’´criture g´n´ralement utilis´es pour le e e e e e ed´veloppement d’applications en JAVA. e2.8.1 Les identificateurs Les identificateurs sont des suites de caract`res servant ` d´signer les entit´s manipul´es par e a e e eun programme (variables, m´thodes, classes, objets, . . .). En JAVA, un identificateur est form´ de e elettres et de chiffres ou du caract`re . Le premier caract`re est forc´ment une lettre A-Z, a-z ou e e e´ventuellement . Il n’existe aucune limitation sur le nombre de caract`res. Exemples :e eligne, valeur 5, total, 56, ma variable 1, i, MaClasse, ...Attention, on distingue les minuscules des majuscules (ligne = Ligne). Certaines conventions sont traditionnellement utilis´es : e – Les noms de variables et de m´thodes sont ´crits en minuscule sauf s’ils sont form´s de la e e e juxtaposition de plusieurs mots, auquel cas chaque sous-mot, sauf le premier, comporte une majuscule ` la premi`re lettre. Exemples : valeur, nombreValeur, tauxEmprunt, a e calculNombreReponsesExactes, getX2, ... – Les noms de classe suivent la mˆme r`gle, mais leur premi`re lettre est ´crite en majuscule. e e e e Exemples : PremierProgramme, Clavier, CalculMoyenne, ... Remarque : cette convention permet de distinguer le fait que System est une classe et que out n’en est pas une (System.out.println).
    • ` ´2.8. REGLES D’ECRITURE D’UN PROGRAMME JAVA 27 – Des identificateurs successifs doivent ˆtre s´par´s par un espace ou un saut de ligne quand e e e il n’y a pas de s´parateur ou de syntaxe particuli`re. Exemple : x = a + 5 ; y += 4 ; Une e e virgule est utilis´e pour faire plusieurs d´clarations d’un mˆme type. Exemple : e e e int x, y ; float n, compteur, total, valeur ;2.8.2 Commentaires Il existe trois types de commentaires en JAVA. – les commentaires commen¸ant par /∗ et se terminant par ∗/, exemple : /* Ceci est un c commentaire usuel*/ – les commentaires de fin de ligne //, exemple : int valeur ; // valeur avec commentaire de fin de ligne – les commentaires de documentation commen¸ant par / ∗ ∗ et finissant par ∗/. C’est un cas c particulier des commentaires usuels puisqu’ils commencent de mani`re l´g`rement diff´rente e e e e par rapport ` ces derniers. Leur int´rˆt est de pouvoir ˆtre extrait automatiquement pour a e e e faire de la documentation avec, par exemple, le programme javadoc.2.8.3 Mots cl´s r´serv´s e e e Les mots suivant sont des mots cl´s r´serv´s pour le langage et ne peuvent ˆtre utilis´s e e e e e abstract boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static super switch synchronized this throw throws transient try void volatile while2.8.4 Remarques globales – Les instructions se terminent par un point virgule ;. – Les blocs de code sont d´finis entre accolades {}. e – On d´clare une variable avec un nom et un type : int x;. e – Un op´rateur d’affectation est avec un seul signe : =. e – Un op´rateur d’´galit´ est avec deux signes : ==. e e e – Lorsque l’on ´crit du code, il est imp´ratif de respecter les r`gles d’indentation : les instruc- e e e tions ` l’int´rieur d’un bloc doivent ˆtre d´cal´es ` droite, c’est ´galement lorsque l’on utilise a e e e e a e une structure de contrˆle. La d´finition de m´thodes et d’attributs de classes doivent ˆtre o e e e indent´s par rapport ` la d´finition de la classe elle-mˆme. e a e e – Pensez ` commenter votre code et ` bien d´crire ce que font vos fonctions et ` quoi servent a a e a vos classe ! – ...2.8.5 Commentaires sur le rendu d’un programme Java Pour rendre un projet vous devez construire une archive (zip, tar.gz) contenant les diff´rents e´l´ments de votre projet. Une archive correctement constitu´e devrait contenir :ee e – une bonne documentation comprenant
    • 28 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA – un Fichier README contenant des informations pour lancer le projet, l’installer, les pr´- e requis ´ventuels et qui documente le contenu de l’archive (liste des fichiers et diff´rents e e r´pertoires et ce qu’il y a dedans). e – un manuel utilisateur indiquant comment utiliser le logiciel – un manuel technique sur la conception du projet (notamment ` destination des d´veloppeurs) a e contenant - par exemple - des sch´mas UML (au moins une description du code constituant e le projet), les points ` am´liorer, les bugs, les difficult´s, les choix .... Pour des projets java, a e e la documentation technique peut id´alement ˆtre compl´t´e par une javadoc (important e e ee pour continuer le d´veloppement plus tard). e – une architecture correcte : id´alement ` la racine on a le README et que des sous-r´pertoires e a e contenant la documentation, le code ex´cutable, le code source, les drivers, plus d’autres e choses tout le temps dans un sous-r´pertoire sp´cifique et document´ dans le README. e e e Les fichiers sources sont s´par´s des ex´cutables, soit dans 2 r´pertoires diff´rents, soit - e e e e e id´alement - dans un r´pertoire contenance uniquement les sources et les ex´cutables sont e e e stock´s dans une archive .jar On mettra dans des r´pertoires sp´cifiques des fichiers de log, e e e de sauvegarde, les images, ... – Un code de bonne qualit´. Le code doit respecter les conventions de nommage java, avoir e des noms de variables explicites, ˆtre indent´ correctement, et bien comment´. On peut e e e distinguer des commentaires g´n´raux d´crivant le contenu d’une classe et son objectif, et e e e des commentaires d´crivant une m´thode et ce qu’elle fait (on les retrouve dans la javadoc). e e Ensuite des commentaires internes qui se situent ` l’int´rieur des m´thodes pour expliquer des a e e des attributs d’une classe, des variables de m´thode , des algorithmes, des choses techniques e .... Le code import´ d’ailleurs doit ˆtre signal´ dans la documention technique par exemple e e e et la provenance doit ˆtre indiqu´e. On peut mˆme signaler pourquoi on a eu besoin de ce e e e code. – L’archive DOIT ˆtre nettoy´e et ne pas poss´der de fichiers inutiles pour l’utilisateur (fichiers e e e de log, de sauvegardes, de tests, inutilis´s, ...) e Ces remarques sont d’ordre g´n´rales mais il est pertinent d’essayer de les respecter. Le nom e ede l’archive doit correspondre au nom du projet, lorsque c’est un travail ` rendre ` un enseignant a ail est de bon ton d’ajouter le nom de la personne envoyant le projet. En g´n´ral, lorsque que l’on e ed´compresse l’archive, celle-ci doit cr´er un dossier contenant tous les ´l´ments. e e ee Lorsque que vous envoyez une archive par courrier ´lectronique, il est parfois conseill´ d’indi- e equer dans le message le nom de l’archive envoy´e (sa taille notamment si elle est volumineuse). eIl est ´galement judicieux de commencer votre message par une formule de salutation (du genre ebonjour) et de terminer par une formule de politesse (Bonne r´ception, cordialement, ...) et veillez ea` ne pas oublier de mettre votre nom ` la fin du message ! Pensez ´galement ` mettre un sujet a e apertinent au message et ` vous mettre en copie (cc) notamment lorsque ce sont des projets not´s a ea` rendre. Je vous conseille aussi pour votre activit´ professionnelle, dans la mesure du possible, d’utiliser eune adresse ´lectronique qui ne soit pas trop fantaisiste. e2.8.6 Liens sur la programmation JAVA Voici quelques liens qui pourront vous permettre de compl´ter vos connaissances en JAVA. eIl existe de nombreux liens, en voici une liste non exhaustive pour commencer vos bookmarkspersonnels. – http://java.sun.com/reference/api/index.html : informations sur les api standards de java, par versions. – http://java.sun.com/docs/ documentation sur les diff´rentes versions de java. e – http://java.sun.com/docs/books/tutorial/deployment/jar/ documentation sur les fi- chiers jars.
    • 2.9. EXERCICES DE COURS 29 – http://java.sun.com/javase/6/docs/technotes/guides/javadoc/index.html documen- tation sur javadoc. – http://ibiblio.org/javafaq : des nouvelles quotidiennes sur java, un cours en HTML, de nombreux liens – http://www.java-channel.org : site modifi´ quotidiennement, contenant des liens vers e d’autres sites. – http://www.javaworld.com : nouvelles et articles techniques – http://developers.sun.com : site de SUN inscription obligatoire mais gratuite, l’inscrip- tion se fait ` partir du lien suivant : http://developpers.sun.com/user_registration/ a whyregister.jsp – http://java.developpez.com/faq/java/ : FAQ en fran¸ais c – http://www.eclipse.org : un environnement de d´veloppement (IDE - Integrated Deve- e lopment Environment) qui facilite l’´criture de programmes java. e2.8.7 Bibliographie Voici quelques r´f´rences bibliographiques, ce cours est inspir´ de certaines d’entre elles. ee e – Programmer en Java. Claude Delannoy. Editions Eyrolles. – Java Tˆte la premi`re. Kathy Sierra et Bert Bates. Editions O’Reilly. e e – Java in a nutshell - manuel de r´f´rence. David Flanagan. Editions O’Reilly. ee – The Java Programming Language Second Edition. Ken Arnold, James Gosling. Addison Wesley, 1998. – Java par la Pratique. Patrick Niemeyer, Joshua Peck. O’Reilly.2.9 Exercices de cours2.9.1 Compilateur Voici le contenu de trois fichiers JAVA, indiquez pour chacun d’eux si ces fichiers peuventse compiler ou dans le cas contraire indiquez comment les corriger. Dites finalement ce que fontchacun de ces programmes. 1. public class Exercice1b{ public static void main(String [] args) { int x=1; while(x<10){ if(x>3) { System.out.println("grand x"); } } } } 2. public static void main (String [] args) { int x=5; while(x>1) { x=x-1; if(x<3) { System.out.println("petit x"); }
    • 30 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA } } 3. public class Exercice1b{ int x=5; while(x>1) { x=x-1; if(x<3){ System.out.println("petit x"); } } }Solution : 1. Ce fichier compile et s’ex´cute, mais il faut ajouter une ligne au programme dans la boucle e while sinon il boucle sans fin. On peut, par exemple, ajouter x = x + 1; juste apr`s le e while et avant le if. 2. Ce fichier ne compile pas, il manque une d´claration de classe pour mettre la m´thode main e e dedans, par exemple public class Test{ et il faudra rajouter une accolade } ` la fin. a 3. Ce fichier ne compile pas, une classe doit avoir au moins une m´thode (pas forc´ment une e e m´thode main). e
    • 2.9. EXERCICES DE COURS 312.9.2 Mots crois´s e 1 2 3 C F P L L U 4 5 J A V A W O B 6 7 S H A C V L 8 9 S I N T O A B I 10 E L M R I C 11 12 13 S Y S T E M O U T P R I N T T A I A 14 A I L B M 15 16 S T R I N G D E C L A R E R I R E T 17 18 C O D E J H V O 19 C O M M A N D E E HORIZONTALEMENT VERTICALEMENT 4 Commande pour executer un programme 1 Patrons de classes (-) java (-) 2 Pas entier (-) 8 Entier (-) 3 Tout le monde peut y acc´der (-) e 9 Pr´fixe (-) e 5 Tant que (-) 10 Acronyme d’un fabricant de puces (-) 6 Transformer en bytecode (-) 11 Pour afficher quelque chose (-) 7 Inconstance (-) 15 A beaucoup de caract`res (-) e 9 Vaut z´ro ou un (-) e 16 Annoncer une nouvelle classe ou une 12 Modificateur de main (-) m´thode (-) e 13 Ma m´thode principale (-) e 17 El´ment de programme (-) e 14 D´finit un comportement (-) e 19 Elle a une ligne (-) 18 Machine fonctionnant au bytecode (-)
    • 32 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA
    • Chapitre 3La notion d’objets : d´finition et eutilisation3.1 Introduction au d´veloppement objets e Dans une entreprise, un projet est soumis avec les sp´cifications suivantes : e 3 formes doivent s’afficher sur une interface graphique : un cercle, un carr´ et un triangle. e Lorsque l’utilisateur cliquera sur un bouton, la forme pivotera de 360 degr´s dans le sens des e aiguilles d’une montre (tour complet sur elle-mˆme), et le syst`me jouera un son d’un fichier e e WAV (format de son) sp´cifique a cette forme. e `2 prototypes sont propos´s pour r´aliser le programme : une en programmation imp´rative et une e e een programmation objets avec une classe pour chaque forme. Programmation imp´rative e Programmation Objets tourner(typeForme){ Carre Cercle Triangle //faire tourner la forme tourner(){ tourner(){ tourner(){ //de 360 degr´s e //code pour //code pour //code pour } //faire tourner //faire tourner //faire tourner //un carr´ e //un cercle //un triangle jouerSon(typeForme){ } } } //utiliser typeForme //pour chercher jouerSon(){ jouerSon(){ jouerSon(){ //quel son WAV jouer //code pour //code pour //code pour //puis le jouer //jouer le son //jouer le son //jouer le son } //d’un carr´e //d’un cercle //d’un triangle } } }En programmation objet, on va cr´er ”un objet” par type de forme demand´e, et on associera ` e e achaque forme ses fonctionnalit´s propres (tourner, jouer un son). En programmation imp´rative, e eon utilisera des proc´dures g´n´riques et les choix des op´rations ` effectuer se feront ` l’aide de e e e e a atests (par exemples des if). Les 2 solutions r´pondent au probl`me, mais la mod´lisation objet e e eest plus rigoureuse et offre de meilleures garanties en cas de modifications futures.Justement, supposons que les sp´cifications sont ensuite modifi´es par le commanditaire du projet : e e 33
    • 34 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATIONIl y aura en plus une forme d’amibe a l’´cran, au milieu des autres. Lorsque l’utilisateur cliquera ` e sur l’amibe elle tournera comme les autres formes, mais jouera un son .AIFCeci implique des modifications dans le code Programmation imp´rative e tourner(typeForme){ //faire tourner la forme Programmation Objets //de 360 degr´s e } Amibe tourner(){ //code pour jouerSon(typeForme){ //faire tourner //Si la forme n’est pas //l’amibe //une amibe } //utiliser typeForme //pour chercher jouerSon(){ //quel son WAV jouer //code pour //puis le jouer //jouer le son //sinon //de l’amibe //jouer le son AIF } //de l’amibe }En programmation imp´rative on va ˆtre oblig´ de modifier le code, ce qui peut provoquer l’ajout e e ed’erreurs (bugs). En programmation objet, on va rajouter un nouvel objet de forme amibe et luiassocier ses comportements propres. On n’a pas ` modifier le code existant d´j` valid´. a ea eProbl`me : le centre de rotation diff`re des autres. e e (a) Une amibe. (b) Les centres de rotation ne sont pas les mˆmes. eCeci implique une nouvelle modification pour tourner les formes.
    • ´3.1. INTRODUCTION AU DEVELOPPEMENT OBJETS 35 Programmation imp´rative e tourner(typeForme, centreX, centreY){ //si la forme n’est pas //une amibe //calculer le centre //sur la base d’un //rectangle puis Programmation Objets //faire tourner la //forme de 360 degr´s e Amibe //sinon int centreX ; //utiliser centreX et int centreY ; tourner(){ //centreY comme centre //faire tourner //de rotation puis faire //l’amibe en utilisant //tourner la forme //centreX et centreY } } jouerSon(typeForme){ jouerSon(){ //Si la forme n’est pas //code pour //une amibe //jouer le son //utiliser typeForme //de l’amibe //pour chercher } //quel son WAV jouer //puis le jouer //sinon //jouer le son AIF //de l’amibe }En programmation objets on n’a pas besoin de modifier le code des autres formes (carr´, triangle, ecercle). On peut mˆme aller plus loin et cr´er une classe contenant les parties communes, puis des e esous-classes contenant les parties sp´cifiques. Si la classe Forme contient une fonctionnalit´ donn´e e e etoutes ses sous-classes en h´ritent automatiquement. La classe Triangle, par exemple, suit les edirectives de la classe forme, pour la classe Amibe on a modifi´ les parties de code n´cessaires. e e Forme Super−classe tourner(){. //code } jouerSon(){ //code } Héritage Carre Triangle Cercle Amibe Sous−classes int centreX; int centreY; tourner(){ //code de //l’amibe } jouerSon(){ //code de // l’amibe } Fig. 3.1 – Conception g´n´rale ` l’aide d’une hi´rarchie de classes. e e a e
    • 36 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION3.2 La notion de classe Les classes ne sont pas des objets, mais servent ` les construire. Elles sont des patrons ad’objets, indiquant ` la JVM comment produire un objet d’un type donn´. Chaque objet peut a eaffecter ses propres valeurs aux variables d’instances d´finies dans la classe ` partir de laquelle il e aa ´t´ cr´´. e e eeAnalogie : un objet peut ˆtre compar´ ` des fiches d’un carnet d’adresses, la classe correspond e eaa` la structure d’une fiche (nom, t´l´phone, adresse, . . .), les objets correspondent aux personnes eestock´es dans les fiches. e3.2.1 Exemple de classe :/** *Classe de d´finition d’un point dans le plan e */public class Point{ private int x; //abscisse private int y; //ordonn´e e public void initialise(int abs,int ord) { x=abs; y=ord; } public void deplace(int dx,int dy) { x+=dx; y+=dy; } public void affiche() { System.out.println("Je suis un point de coordonn´es "+x+" "+y); e }} De part la d´finition de cette classe Point, nous pouvons noter deux choses : e – 2 variables d’instances sont d´finies x et y. Le mot private indique que l’on ne peut avoir e acc`s ` ces variables qu’` l’int´rieur de la classe. (On appelle parfois ces variables champs e a a e ou attributs) – 3 m´thodes sont d´finies initialise, deplace et affiche. Le mot public indique que ces e e m´thodes sont utilisables depuis un programme quelconque. Ces 3 m´thodes ne poss`dent e e e pas de valeur de retour, dans ce cas on utilise le mot cl´ void dans la d´claration. Notons, e e de plus, que la m´thode initialise – par exemple – poss`de 2 arguments abs et ord, tous e e deux de type entier. (Note : il est possible d’avoir des m´thodes private dans une classe, e dans ce cas elles ne pourront ˆtre utilis´es que dans la classe) e e3.2.2 Cr´ation d’un objet ` l’aide d’une classe e a On d´clare un objet de type Point en d´finissant une variable de type Point de la mani`re e e esuivante :
    • 3.2. LA NOTION DE CLASSE 37Point a;ceci implique la cr´ation d’une r´f´rence de type Point nomm´e a, ` ce stade aucun objet n’a ´t´ e ee e a eecr´´. ee Pour cr´er un objet, il faut utiliser l’op´rateur new : e ePoint a = new Point(); ? x a ? yUn objet point a ´t´ cr´´, mais x et y n’ont pas re¸u de valeur, par d´faut ces variables sont initia- e e ee c elis´es ` z´ro. Ensuite on peut initialiser les valeurs de l’objet en utilisant la m´thode initialise : e a e ea.initialise(3,5); 3 x a 5 y3.2.3 Exemple d’utilisation dans un programme completpublic class TestPoint{ public static void main(String [] args) { Point a; Point b; a = new Point(); b = new Point(); a.initialise(3,5); a.affiche(); a.deplace(2,0); a.affiche(); b.initialise(6,8); b.affiche(); }}Si on l’ex´cute, ce programme produira le r´sultat suivant : e eJe suis un point de coordonn´es 3 5 eJe suis un point de coordonn´es 5 5 eJe suis un point de coordonn´es 6 8 eRemarques : Pour utiliser ce programme, il faut cr´er 2 classes, on enregistre la classe Point edans un fichier Point.java et la classe TestPoint dans un fichier TestPoint.java. En r`gle g´n´rale, on s´pare la fonction d’utilisation (c’est-`-dire le main) dans une classe ` e e e e a apart de mani`re ` faciliter la r´utilisation des classes d´j` construites. e a e ea Pour utiliser notre programme il faut : 1. compiler le fichier Point.java ; 2. compiler le fichier TestPoint.java, il ne sera possible d’utiliser le programme que si le fichier Point.class existe ; 3. lancer le programme TestPoint.
    • 38 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION Java impose au minimum que : – Un fichier source peut contenir une ou plusieurs classes, mais exactement une seule doit ˆtre e publique. – La classe contenant la m´thode main doit obligatoirement ˆtre publique. e e – Une classe n’ayant aucun attribut d’acc`s (public/private) est accessible ` toutes les classes e a du mˆme paquetage, et donc a fortiori du mˆme fichier source. (Nous verrons les paquetages e e plus tard).3.3 La notion de constructeur Un constructeur permet d’automatiser le m´canisme d’utilisation d’un objet en ´vitant d’ap- e epeler une m´thode sp´cifique (comme la m´thode initialise de la classe Point). Il sert ` cr´er e e e a el’objet et il est appel´ uniquement lors de la cr´ation de l’objet. e e Un constructeur est une m´thode sans valeur de retour, portant le mˆme nom que la e eclasse pouvant d´finir tout un tas d’actions utiles au bon fonctionnement d’un objet. Le construc- eteur peut disposer d’un nombre quelconque d’arguments.Exemplepublic class Point{ private int x; private int y; public Point(int abs,int ord) //constructeur { x=abs; y=ord; } public void deplace(int dx,int dy) { x+=dx; y+=dy; } public void affiche() { System.out.println("Je suis un point de coordonn´es "+x+" "+y); e }} Nous cr´ons ensuite un point via Point a = new Point(1,3); eVoici quelques lignes de code qui pourraient ˆtre mises dans une m´thode main pour tester le e eprogramme.Point a;Point b = new Point(6,8);a = new Point(3,5);a.affiche();a.deplace(2,0);a.affiche();b.affiche();
    • 3.3. LA NOTION DE CONSTRUCTEUR 39Attention : dans notre nouvelle classe, l’utilisation de a = new Point(); n’est plus possibleet provoque une erreur. Si l’on d´sire conserver un constructeur sans arguments, il faut ´crire 2 e econstructeurs. Lors de la construction d’un objet, il se passe, dans l’ordre : 1. initialisation par d´faut des champs de l’objet e 2. initialisation explicite des champs donn´e lors de leur d´claration e e 3. ex´cution du corps du constructeur. e Liste des initialisations par d´faut des champs d’un objet en fonction de leur type. Ces valeurs ecorrespondent en g´n´ral ` une valeur nulle : e e a – boolean → false – char → null – entier → 0 – flottant → 0.0 (ou 0.f) – objet quelconque → nullCas des champs d´clar´s avec l’attribut final. Ces champs ne doivent ˆtre d´clar´s qu’un e e e e eseule fois. Toute tentative de modification ult´rieure aboutira ` une erreur de compilation. Un e achamp final doit ˆtre initialis´ au plus tard par le constructeur. Il n’est pas permis de compter e esur l’initialisation par d´faut d’un tel champ. eExemple de programme r´capitulatif epublic class Init{ public static void main(String [] args) { A a = new A(); a.affiche(); }}class A{ private int np; //initialisation de type 1 private int n=20, p=10; //initialisation de type 2 public A() { np = np * p; //ou np=n*n: initialisation de type 3 n = 5; } public void affiche() { System.out.println("n="+n+", p="+p+", np="+np); }}Cependant, il est pr´f´rable d’effectuer les initialisations par le constructeur pour que l’utilisateur een’ait pas ` s’interroger sur l’ordre des diff´rentes op´rations. a e epublic A(){ n=20, p=10; np = n * p;
    • 40 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION n=5;}3.4 Affectation et comparaison d’objets Nous venons de voir qu’il existe des variables de type ”classe” (Point a;) destin´es ` contenir e ades r´f´rences sur des objets. Une r´f´rence est simplement une autre valeur de variable possible. ee eePour ces variables, les affectations portent sur les r´f´rences et non les objets. ee 3 x a 5 y Point a,b; 2 x b 0 y a = new Point(3,5); b = new Point(2,0);Exemple Si maintenant nous ajoutons : 3 x a 5 y 2 x b 0 y a = b; On recopie en fait dans a la r´f´rence de b, a et b d´signent alors le mˆme objet et non la ee e emˆme valeur. eSecond exemple :Point a,b,c;a = new Point(1,10);b = new Point(2,20);c = a;a = b;b = c;Il y a 2 objets et 3 variables de type Point. Le sch´ma suivant repr´sente le r´sultat final du code e e eci-dessous. 1 xa 10 yb 2 xc 20 y3.4.1 La r´f´rence null ee Si on effectue une d´claration sans initialisation, par exemple Point p;, par d´faut p est e einitialis´ ` null (rien). On ne peut pas avoir acc`s aux champs de l’objet ni utiliser ses m´thodes. ea e eDans ce cas, une erreur (exception) de type NullPointerException sera lev´e ` l’utilisation. e a
    • 3.5. LE RAMASSE-MIETTES 41 nullp On peut cependant tester la non nullit´ d’une r´f´rence a un objet. e ee `if(p!=null){ p.affiche();}3.5 Le ramasse-miettes Nous avons vu que grˆce ` l’op´rateur new, la JVM alloue un emplacement m´moire ` l’objet et a a e e al’initialise. Il n’existe pas de m´canisme de destruction d’objets. Il existe par contre un m´canisme e ede gestion automatique de la m´moire connu sous le nom de ramasse-miettes (en anglais garbage ecollector). Son principe est le suivant : – A tout instant, la JVM connaˆ le nombre de r´f´rences ` un objet donn´ (tout est g´r´ par ıt ee a e e e r´f´rences en Java). ee – Lorsqu’il n’existe plus aucune r´f´rence sur un objet, on est certain que le programme ne ee pourra plus y acc´der. Il est donc possible de lib´rer l’emplacement correspondant. Cepen- e e dant, pour des raisons d’efficacit´ ( ? ?), Java n’impose pas que ce soit fait imm´diatement. e e On dit que l’objet est candidat au ramasse-miettes.Note : La zone m´moire utilis´e pour allouer de l’espace ` de nouveaux objets s’appelle le tas. e e aTous les objets r´sident sur le tas. Avant qu’un objet ne soit candidat au ramasse-miettes, Java eappelle la m´thode finalize, qui est une m´thode permettant d’effectuer des op´rations lors de e e ela destruction de l’objet.3.6 L’encapsulation de donn´es e L’encapsulation de donn´es est une convention de manipulation des variables d’instances en eJava. Il est plus que fortement conseill´ de suivre cette d´marche, elle s’av`re mˆme obligatoire e e e epour l’´criture d’un code correct et lisible dans certaines structures. e En g´n´ral, une bonne programmation objet prot`ge les donn´es relatives ` un objet : les e e e e avariables d´finies dans une classe. Pour cela, on d´clare ces champs private, et on utilise des e em´thodes d´clar´es public pour y acc´der. e e e e Par exemple, pour la classe Point, on rajoutera les m´thodes suivantes epublic int getX(){return x;}public int getY(){return y;}public void setX(int abs){ x = abs;}public void setY(int ord){ y = ord;}public void setPosition(int abs, int ord){ x = abs;
    • 42 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION y = ord;} Suivant les cas, il peut-ˆtre pr´f´rable d’avoir une seule m´thode de changement de variables e ee elorsque que la modification d’une variable peut en affecter une autre.Autre exemple :public class BonChien{ private int taille; public BonChien() { taille = 20; } public int getTaille() { return taille; } public void setTaille(int t) { taille = t; } public void aboyer() { if(taille > 60) { System.out.println("Grr ! Grr !"); }else if(taille > 20){ System.out.println("Ouaf ! Ouaf !"); }else{ System.out.println("Kai ! Kai !"); } }}public class TestBonChien{ public static void main(String [] args) { BonChien un = new BonChien(); BonChien deux = new BonChien(); un.setTaille(70); deux.setTaille(8); System.out.println("Taille de un : "+un.getTaille()); un.aboyer(); System.out.println("Taille de deux : "+deux.getTaille()); deux.aboyer(); }}
    • ´3.7. CHAMPS ET METHODES STATIQUES 433.7 Champs et m´thodes statiques e En Java on peut d´finir des champs qui n’existent qu’en un seul exemplaire pour toutes les einstances de la classe, au lieu d’exister dans chacune des instances. Il s’agit en quelque sorte dedonn´es globales partag´es par toutes les instances d’une mˆme classe. On parle de champs e e e(ou variables) de classe ou de champs (ou variables) statiques, nous verrons plus tard qu’il existeaussi des m´thodes statiques. e3.7.1 Variables statiquesExemple classiqueclass A{ public int n; public float y; public A() { n = 3; y = 5.5; }} Chaque objet de type A poss`de ses propres champs n et y. Ils sont exceptionnellement public edans cet exemple, mais nous rappelons ici qu’il est imp´ratif de mettre ces champs private dans en’importe quel programme. Si on cr´e 2 objets, leur occupation en m´moire peut se repr´senter de la mani`re suivante : e e e e 3 a1.n a1 5.5 a1.y A a1 = new A(); 2 a2.n A a2 = new A(); a2 0.5 a2.y a2.n -= 1; a2.y -= 5.0;Avec un champ statiqueclass B{ public static int n = 2; public float y; public B() { y = 5.5; }}
    • 44 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION b1.n ou B.n 2 b2.n ou B.n B b1 = new B(); b1 5.5 0.5 b2 B b2 = new B(); b1.y b2.y b2.y -= 5.0; b1.n et b2.n d´signent le mˆme champ, il est cependant pr´f´rable de s’y r´f´rer par B.n. n e e ee eeest une variable statique de la classe B.Exemple :public class ExObjet{ private static long nb = 0; public ExObjet() { System.out.print("++ creation de l’objet ExObjet numero "+nb+" "); nb++; System.out.println("il y a maintenant "+nb+" objet(s)"); }}public class TestExObjet{ public static void main(String args []) { ExObjet a,b,c; System.out.println("Avant la creation de l’objet a"); a = new ExObjet(); System.out.println("Apr`s la e creation de l’objet a"); System.out.println("Avant la creation de l’objet b"); b = new ExObjet(); System.out.println("Apr`s la e creation de l’objet b"); c = new ExObjet(); System.out.println("Apr`s la e creation du dernier objet c"); }} R´sultat du programme eAvant la creation de l’objet a++ creation de l’objet ExObjet numero 0 il y a maintenant 1 objet(s)Apr`s la creation de l’objet a eAvant la creation de l’objet b++ creation de l’objet ExObjet numero 1 il y a maintenant 2 objet(s)Apr`s la creation de l’objet b e++ creation de l’objet ExObjet numero 2 il y a maintenant 3 objet(s)Apr`s la creation du dernier objet c eRemarque lorsque l’on compte le nombre d’objets, on ne prend pas en compte les ´ventuels eobjets d´truits par le ramasse-miettes (il faudrait utiliser la m´thode statique finalize). e e Les champs statiques peuvent ˆtre initialis´s avant l’appel ` un constructeur. Il peut mˆme e e a ene pas y avoir de constructeur, dans ce cas la seule initialisation possible est une initialisationexplicite lors de la d´claration. e
    • ´3.7. CHAMPS ET METHODES STATIQUES 453.7.2 Les m´thodes statiques e Les m´thodes statiques jouent un rˆle ind´pendant d’un objet quelconque. Elles peuvent ˆtre e o e eappel´s sans qu’un objet de la classe n’ait ´t´ cr´´. e e e eeExemplepublic class B2{ private float x; private static int n; public static void f() //m´thode de classe ou statique e { //ici on ne peut pas acc´der ` x, mais on peut acc´der ` n e a e a }}Exempleclass ExObjet2{ private static long nb = 0; public ExObjet2() { System.out.print("++ creation de l’objet ExObjet2 numero "+nb+" "); nb++; System.out.println("il y a maintenant "+nb+" objet"+pluriel()); } public static long getNb() { return nb; } public static String pluriel() { if(nb>1){ return "s"; } return ""; }}public class TestExObjet2{ public static void main(String [] args) { ExObjet2 a,b,c; System.out.println("Avant la creation de l’objet a, NB objet" +ExObjet2.pluriel() + ":" + ExObjet2.getNb()); a = new ExObjet2(); System.out.println("Apr`s la creation de l’objet a, NB objet" + eExObjet2.pluriel() + ":"+ExObjet2.getNb());
    • 46 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION System.out.println("Avant la creation de l’objet b, NB objet" +ExObjet2.pluriel() + ":"+ExObjet2.getNb()); b = new ExObjet2(); System.out.println("Apr`s la creation de l’objet b, NB objet" + eExObjet2.pluriel() + ":"+ExObjet2.getNb()); c = new ExObjet2(); System.out.println("Apr`s la creation du dernier objet c, NB objet" + eExObjet2.pluriel() + ":"+ExObjet2.getNb()); }} R´sultat du programme eAvant la creation de l’objet a, NB objet: 0++ creation de l’objet ExObjet numero 0 il y a maintenant 1 objetApr`s la creation de l’objet a, NB objet: 1 eAvant la creation de l’objet b, NB objet: 1++ creation de l’objet ExObjet numero 1 il y a maintenant 2 objetsApr`s la creation de l’objet b, NB objets: 2 e++ creation de l’objet ExObjet numero 2 il y a maintenant 3 objetsApr`s la creation du dernier objet c, NB objets: 3 e Les m´thodes statiques s’av`rent utiles e e – pour permettre aux objets de disposer d’informations ”collectives”, – fournir des services n’ayant une signification que pour la classe elle-mˆme (par exemple pour e l’identification d’une classe), – fonctionnalit´s n’´tant pas li´es ` un objet quelconque (par exemple la m´thode pluriel, e e e a e ou des m´thodes math´matiques comme le calcul d’un cosinus ou d’une racine carr´ avec la e e e classe Math).3.8 Surd´finition/surcharge de m´thodes e e On parle de surcharge lorsqu’un mˆme symbole poss`de plusieurs significations diff´rentes e e echoisies en fonction du contexte d’utilisation. Par exemple, l’op´rateur + peut, suivant les cas, ecorrespondre ` une somme d’entiers, de flottants ou une concat´nation de chaˆ a e ınes de caract`res. e Ceci s’applique ´galement en Java aux m´thodes. Plusieurs m´thodes peuvent porter le mˆme e e e enom pour peu que le nombre et le type de leurs arguments permettent au compilateur d’effectuerson choix.Exemple introductif : une classe Point avec 3 m´thodes deplace epublic class Point{ private int x,y; public Point(int abs, int ord) //constructeur { x = abs; y = ord; } public void deplace(int dx, int dy) { x += dx;
    • ´ ´3.8. SURDEFINITION/SURCHARGE DE METHODES 47 y += dy; } public void deplace(int dz) { x += dz; } public void deplace(short dz) { y += dz; }}public class TestSurdef{ public static void main(String [] args) { Point a = new Point(1,2); a.deplace(1,3); //appel de deplace(int ,int ) a.deplace(2); //appel de deplace(int) short p = 3; a.deplace(p); //appel de deplace(short) byte b = 2; a.deplace(b); //appel de deplace(short) }} Si jamais il y a une ambigu¨ e lors de l’appel, il y aura erreur de compilation. ıt´Remarques importantes : – Le type de la valeur de retour n’intervient pas dans le choix de la m´thode surcharg´e. e e – On peut surcharger des m´thodes statiques. e – L’attribut final n’a aucune influence sur le choix d’une m´thode surcharg´e. e e public void deplace (int dx) { ... } public void deplace (final int dx){ ... } //erreur de compilation !!!3.8.1 Surd´finition de constructeurs eExemplepublic class Point{ private int x,y; public Point() { x = 0; y = 0; } public Point(int a) { x = y = a;
    • 48 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION } public Point(int abs, int ord) { x = abs; y = ord; } public Point(Point a) { x = a.getX(); y = a.getY(); } public int getX() { return x; } public int getY() { return y; }} UtilisationPoint a = new Point(1,3);Point d = new Point(2);Point e = new Point(d);3.9 La copie d’objets L’affectation de variables d’un type objet quelconque se limite ` la recopie de r´f´rence et ne a eeprovoque pas la recopie de la valeur des objet. En g´n´ral pour copier efficacement un objet, on cr´e une m´thode sp´cifique. e e e e epublic class Point{ private int x,y; . . . public Point copie() { Point p = new Point(x,y); return p; }} UtilisationPoint a = new Point(1,2);Point b = a.copie();
    • ´ ´ ´3.10. AUTOREFERENCEMENT : LE MOT CLE THIS 49 Cette d´marche est utilisable tant que la classe concern´e ne comporte pas des variables qui e esont de type objet (par exemple lorsque dans une classe Point on a un champ qui est aussi unevariable de type Point). Il faut alors d´cider si la copie soit porter sur les objets r´f´renc´s ou e ee ejuste sur les r´f´rences. ee – Copie superficielle d’un objet : on copie la valeur de tous les champs, y compris ceux qui sont d’un type classe. – Copie profonde : on recopie la valeur des champs d’un type primitif, mais pour les champs de type classe on cr´e une nouvelle r´f´rence ` un nouvel objet de mˆme type et de mˆme e ee a e e valeur.Exemple : permutation des valeurs de 2 objetspublic class Point{ private int x,y; . . . public void permute(Point a) { Point c = new Point(0,0); c.setX(a.getX()); c.setY(a.getY()); a.setX(x); a.setY(y); x = c.getX(); y = c.getY(); }} 3 x a 5 y Point a = new Point(3,5); Point b = new Point(0,2); 2 x b 0 y 2 x 2 x a 0 y 0 y c a.permute(b) 3 x b 5 y A la fin de la m´thode permute, le point r´f´renc´ par c devient candidat au ramasse- e ee emiettes.3.10 Autor´f´rencement : le mot cl´ this ee e Il permet de faire r´f´rence ` l’instance de l’objet courant dans sa globalit´ au sein d’une ee a em´thode. e
    • 50 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATIONExemple : M´thode co¨ncide pour savoir si un point co¨ e ı ıncide avec un autre.public class Point{ private int x,y; . . . public boolean coincide(Point pt) { return ((pt.getX() == this.x) && (pt.getY() == this.y)); }}Autre exemple : Voici le constructeur classique que nous avons ´crit : epublic Point(int abs,int ord){ x = abs; y = ord;}Ce constructeur peut se r´-´crire de la mani`re suivante en utilisant un auto-r´f´rencement : ee e eepublic Point(int x,int y){ this.x = x; this.y = y;} Le mot cl´ this permet d’employer des noms d’arguments identiques ` des noms de champs e a(ce qui peut ´viter l’utilisation de nouveaux identificateurs). e Il est ´galement possible de s’en servir pour appeler un autre constructeur au sein de la mˆme e eclasse.public class Point{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; System.out.println("Constructeur avec 2 arguments "+x+" et "+y); } public Point() { this(0,0); //appel du constructeur precedent Point(0,0) System.out.println("Constructeur sans argument"); }}ATTENTION : l’appel de this(0,0) doit obligatoirement ˆtre la premi`re instruction e edu constructeur. Les instructions :
    • ´ ´3.11. REMARQUES SUR LA DEFINITION DE METHODES 51Point a = new Point(1,2);Point b = new Point();provoquent le r´sultat suivant : eConstructeur avec 2 arguments 1 et 2Constructeur avec 2 arguments 0 et 0Constructeur sans argument3.11 Remarques sur la d´finition de m´thodes e e3.11.1 M´thodes de type proc´dures et fonctions e e Si une m´thode ne fournit aucun r´sultat, le mot cl´ void figure dans son en-tˆte ` la place du e e e e atype de valeur de retour. Une telle m´thode sera appel´e une proc´dure. e e e Si une m´thode fournit un r´sultat, elle porte alors le nom de fonction. Le type de sa valeur e ede retour doit ˆtre indiqu´ dans son en-tˆte, l’instruction return doit ´galement ˆtre utilis´e pour e e e e e eretourner le r´sultat. eExemple : une m´thode distance qui calcule la distance du point par rapport ` l’origine (0, 0) e aque l’on pourrait ajouter ` la classe Point. apublic class Point{ private int x,y; . . . public double distance() { double d; d = Math.sqrt(x*x + y*y); return d; }}Utilisation de cette m´thode : ePoint a = new Point(2,5);double r;r = a.distance();System.out.println("La distance par rapport ` l’origine est de "+r); aIl est ´galement possible de ne pas utiliser la valeur de retour, dans ce cas on appelle juste la em´thode : ea.distance();3.11.2 Les arguments Ils figurent dans l’en-tˆte de la d´finition d’une m´thode et peuvent ˆtre utilis´s dans le corps e e e e ede la m´thode. e
    • 52 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATIONpublic void f(int arg1,int arg2,int arg3){ ...} On peut th´oriquement changer la valeur des arguments, mais c’est assez d´conseill´. e e evoid f(final int n,double x){ ... x = 2.5 //correct mais d´conseill´ e e} Il ´galement d´conseill´ de modifier la valeur des arguments comme le montre la m´thode e e e epr´c´dente. Dans le cas d’arguments de type primitif, les modifications ` l’int´rieur de la m´thode e e a e ene sont plus prises en compte ` la sortie de la m´thode. On conseille en g´n´ral de cr´er une a e e e evariable locale suppl´mentaire et de copier la valeur de l’argument dedans avant de l’utiliser. e Notez que dans la m´thode pr´c´dente, toute modification de la valeur de n provoque une e e eerreur de compilation.3.11.3 Les variables localesvoid f(int n){ float x; //variable locale ` f a float n; //INTERDIT en Java ...}void g(){ double x; //variable locale ` g, ind´pendante de la variable de f a e ...} L’emplacement m´moire d’une variable locale est allou´ au moment ou l’on entre dans la e em´thode, il est lib´r´ lorsque l’on en sort. e e eN.B. Les variables locales n’ont pas d’initialisation par d´faut. eIl est possible de cr´er des variables locales ` un bloc (par exemple dans une boucle for) qui ne e aseront valides que dans ce bloc.public void f(){ int i; ... for(i=0;i<5;i++) { int p; //p n’est connu que dans le bloc du for ... } ...}
    • 3.12. LES PAQUETAGES (PACKAGES) 533.11.4 La r´cursivit´ e e La r´cursivit´ de m´thodes peut prendre 2 formes : e e e – directe : une m´thode comporte dans sa d´finition au moins un appel ` elle-mˆme, e e a e – crois´e : l’appel d’une m´thode entraˆ l’appel d’une autre m´thode qui a son tour appelle e e ıne e la m´thode initiale. e La r´cursivit´ peut s’appliquer aussi bien aux m´thodes statiques qu’aux autres m´thodes. e e e eExemple : Calcul de la factorielle d’un nombre par une m´thode statique (pour n = 8 le r´sultat e eest 40320).public class Util{ public static long fact(long n) { if(n>1) return (fact(n-1) * n); return 1; //notez que si n<0 fact n’est en fait pas d´finie e }}public class TestFact{ public static void main(String [] args) { int n = Integer.parseInt(args[0]); System.out.println("La factorielle de "+ n +" est "+ Util.fact(n)); }}Note : A chaque appel de fact, il y a une allocation m´moire pour les variables locales, la valeur ede retour et l’argument. Chaque nouvel appel de fact entraˆ donc une telle allocation sans que ıneles emplacements pr´c´dents n’aient ´t´ lib´r´s (empilement d’espace m´moire). Ce n’est qu’` la e e ee e e e apremi`re instruction return qu’il y a un d´pilement des arguments. e e3.12 Les paquetages (packages) Une paquetage est un regroupement logique, sous un identificateur commun, d’un ensemble declasses. La notion de paquetage se rapproche de la notion de biblioth`que (ou librairie) que l’on etrouve dans d’autres langages. Elle facilite le d´veloppement et la cohabitation de logiciels. e3.12.1 Attribution d’une classe ` un paquetage a Un paquetage est caract´ris´ par un nom qui est soit un simple identificateur soit une suite e ed’identificateur s´par´s par des points. Exemple : e eMesClassesUtilitaires.MathematiquesUtilitaires.Tris L’utilisation du point . implique une hi´rarchie logique de package. Ainsi, dans l’exemple epr´c´dent, les packages Math´matiques et Tris sont en dessous du package Utilitaires. e e e
    • 54 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION Utilitaires Mathematiques Tris L’attribution ` un package se fait au niveau du fichier source. Toutes les classes d’un mˆme a efichier appartiendront toujours ` un mˆme package. On place en d´but de fichier une instruction a e ede la forme :package nompaquetage; La plupart des environnements imposent des contraintes quant ` la localisation des fichiers acorrespondant ` un package. En particulier un paquetage de nom X.Y.Z se trouvera toujours adans un sous-r´pertoire de nom X.Y.Z (les r´pertoires de niveau hi´rarchique sup´rieur peuvent e e e eˆtre quelconques). Deux paquetages X.Y.Z et X.Y.U n’ont pas l’obligation d’ˆtre dans le mˆmee e er´pertoire. e Avec le JDK (ou SDK) de Sun la recherche d’un package se fait dans les r´pertoires indiqu´s e edans la variable d’environnement CLASSPATH. S’il n’y a pas de paquetage indiqu´ dans un fichier source, le compilateur consid`re que ceux-ci e eappartiennent au paquetage par d´faut. e Si l’on ne souhaite pas utiliser la variable d’environnement CLASSPATH, il est possible de sp´cifier eles chemins o` se trouvent les paquetages ` l’aide de l’option -classpath des commandes java et u ajavac. Par exemple si une classe Toto utilise des packages ou des classes situ´es dans les r´pertoires e e~/MesPackages et /usr/local/packages standard, on utilisera les commandes suivantes :javac -classpath ~/MesPackages;/usr/local/packages_standard Toto.javajava -classpath ~/MesPackages;/usr/local/packages_standard Toto Ceci implique si le package affaires de toto est utilis´, le dossier contenant les ´l´ments de e eece package doit ˆtre situ´ soit dans ~/MesPackages/affaires_de_toto ou dans e e/usr/local/packages standard/affaires de toto ; ´videmment une seule des 2 solutions est evalable.3.12.2 Utilisation d’une classe situ´e dans une paquetage e Il faut : – citer le nom du paquetage avec le nom de la classe, – utiliser une instruction import en indiquant soit une classe particuli`re d’un paquetage, soit e un paquetage entier.Avec une citation de nom de classe. Si vous avez attribu´ la classe Point au package eMesClasses, vous pouvez l’utiliser en la nommant MesClasses.Point, exemple :MesClasses.Point p = new MesClasses.Point(2,5);...p.affiche(); //le nom de la classe n’est plus requis iciEn important une classe avec l’instruction importimport MesClasses.Point, MesClasses.Cercle; Il est ensuite possible d’utiliser les classes Point et Cercle sans avoir ` mentionner leurs noms. a
    • 3.13. LES TABLEAUX 55En important un package en entier.import MesClasses.*;Toutes les classes du package MesClasses et les classes des packages hi´rarchiquement en dessous esont alors directement utilisables. Notez que si vous tapez uniquement import MesClasses ; lesclasses du package MesClasses seront directement utilisables, mais pas les packages contenus dansMesClasses. Il existe plusieurs paquetages standard fournis avec Java, par exemple le package Math ouencore le package java.lang qui est automatiquement ajout´ par le compilateur. e3.12.3 Droits d’acc`s e – Avec le mot cl´ public, une classe est accessible ` partir de toutes les autres classes e a (´ventuellement via une instruction import). e – Sans le mot cl´ public, une classe n’est accessible qu’aux classes du mˆme paquetage. Tant e e que l’on travaille avec le paquetage par d´faut, l’absence du mot public n’a gu`re d’impor- e e tance.Note : le mot cl´ private n’a pas de sens au niveau d’une classe. e3.13 Les tableaux En programmation, un tableau d´signe un ensemble d’´l´ments de mˆme type identifi´s par e ee e eun nom unique. Chacun des ´l´ments ´tant ensuite rep´r´ par un indice pr´cisant sa position au ee e e e esein de l’exemple. En Java, les tableaux sont consid´r´s comme des objets, les tableaux ` plusieurs indices s’ob- e e atiennent par composition de tableaux.3.13.1 D´claration et cr´ation e e Imaginons que nous voulions cr´er un tableau d’entiers, deux d´clarations sont possibles : e eint t[];int []t; La diff´rence entre les 2 d´clarations a une importance lorsque l’on souhaite d´clarer plusieurs e e etableaux :int [] t1,t2; //d´claration de 2 tableaux d’entiers eint t1[], t2[]; //meme choseint t1[], n, t2[]; //2 tableaux t1 et t2, n est un entierPoint a, tp[], b; //a et b sont de type Point, tp est un tableau // d’objets PointN.B. : une d´claration de tableau ne doit pas pr´ciser de dimension. e e Pour cr´er un tableau on utilise l’op´rateur new comme pour des objets classiques. Voici un e eexemple montrant comment cr´er un tableau de 10 entiers : eint t[] = new int[10]; Il est ´galement possible de fournir une liste d’expression entre accolades. Voici un exemple de ecr´ation d’un tableau d’entiers ` 5 ´l´ments. e a eeint t[] = {1, 2, 7, 10, 0};
    • 56 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATIONL’instruction pr´c´dente ´quivaut aux instructions suivantes : e e eint [] t = new int[5];t[0] = 1;t[1] = 2;t[2] = 7;t[3] = 10;t[4] = 0;Attention. Une fois un tableau cr´´, on ne peut plus modifier sa taille. Par contre, on peut cr´er ee eun nouveau tableau et - si besoin - recopier les valeurs du tableau initial. La taille d’un tableauest toujours positive.La taille d’un tableau Il est possible d’avoir acc`s ` la taille d’un tableau ` l’aide du champ e a alength.int t[] = new int[6];System.out.println("taille de t "+t.length); //affiche 6t = new int[2];System.out.println("taille de t "+t.length); //affiche 2Ici length est vu comme un champ et non comme une m´thode. eAcc`s aux ´l´ments d’un tableau Un ´l´ment est d´sign´ en pla¸ant entre crochets sa position e ee ee e e capr`s le nom du tableau. Une position est d´sign´e par une expression enti`re comprise entre 0 (le e e e epremier ´l´ment du tableau) et la taille du tableau-1 (dernier ´l´ment du tableau). ee eeExemple : calcul d’une moyenne de notespublic class TestCalculMoyenne{ public static void main(String [] args) { int i, nbNotes, nbSupMoy; double somme, moyenne, notes[]; if(args.length == 0) { System.exit(0); } notes = new double[args.length]; nbNotes = args.length; for(i=0; i< nbNotes; i++) { notes[i] = Double.parseDouble(args[i]); } somme=0.0; for(i=0; i< nbNotes; i++) somme += notes[i] ; moyenne = somme / (double) nbNotes;
    • 3.13. LES TABLEAUX 57 System.out.println("Moyenne des notes :"+moyenne); for(i=0, nbSupMoy=0; i < nbNotes; i++) { if(notes[i] > moyenne) nbSupMoy++; } System.out.println(nbSupMoy + " notes sont sup´rieures ` cette moyenne"); e a }}Affectation de tableaux. Exemple.int [] t1 = new int[3];for(int i=0; i<t1.length; i++) t1[i] = i;int [] t2 = new int[2];for(int i=0; i<t2.length; i++) t2[i] = 10+ i;La situation peut-ˆtre sch´matis´e comme ceci : e e e 0 t1 1 2 10 t2 11 Si maintenant on ex´cute : et1 = t2; //la r´f´rence contenue dans t2 est recopi´e dans t1 e e eNous aboutissons alors ` cette situation : a 0 t1 1 2 10 t2 11 Maintenant si l’on ex´cute les instructions suivantes : et1[1] = 5;System.out.println(t2[1]); //affiche 5 !!! L’ancien objet r´f´renc´ par t1 devient candidat au ramasse-miettes. Lors de l’affectation de ee er´f´rences de tableau, il n’y a aucune recopie des valeurs des ´l´ments du tableau. ee ee
    • 58 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATIONExemple de tableau d’objetspublic class Point{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; } public void affiche() { System.out.println("Point : "+x+", "+y); }}public class TabPoint{ public static void main(String [] args) { Point [] tp; tp = new Point[3]; tp[0] = new Point(1,2); tp[1] = new Point(4,5); tp[2] = new Point(8,9); for(int i=0; i<tp.length; i++) tp[i].affiche(); }}R´sultat : ePoint : 1, 2Point : 4, 5Point : 8, 93.13.2 Tableau en argument ou en retour Lorsque l’on transmet un nom de tableau en argument d’une m´thode, on transmet en fait une ecopie de la r´f´rence au tableau. La m´thode agit directement sur le tableau concern´ et non sur ee e eune copie. Voici un exemple de manipulations de tableau par des m´thodes statiques. eclass Util{ static void raz(int t[]) { for(int i=0; i<t.length; i++) t[i] = 0; } static void affiche (int t[]) {
    • 3.13. LES TABLEAUX 59 for(int i=0; i<t.length; i++) System.out.print(t[i] + " "); System.out.println(); }}public class TabArg{ public static void main(String [] args) { int t[] = {1, 3, 5, 7}; System.out.print("t avant : "); Util.affiche(t); Util.raz(t); System.out.print("t apres : "); Util.affiche(t); }}R´sultat. et avant: 1 3 5 7t apres 0 0 0 0 La mˆme chose s’applique ` un tableau fourni en valeur de retour. Par exemple, la m´thode e a esuivante fourni un tableau form´ des n premiers entiers : epublic static int[] suite(int n){ int [] res = new int[n]; for(int i=0; i<t.length; i++) res[i]=i+1; return res;} Un appel ` suite fournira une r´f´rence ` un tableau dont on pourra ´ventuellement modifier a ee a ela valeur des ´l´ments. ee3.13.3 Les tableaux ` plusieurs indices a De nombreux langages disposent de la notion de tableau ` plusieurs indices. Par exemple, un atableau ` deux indices permet de repr´senter une matrice math´matique. a e e Java ne dispose pas d’une telle notion. N´anmoins, il permet de la simuler en cr´ant des e etableaux de tableaux dont les ´l´ments sont eux-mˆmes des tableaux. Cette possibilit´ s’av`re en ee e e efait tr`s riche puisqu’elle peut permettre de cr´er des tableaux irr´guliers (par exemple lorsque les e e ediff´rentes lignes ont un nombre de colonnes qui varie). ePremier exemple. Ces trois d´clarations sont ´quivalentes pour un tableau ` 2 dimensions : e e aint t [] [];int [] t [];int [] [] t;Elles d´clarent une r´f´rence ` un tableau, dans lequel chaque ´l´ment est lui-mˆme une r´f´rence e ee a ee e eea` un tableau d’entiers. Notez que pour l’instant aucun tableau n’existe encore. Consid´rons la d´claration : e e
    • 60 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATIONint t [] [] = { new int [3], new int [2] };t comporte deux ´l´ments de sorte que le premier soit un tableau de 3 entiers et que le deuxi`me ee esoit un tableau de 2 entiers. On aboutit ` la situation suivante (les ´l´ments des tableaux d’entiers a eesont comme d’habitude initialis´s ` 0) : e a 0 0 0 t 0 0 On constate alors que : – la notation t[0] d´signe la r´f´rence au premier tableau de 3 entiers, e ee – la notation t[0][1] d´signe le deuxi`me ´l´ment de ce tableau (pour rappel les indices e e ee commencent ` 0), a – la notation t[1] d´signe la r´f´rence au deuxi`me tableau de 2 entiers, e ee e – la notation t[0][i-1] d´signe le i`me ´l´ment de ce tableau pour i compris entre 1 et 2, e e ee – l’expression t.length vaut 2, – l’expression t[0].length vaut 3, – l’expression t[1].length vaut 2.Second exemple.int t [] [];t = new int [2] [];int [] t1 = new int[3];int [] t2 = new int[2];t[0] = t1;t[1] = t2; La situation peut s’illustrer comme ceci : t1 0 0 0 t 0 0 t2Troisi`me exemple. eclass Util{ static void raz(int t[] []) { int i,j;
    • 3.13. LES TABLEAUX 61 for(i=0;i<t.length;i++) for(j=0;j<t[i].length;j++) t[i][j]=0; } static void affiche(int t[] []) { int i,j; for(i=0;i<t.length;i++) { System.out.println("ligne de rang "+i+" = "); for(j=0;j<t[i].length;j++) System.out.println(t[i][j] + " "); System.out.println(); } }}public class TestTab2{ public static void main(String arg[]) { int t [][] = {{1,2,3}, {11, 12}, {21, 22, 23, 24} } System.out.println("t avant raz :"); Util.affiche(t); Util.raz(t); System.out.println("t apres raz :"); Util.affiche(t); }}R´sultat. et avant razligne de rang 0= 1 2 3ligne de rang 1= 11 12ligne de rang 2= 21 22 23 24t apres razligne de rang 0= 0 0 0ligne de rang 1= 0 0ligne de rang 2= 0 0 0 0Cas des tableaux r´guliers. Si on souhaite cr´er une matrice de N L lignes et N C colonnes e eon peut toujours proc´der comme ceci : eint t[][] = new int [NL] [];int i;for(i=0; i<NL; i++) t[i] = new int [NC]; On peut ´galement ´crire en Java : e eint t[][] = new int [NL] [NC];
    • 62 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION3.14 Exercices de cours3.14.1 Compilateur Voici le contenu de deux fichiers JAVA, indiquez pour chacun d’eux si ces fichiers peuventse compiler ou dans le cas contraire indiquez comment les corriger. Dites finalement ce que fontchacun de ces programmes. 1. Premier fichier : class TapeDeck { private boolean canRecord = false; void playTape() { System.out.println("lecture de la bande"); } void recordTape() { System.out.println("enregistrement de la bande"); } public boolean getCanRecord() { return canRecord; } public void setCanRecord(boolean canRecord) { this.canRecord=canRecord; } } public class TapeDeckTestDrive{ public static void main(String [] args) { t.setCanRecord(true); t.playTape(); if(t.getCanRecord()==true){ t.recordTape(); } } } 2. Deuxi`me Fichier : e class DVDPlayer{ private boolean canRecord=false; void recordDVD() { System.out.println("enregistrement du DVD"); }
    • 3.14. EXERCICES DE COURS 63 public boolean getCanRecord() { return canRecord; } public void setCanRecord(boolean canRecord) { this.canRecord=canRecord; } } public class DVDPlayerTestDrive{ public static void main(String [] args){ DVDPlayer d = new DVDPlayer(); d.setCanRecord(true); d.playDVD(); if(d.getCanRecord() == true){ d.recordDVD(); } } }R´ponses : e 1. Le fichier ne compile pas, il manque la cr´ation d’une instance TapeDeck, il faut donc cr´er e e un objet. Pour cela il faut rajouter juste apr`s la d´claration de la m´thode main, et avant e e e la ligne t.setCanRecord(true); la ligne TapeDeck t = new TapeDeck(); 2. Le fichier ne compile pas, il manque la m´thode playDVD() dans la classe DVDPlayer, on e pourra par exemple rajouter les lignes suivantes juste avant la fin de la classe : void playDVD() { System.out.println("lecture du DVD"); }Remarque importante : pour simplifier l’exercice et pouvoir le faire d`s le d´but, il n’y a pas e ede droits d’acc`s indiqu´s pour les variables d’instances, elles sont donc publiques par d´faut. Ceci e e en’est pas une bonne pratique : il vaut mieux d´clarer les variables priv´es et utiliser l’encapsula- e etion. A vous donc d’am´liorer la correction de l’exercice ! e3.14.2 Qui suis-je ? Associer ` chaque ligne ci-dessous un ou plusieurs mots parmi : Classe, M´thode, Objet, a eVariable d’instance. 1. Je r´sulte de la compilation d’un fichier .java : classe e 2. Mes variables d’instances peuvent ˆtre diff´rentes de celles de mes copains : objet e e 3. Je me comporte comme un patron : classe 4. J’aime faire des choses : objet, m´thode e 5. Je peux avoir plusieurs m´thodes : classe, objet e 6. Je repr´sente un “´tat” : variable d’instance e e 7. J’ai des comportements : objet, classe 8. On me trouve dans des objets : m´thode, variable d’instance e 9. Je r´side sur le tas : objet e
    • 64 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION 10. Je sers ` cr´er des instances d’objets : classe a e 11. Mon ´tat peut changer : objet e 12. Je d´clare des m´thodes : classe e e 13. Je peux changer lors de l’ex´cution : objet, variable d’instance eNote : classes et objets ont tous deux un ´tat et un comportement. Ils sont d´finis dans la classe e emais on dit aussi que c’est l’objet qui les “poss`de”. e3.14.3 Compilateur 2 Voici trois programmes, indiquez si ces programmes compilent ; si la r´ponse est oui dites ce equ’ils font, sinon comment les corrigez vous ? 1. public class XCopie{ public static void main(String [] args) { int orig = 42; XCopie x = new XCopie(); int y = x.go(orig); System.out.println(orig + " " + y); } int go(int arg) { arg = arg * 2; return arg; } } 2. class Horloge{ private String heure; void setHeure(String t){ heure = t; } void getHeure(){ return heure; } } public class TesteHorloge{ public static void main(String [] args) { Horloge c = new Horloge(); c.setHeure("1245"); String h = c.getHeure(); System.out.println("heure: " + h); } } 3. Ce programme compile, mais que fait-il ? class Resultat{ public static void main(String []args){ Resultat r = new Resultat(); r.go();
    • 3.14. EXERCICES DE COURS 65 } void go(){ int y=7; for(int x=1; x < 8 ; x++){ y++; if(x > 4){ ++y; System.out.print(y+" "); } if(y > 14) { System.out.println(" x = " + x); break; } } } }R´ponses : e 1. La classe compile et s’ex´cute, le r´sultat est 42 84 e e 2. Le fichier ne compile pas, il manque le type de retour String pour la m´thode getHeure. e 3. java Resultat 13 15 x = 63.14.4 Qui suis-je ? Associer ` chaque ligne ci-dessous un ou plusieurs mots parmi : variable d’instance, argu- ament, retour, m´thode get, m´thode set, encapsulation, public, private, passage par e evaleur, m´thode. e 1. Une classe peut en avoir un nombre quelconque : variables d’instances, m´thode, m´thode e e set, m´thode get e 2. Une m´thode ne peut en avoir qu’un : retour e 3. Peut ˆtre converti implicitement : retour, arguments e 4. Je pr´f`re mes variables d’instances private : encapsulation ee 5. Signifie r´ellement “faire une copie” : transmettre par valeur e 6. Seules les m´thodes set devraient les modifier : variables d’instance e 7. Une m´thode peut en avoir plusieurs : arguments e 8. Je retourne quelque chose par d´finition : m´thode get e e 9. Ne m’utilisez pas avec des variables d’instance : public 10. Je peux avoir plusieurs arguments : m´thode e 11. Par d´finition, j’accepte un seul argument : m´thode set e e 12. Ils aident ` cr´er l’encapsulation : m´thode get, m´thode set, public, private a e e e 13. Je vole toujours en solo : retour3.14.5 Compilateur 3 Voici deux programmes, indiquez si ces programmes compilent ; si la r´ponse est oui dites ce equ’ils font, sinon comment les corrigez vous ? (Pour des raisons de simplicit´, l’encapsulation des edonn´es a ´t´ omise dans cet exercice, nous rappelons cependant que cet aspect est primordial en e eeprogrammation objet)
    • 66 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION 1. class Livres{ private String titre; private String auteur; public String getTitre() { return titre; } public void setTitre(String titre) { this.titre=titre; } public String getAuteur() { return auteur; } public void setAuteur(String auteur) { this.auteur=auteur; } } class TestLivres{ public static void main(String [] args) { Livres [] mesLivres = new Livres[3]; int x=0; mesLivres[0].setTitre("Panique ` Java"); a mesLivres[1].setTitre("Java et moi"); mesLivres[2].setTitre("Cuisinez en Java"); mesLivres[0].setAuteur("Monique"); mesLivres[1].setAuteur("Michel"); mesLivres[2].setAuteur("Sophie"); while(x<3) { System.out.print(mesLivres[x].getTitre()); System.out.print("par"); System.out.print(mesLivres[x].getAuteur()); x=x+1; } } } 2. class Hobbits{ private String nom; public String getNom() { return nom;
    • 3.14. EXERCICES DE COURS 67 } public void setNom(String nom) { this.nom=nom; } public static void main(String [] args) { Hobbits [] h = new Hobbits[3]; int z = -1; while(z < 2) { z=z+1; h[z]= new Hobbits(); h[z].setNom("bilbo"); if(z==1){ h[z].setNom("frodon"); } if( z == 2) { h[z].setNom("sam"); } System.out.print(h[z].getNom() + " est un "); System.out.println("bon nom de Hobbit "); } } }R´ponses : e 1. Il manque la cr´ation des objets livres, juste apr`s int x=0; il faut rajouter e e mesLivres[0] = new Livres(); mesLivres[1] = new Livres(); mesLivres[2] = new Livres(); 2. Cette classe compile et fonctionne, nous rappelons que les indices de tableaux commencent a e ` z´ro.
    • 68 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION3.14.6 Mots crois´s e 1 2 3 I M P L E M E N T E R M R E 4 5 E X T R E M E I N T 6 7 X S R E T U R N H 8 9 P S E U D O C O D E I O R E T T D 10 11 12 E I C A S T J V M I E S T R A A 13 14 15 S E L E M E N T V A R I A B L E I R M A R I 16 O A E J A V A . L A N G S N T N I U E 17 I N T E G E R O M R 18 O G E 19 20 21 22 R A N D O M B O O L E E N B 23 A T T F Y 24 25 V I R T U E L L E S S H O R T 26 A P I H R E HORIZONTALEMENT VERTICALEMENT 1 Mettre en oeuvre (-) 2 Type d’incr´mentation (-) e 4 Teste d’abord (-) 3 Elle fait le travail (-) 5 32 bits (-) 4 Sp´cifie l’action dans un for (-) e 7 R´ponse d’une m´thode (-) e e 5 Fixe la valeur de d´part (-) e 8 Avant le vrai code (-) 6 M´thode qui modifie (-) e 11 Changement de type (-) 9 Contraire d’incr´ment (-) e 12 Executrice (-) 10 R´p´tition (-) e e 13 Fait partie d’un tableau (-) 12 Package pour les E/S (-) 14 Peut ˆtre locale (-) e 15 Faits pour ˆtre transmis (-) e 16 Package contenant les classes essentielles (-) 18 M´thode qui acc`de (-) e e 17 A une m´thode parseInt (-) e 20 Classe qui calcule (-) 19 Pour g´n´rer des nombres au hasard (-) e e 22 Plus petit qu’un short (-) 21 Impossible ` convertir (-) a 23 Type de boucle (-) 24 Certaines r´alit´s le sont (-) e e 24 Editeur pr´f´r´ des puristes (-) ee e 25 Plus petit qu’un int (-) 26 Interface de d´veloppement d’applications e (-)
    • 3.14. EXERCICES DE COURS 693.14.7 Mots crois´s eCertains mots sont introduits dans la section 8.3.2 sur les ArrayList. 1 2 3 4 P R I M I T I F S 5 D E N I 6 7 O B J E C T D Z E R O U H E E 8 9 B P O X I 10 11 12 13 L A D D C O N T A I N S 14 S E T C E F Y N E 15 K V P D M 16 A R R A Y L I S T E I P 17 P G R L C T 18 I L E N G T H I E Y 19 U S G 20 21 22 V A R I A B L E T E L S E 23 E L E M E N T HORIZONTALEMENT VERTICALEMENT 1 Ils n’ont pas de comportement (-) 2 Impl´mente un comportement (-) e 6 Tous les objets en d´rivent (-) e 3 Retourne une position (-) 7 Premier indice (-) 4 Retourne un nombre d’´l´ments (-) ee 10 Ajoute un objet (-) 5 Grand d´cimal (-) e 11 Loup y es-tu ? (-) 8 Groupe de classes (-) 14 Mutateur (-) 9 Pour savoir si une liste est vide (-) 16 Croˆ dynamiquement (-) ıt 12 Sorte (-) 18 Homologue de 4 (vertical) (-) 13 Position d’un ´l´ment (-) ee 20 Inconstante (-) 15 Pas r´el (-) e 22 Sinon (-) 16 Acronyme de la biblioth`que (-) e 23 Unit´ adressable (-) e 17 Commun aux courses et aux tableaux (-) 19 R´cup`re une valeur (-) e e 21 Article (rien ` voir avec Java) (-) a
    • 70 ´ CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION
    • Chapitre 4Les concepts d’H´ritage et de ePolymorphisme4.1 Pr´sentation et d´finition e e L’h´ritage permet de sp´cifier une classe g´n´rale donn´e en sous-classe. e e e e ePremier exemple. Voici une premi`re hi´rarchie de classe. e e Medecin Super classe travailleALHopital traiterPatient() MedecinDeFamille Chirurgien Sous classes faitDesVisites traiterPatient() donnerConseil() faireUneIncision() En Java, cette hi´rarchie s’´crira comme ceci : e epublic class Medecin{ private boolean travailleALHopital; void traiterPatient() { //traiter le patient } ...}public class MedecinDeFamille extends Medecin{ private boolean faitDesVisites; void donnerConseil() { //donner un simple conseil 71
    • 72 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME } ...}public class Chirurgien extends Medecin{ void traiterPatient() { //traitement d’un chirurgien } void faireUneIncision() { //action sp´cifique du chirurgien e } ...}Autre exemple : retour ` la classe Point. apublic class Point{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; } public Point() { this(0,0); } public void deplace(int dx,int dy) { x += dx; y += dy; } public void modifie(int x,int y) { this.x = x; this.y = y; } public void affiche() { System.out.println("Je suis en "+x+" "+y); }} Imaginons que nous ayons besoin de manipuler des points color´s de mani`re ` : e e a
    • ´ ´4.1. PRESENTATION ET DEFINITION 73 – garder les mˆme fonctionnalit´s de Point, e e – ajouter le traitement d’une couleur, – red´finir l’affichage d’un point avec sa couleur. epublic class PointCouleur extends Point{ private byte couleur; public void colorie(byte couleur) { this.couleur = couleur; } public void modifie(int x,int y,byte couleur) { super.modifie(x,y); this.couleur = couleur; } public void afficheCouleur() { super.affiche(); System.out.println(" de couleur" + couleur); }}PointCouleur est un Point, Point est la classe de base ou superclasse, PointCouleur est la sous-classe ou classe d´riv´e. Un objet de type PointCouleur peut alors faire appel aux m´thodes e e epubliques de PointCouleur et aux m´thodes publiques de Point. e Un objet d’une classe d´riv´e peut acc´der directement aux membres public de sa classe de e e ebase, mais pas aux membres priv´s. eA retenir : – Une classe d´riv´e n’acc`de pas aux membres priv´s (champs et m´thodes) de sa su- e e e e e perclasse. Par exemple, les points x et y ne sont pas accessibles directement de la classe PointCouleur. – Une classe d´riv´e a acc`s aux membres publiques de sa superclasse. Pour acc´der ` une e e e e a m´thode public de la superclasse on utilise le mot cl´ super. e e – Un objet d’une classe d´riv´e acc`de aux membres publics de sa classe de base exactement e e e comme s’ils ´taient d´finis directement dans la classe d´riv´e elle-mˆme. e e e e eExemple d’utilisation des 2 classes pr´c´dentes. e ePointCouleur pc1 = new PointCouleur();pc1.modifie(3,5);pc1.colorie((byte) 3);pc1.affiche();pc1.afficheCouleur();PointCouleur pc2 = new PointCouleur();pc2.modifie(5,8,(byte)2);pc2.afficheCouleur();pc2.deplace(1,-3);pc2.afficheCouleur(); Ces lignes de code provoquent le r´sultat suivant : e
    • 74 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISMEJe suis en 3 5Je suis en 3 5 de couleur 3Je suis en 5 8 de couleur 2Je suis en 6 5 de couleur 24.2 Construction et initialisation des objets d´riv´s e e Quand il n’y a pas de constructeur, un pseudo-constructeur par d´faut est appel´, nous nous e eint´ressons maintenant au constructeur de la classe d´riv´e. e e e En Java, le constructeur de la classe d´riv´e doit prendre en charge l’int´gralit´ de la construc- e e e etion de l’objet. Pour l’initialiser certains champs private de la classe de base, on peut soit utiliserdes m´thodes de modifications publiques, soit appeler le constructeur de la super-classe. eAttention. Si un constructeur d’une classe d´riv´e appelle un constructeur d’une classe de base, e eil doit obligatoirement s’agir de la premi`re instruction du constructeur (mˆme principe que pour e el’utilisation du this). La r´f´rence ` un constructeur est d´sign´e par super. ee a e epublic class Point{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; } ...}public class PointCouleur extends Point{ public PointCouleur(int x,int y,byte couleur) { super(x,y); //appel du constructeur de la classe Point this.couleur = couleur; } ...}Attention. – Les mots cl´s this et super ne peuvent pas ˆtre utilis´s en mˆme temps. e e e e – Lorsqu’une classe d´rive d’une classe qui d´rive elle aussi d’une autre classe, l’appel par super e e ne concerne que le constructeur de la classe de base de niveau imm´diatement sup´rieur. e e
    • ´ ´4.2. CONSTRUCTION ET INITIALISATION DES OBJETS DERIVES 75 super()Remarques importantes sur la d´finition d’un constructeur. e – Si la super-classe ne poss`de pas de constructeur, il est possible d’appeler le constructeur e par d´faut ` partir de la classe d´riv´e via super();. Cet appel peut paraˆ superflu, mais e a e e ıtre ne nuit pas. Ceci est pratique lorsque l’on construit une classe d´riv´e sans connaˆ e e ıtre les d´tails de la classe de base : on s’assure que les diff´rents ´l´ments de la super-classe seront e e ee correctement initialis´s. Ceci justifie ´galement le principe de toujours mettre un constructeur e e par d´faut sans argument dans une classe. e – Si la classe d´riv´e ne poss`de pas de constructeur, le constructeur par d´faut de la classe sera e e e e appel´e et par cons´quent le constructeur par d´faut de la super-classe. Si ce constructeur e e e n’existe pas (s’il y a que des constructeurs avec arguments qui sont d´finis), il y a une erreur e de compilation. Par exemple ; class A { public A(int n) { ... } ... } class B extends A { // pas de constructeur } Cet exemple provoque une erreur car il n’y a pas de constructeur sans argument dans A. La construction d’un objet B d´riv´ d’un objet A entraˆ 6 ´tapes : e e ıne e 1. Allocation m´moire pour un objet de type B (y compris les champs d´finis dans la super-classe e e A). 2. Initialisation par d´faut de tous les champs de B (aussi bien ceux h´rit´s de A que ceux d´finis e e e e dans B) aux valeurs nulles classiques. 3. Initialisation explicite des champs h´rit´s de A. e e 4. Ex´cution du corps du constructeur de A. e 5. Initialisation explicite des champs propres ` B. a 6. Ex´cution du constructeur de B. eNotez ´galement qu’il est possible d’avoir plusieurs d´rivations successives : e e
    • 76 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME A B C D E F G4.3 Red´finition, surd´finition et h´ritage e e e4.3.1 Red´finition e La red´finition consiste ` re-´crire une m´thode d´finit dans la super-classe et ` changer son e a e e e acomportement. Le nombre et le type des arguments ainsi que la valeur de retour doivent ˆtreeexactement les mˆmes. epublic class Point{ private int x,y; ... public void affiche() { System.out.println("Je suis un point de coordonn´es "+x+" "+y); e }}public class PointCouleur extends Point{ private byte couleur; ... public void affiche() { super.affiche(); System.out.println(" de couleur "+couleur); }} Lorsque l’on utilise la m´thode affiche d’un objet de type PointCouleur, la m´thode d´finie e e edans la classe PointCouleur est appliqu´e, sinon pour un objet de type Point uniquement c’est ela m´thode d´finie dans la classe Point. e e Imaginons que nous ayons une hi´rarchie de classe avec plusieurs d´rivations successives. Dans e ela classe la plus “´lev´e” une m´thode f et d´finie et cette m´thode est red´finie dans certaines de e e e e e eses sous-classes.
    • 4.4. LE POLYMORPHISME 77 A définition de f B redéfinition de f C redéfinition de f D E F Voici la liste des m´thodes f qui seront appel´es en fonction du type de l’objet consid´r´ : e e e e – pour A, la m´thodes f de A, e – pour B, la m´thodes f de A, e – pour C, la m´thodes f de C, e – pour D, la m´thodes f de D, e – pour E, la m´thodes f de A, e – pour F, la m´thodes f de C. eAttention. Les droits d’acc`s des m´thodes red´finies ne doivent pas ˆtre diminu´s : une m´thode e e e e e epublique dans la super-classe ne peut pas ˆtre red´finie priv´e dans la classe d´riv´e, l’inverse est e e e e ecependant possible.4.3.2 La surchage La surcharge ou surd´finition consiste ` modifier le prototype d’une m´thode existante, en e a echangeant le nombre d’arguments et/ou le type des arguments. Nous avons d´j` vu cette notion eaauparavant, dans le cadre de l’h´ritage, la recherche d’une m´thode acceptable se fait en “remon- e etant” les d´rivations successives. e4.3.3 En r´sum´ e e – Si une m´thode poss`de la mˆme signature dans une classe d´riv´e que dans une classe e e e e e parente : – les types des valeurs de retour doivent ˆtre exactement les mˆmes, e e – les droits d’acc`s de la m´thode de la classe d´riv´e ne doivent pas ˆtre moins ´lev´s que e e e e e e e dans la classe parente, – la clause throws de la m´thode d´riv´e ne doit pas mentionner des exceptions non indiqu´es e e e e dans la clause throws de la m´thode de la classe parente. (Nous verrons ceci plus tard). e Si ces 3 conditions sont r´unies, nous avons une red´finition sinon il y a une erreur. e e – Si la signature de la m´thode (nombre/type des arguments) n’est pas la mˆme on a une e e surcharge (ou surd´finition). On rappelle que le type de la valeur de retour n’est pas pris en e compte dans le cas d’une surcharge.Notez qu’il est possible de dupliquer des champs lors d’un processus d’h´ritage, dans ce cas seul ele champ de la classe d´riv´e n’est visible de “l’ext´rieur”. Ceci est ` ´viter. e e e ae4.4 Le polymorphisme Le polymorphisme permet de manipuler des objets sans connaˆ tout ` fait leur type. C’est ıtre aun principe extrˆmement puissant en programmation orient´e objet, qui compl`te l’h´ritage. e e e eExemple de base :public class Point{ private int x,y;
    • 78 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME public Point(int x,int y){ ... } public Point(){ ... } public void affiche(){ ... } ...}public class PointCouleur extends Point{ private byte couleur; public PointCouleur(int x,int y,byte couleur){ ... } public PointCouleur(){ ... } public void affiche(){ ... } ...} Tout ´l´ment de type PointCouleur est ´galement de type Point, il est possible d’utiliser cette ee ecaract´ristique commune. e Objet de type Point Point p; 3 x (Point) p 5 y p = new Point(3,5); ... 4 x p = new PointCouleur(4,8,(byte) 2); (Point) p 8 y 2 couleur Objet de type PointCouleurAutre exemple.Point p = new Point(3,5);p.affiche(); //methode affiche de la classe Pointp = new PointCouleur(4,8,(byte)2);p.affiche(); //m´thode affiche de la classe PointCouleur e Le choix de la m´thode ` appliquer se fait automatiquement en fonction du type effectif de e al’objet et non pas en fonction du type de la variable qui r´f´rence l’objet. Ce choix porte le nom eede liaison dynamique ou ligature dynamique. Le polymorphisme se traduit par : – la compatibilit´ par affectation entre un type de classe et un type ascendant, e – la liaison dynamique des m´thodes : comportement adapt´ ` chaque objet. e ea
    • 4.4. LE POLYMORPHISME 794.4.1 Tableaux h´t´rog`nes d’objets e e eExemple :Point [] tabPts = new Point[4];tabPts[0] = new Point(0,2);tabPts[1] = new PointCouleur(1,5,(byte) 2);tabPts[2] = new PointCouleur(2,3,(byte) 4);tabPts[3] = new Point(1,2);for(int i=0 ; i<tabPts.length ; i++){ tabPts.affiche();} Ce bout de code provoque le r´sultat suivant : eJe suis un point de coordonn´es 0 2 eJe suis un point de coordonn´es 1 5 e de couleur 2Je suis un point de coordonn´es 2 3 e de couleur 4Je suis un point de coordonn´es 1 2 eCette situation s’adapte ´galement ` une hi´rarchie de classe plus complexe. e a e A B C D E F GAutre exemple : cette fois on red´finit pas de m´thode affiche dans la classe PointCouleur e epublic class Point{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; } public void affiche() { identifie(); System.out.println(" de coordonn´es "+x+" "+y); e }
    • 80 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME public void identifie() { System.out.print("Je suis un point"); } ...}public class PointCouleur extends Point{ private byte couleur; public PointCouleur(int x,int y,byte couleur) { super(x,y); this.couleur = couleur; } public void identifie() { System.out.print("Je suis un point couleur de couleur "+couleur+", "); }} Si on reprend le code utilis´ sur les tableaux on obtient le r´sultat suivant : e eJe suis un point de coordonn´es 0 2 eJe suis un point couleur de couleur 2, de coordonn´es 1 5 eJe suis un point couleur de couleur 4, de coordonn´es 2 3 eJe suis un point de coordonn´es 1 2 e4.4.2 R`gles du polymorphisme en Java eCompatibilit´. Il existe une conversion implicite d’une r´f´rence ` un objet de classe T ` un e ee a aobjet d’une classe parente de T.Liaison dynamique. Lors d’un appel d’une m´thode a.f() o` a est suppos´ ˆtre de type d’une e u eeclasse T, le choix de f est d´termin´ : e e – A la compilation : on d´termine dans la classe T ou ses ascendants la signature de la meilleure e m´thode f() convenant ` l’appel, ce qui d´fini du mˆme coup le type de la valeur de retour. e a e e – A l’ex´cution : on cherche la m´thode f de syntaxe et de type de retour voulu ` partir de la e e a classe correspondante au type effectif de l’objet r´f´renc´ par a (de type T ou ascendant). Si ee e cette classe ne comporte pas de m´thode appropri´e on remonte le plus possible jusqu’` ce e e a qu’on en trouve une.4.5 La super-classe Object En Java, toute classe d´finie h´rite de la classe Object. Une variable de type Object peut ˆtre e e eutilis´e pour r´f´rencer un objet de type quelconque. e eeExemplePoint p = new Point(1,3);Object o;o = p;
    • 4.5. LA SUPER-CLASSE OBJECT 81((Point)o).affiche();Point p1 = (Point) o;p1.affiche();Attention. L’instruction o.affiche(); provoque une erreur car il n’y a pas de m´thode affiche ed´finie dans la classe Object. Il faut alors faire une conversion (cast) explicite comme le montre el’exemple ci-dessus. La classe Object poss`de quelques m´thodes, dont notamment : e e – la m´thode public String toString() qui renvoie, par d´faut, une chaˆ de caract`res e e ıne e contenant le nom de la classe et l’adresse m´moire de l’objet (adresse pr´c´d´e de @). e e e e Point a = new Point(1,2); System.out.println(a.toString()); //affiche Point@fc1aedf System.out.println(a); //´quivalent e La m´thode toString d´finie par d´faut le chaˆ ` afficher lorsque l’on veut afficher un e e e ıne a objet. Plutˆt que de d´finir une m´thode d’affichage on red´finie la m´thode toString dans o e e e e la classe souhait´e puis on affiche directement l’objet. e public class Point { private int x,y; public Point(...){...} ... public String toString() { return "Je suis un point de coordonn´es "+x+" "+y; e } } ... Point p = new Point(0,2); ... System.out.println(p); – La m´thode public boolean equals(Object o) se content de comparer les adresses m´moire e e des objets r´f´renc´s. ee e Object o1 = new Point(1,2); Object o2 = new Point(1,2); o1.equals(o2); //renvoie false comme r´ponse e o1.equals(o1); //renvoie true comme r´ponse e Il est ´galement possible de r´d´finir/surcharger la m´thode equals dans ses propres classes : e e e e public class Point { private int x,y; public Point(...){...} ... public boolean equals(Point p) { return ((p.getX()==x) && (p.getY()==y)); } }
    • 82 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME4.6 Acc`s par membres prot´g´s : protected e e e En plus des droits d’acc`s public et private et du droit par d´faut li´ ` la notion de paquetage, e e eail existe un autre droit d’acc`s : protected. e Un membre protected est accessible ` des classes du mˆme package ainsi qu’` leur classe a e ad´riv´es. En pratique, ce droit d’acc`s est assez peu utilis´. e e e e4.7 M´thodes et classes finales e Une m´thode d´clar´e final ne peut pas ˆtre red´finie dans une classe d´riv´e. e e e e e e e Une classe d´clar´e final ne peut plus ˆtre d´riv´e. e e e e e4.8 Les classes abstraites Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle ne peut servirque de classe de base pour une d´rivation. eExemplepublic abstract class A{ public void f() { ... // m´thode compl`tement sp´cifi´e dans A e e e e } //m´thode abstraite pas d´finie dans A e e public abstract void g(int n);} Une classe abstraite poss`de au moins une m´thode abstraite, utilisation du mot cl´ abstract. e e eIl est possible de cr´er une r´f´rence de type A (A a;), mais on ne peut pas cr´er d’objet de type e ee eA (A a = new A(); provoque une erreur). En revanche, on cr´e une classe B qui d´rive de A en d´finissant g. e e epublic class B extends A{ public void g(int n) { ... }} Ensuite on peut cr´er des objets de type B (B b = new B();). e Une classe d´riv´e d’une classe abstraite n’est pas oblig´e de red´finir toutes les m´thodes e e e e eabstraites de sa classe de base. Dans ce cas c’est une classe abstraite elle aussi, il faut alors pensera` utiliser le mot cl´ abstract dans sa d´finition. e e Une m´thode abstraite est toujours publique. eInt´rˆt. e e – Permet de sp´cifier toutes les fonctionnalit´s que l’on souhaite disposer dans les classes e e d´riv´es. e e – Permet d’exploiter le polymorphisme en ´tant sˆ r que certaines m´thodes existes. e u e
    • 4.8. LES CLASSES ABSTRAITES 83Exemple.abstract class Affichable{ abstract public void affiche();}class Entier extends Affichable{ private int valeur; public Entier(int n) { valeur = n; } public void affiche() { System.out.println("Je suis un entier de valeur "+valeur); }}class Flottant extends Affichable{ private float valeur; public Flottant(float x) { valeur = x; } public void affiche() { System.out.println("Je suis un flottant de valeur "+valeur); }}public class Test{ public static void main(String [] args) { Affichable [] tab; int i; /*compteur*/ tab = new Affichable[3]; tab[0] = new Entier(25); tab[1] = new Flottant(1.25f); tab[2] = new Entier(42); for(i=0 ; i<3 ; i++) tab[i].affiche(); }} Si on ex´cute le code contenu dans la m´thode main, on obtient le r´sultat suivant : e e eJe suis un entier de valeur 25Je suis un flottant de valeur 1.25Je suis un entier de valeur 42
    • 84 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME4.9 Les interfaces Une interface est une notion correspondant ` une classe abstraite o` aucune m´thode n’est a u eimpl´ment´e. e e4.9.1 D´finition et mise en œuvre epublic interface I{ void f(int n); //public et abstract sont facultatifs void g();}public class A implements I{ //A doit red´finir f et g e} – Une mˆme classe peut impl´menter plusieurs interfaces. e epublic interface I2{ int h();}class B implements I,I2{ //red´finition de f et g de I et h de I2 e} – Les interfaces peuvent contenir des constantes de type static final. Ces constantes seront donc accessibles en dehors d’une classe impl´mentant l’interface. e – Les interfaces peuvent se d´river, mais les classes d´riv´es obtenues sont aussi des interfaces. e e einterface I1{ static final int MAXI = 20; void f(int n);}interface I2 extends I1{ void g();}class A implements I1{ //red´finit f, on a acc`s ` MAXI directement e e a //par exemple if(i < MAXI) ...}class B extends A implements I2{ //red´finition de g e}
    • 4.10. CONNAˆ ITRE LA CLASSE ET LES TYPES D’UN OBJET 85 On peut ainsi ´crire les choses suivante d’o` on veut : e uI1 i = new A();I1 i2 = new B();I2 b = new B();System.out.println("Constante "+I1.MAXI);4.9.2 Int´rˆt des interfaces e e – Une classe peut impl´menter plusieurs interfaces, alors qu’une classe ne peut d´river que e e d’une seule classe (´ventuelle abstraite). e – La notion d’interface se superpose ` la notion de d´rivation et ne s’y substitue pas. a e – On peut utiliser des variables de type d’interfaces. – Les interfaces peuvent se d´river. e Les interfaces permettent notamment de fournir une solution au probl`me de l’h´ritage mul- e etiple. Graveur graver() GraveurCD GraveurDVD graver() graver() ComboProbl`me de l’h´ritage multiple : quelle m´thode graver s’ex´cute sur le combo ? e e e e En Java il n’y a pas d’h´ritage multiple : on ne peut h´riter que d’une seule classe. On contourne e ealors le probl`me en utilisant des interfaces. Dans l’exemple du dessus, une solution pourrait ˆtre e ede cr´er une classe Combo qui h´rite de Graveur et qui impl´mente l’interface GraveurCD poss´dant e e e eune m´thode graverCD et l’interface graverDVD poss´dant une m´thode graverDVD. e e e4.10 Connaˆ ıtre la classe et les types d’un objet4.10.1 L’op´rateur instanceof e C’est un op´rateur bool´en qui renvoie true lorsque qu’un objet peut ˆtre converti en type d´fini e e e epar une classe. Cette classe peut correspondre ` une classe (abstraite ou non) situ´e au dessus de a ela classe de la r´f´rence de l’objet dans la hi´rarchie d’h´ritage ou une interface impl´ment´e par ee e e e el’une des classes m`res ou la classe propre de l’objet. e
    • 86 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISMEExemple d’utilisationif(objetA instanceof classeB){ //renvoie true si objetA peut-etre converti dans //le type classeB}Un autre exemple, dans le cas de red´finition de equals epublic boolean equals(Object o) { if (o instanceof MyClass) { MyClass mc = (MyClass) o; if (mc == null) // ne peut pas etre nul ici return false; else return ... // il faudrait comparer les champs de mc } return false;}4.10.2 La class Class Les instances de cette classe (qui n’est pas sous-classable, c’est-`-dire dont une sp´cification a eest final) sont utilis´es dans une application en cours d’ex´cution dans une JVM pour repr´senter e e eles diff´rentes classes ou interfaces utilis´es par l’application. Il en va de mˆme des tableaux et des e e etypes primitifs du langage. Cette classe n’a pas de constructeurs : les instances sont construitesautomatiquement par la JVM lors du chargement des classes. Si on se r´f`re par exemple ` la classe Object la m´thode getClass permet d’acc´der ` la ee a e e aclasse (r´f´rence sur Class) associ´e et ` partir d’une telle r´f´rence des informations relatives ` ee e a ee acette classe peuvent ˆtre obtenues par l’interm´diaire des m´thodes de cette classe. Parmi celles-ci e e ecitons : – Class[ ] getClasses( ) : renvoie un tableau contenant toutes les classes publiques et interfaces ; – String getName( ) : renvoie sous forme de chaˆ le nom de l’entit´ (classe, interface, ıne e tableau ou type primitif) correspondante ; – Class getSuperclass( ) : renvoie une r´f´rence sur la sur-classe ; ee – boolean isInstance(Object obj) : renvoie true si la r´f´rence est compatible avec la classe ee courante, ce qui est similaire ` l’utilisation de l’op´rateur instanceof. a e Voici un petit exemple d’utilisation :class AAAA { int a; }class BBBB { }class CCCC extends AAAA{ }class Class1{ public static void main(String[ ] arg){ AAAA a = new AAAA( ); CCCC c = new CCCC( ); int[ ] t = new int[10]; Object[ ] tabObj = new Object[5]; BBBB[ ] tabB = new BBBB[33];
    • 4.11. EXERCICES DE COURS 87 System.out.println("classe de a : " + a.getClass( ).getName( )); System.out.println("classe de c : " + c.getClass( ).getName( )); System.out.println("classe de t : " + t.getClass( ).getName( )); System.out.println("classe de tabObj : " + tabObj.getClass( ).getName( )); System.out.println("classe de tabB : " + tabB.getClass( ).getName( )); }}Voici le r´sultat eclasse de a : AAAAclasse de c : CCCCclasse de t : [Iclasse de tabObj : [Ljava.lang.Object;classe de tabB : [LBBBB; D’autres utilisations de cette classe sont possibles, notamment pour la cr´ation et l’utilisation ede classes dynamiques. Ceci sort du cadre de ce cours, mais pour plus d’informations vous pouvezconsulter la documentation de Sun et jeter un coup d’oeil ` la derni`re partie du dernier chapitre. a e4.11 Exercices de Cours4.11.1 Classes abstraites - classes concr`tes e L’id´e de cet exercice est de trouver une application concr`te ` toute d´finition abstraite. e e a ePlusieurs classes sont list´es dans la colonne du milieu. L’objectif est d’imaginer des applications edans lesquelles la classe list´e pourrait ˆtre abstraite et des applications o` elle pourrait ˆtre e e u econcr`te. Quelques exemples sont fournis pour aider ` d´marrer. Par exemple, la classe arbre e a eserait abstraite dans un programme p´pini`re o` les diff´rences entre un chˆne et un peuplier sont e e u e eimportantes. Mais dans un programme de simulation de golf, la classe arbre peut ˆtre concr`te e e(par exemple une sous-classe d’obstacle), parce qu’il n’y a aucun besoin de diff´rencier les arbres. e
    • 88 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME Concr`te e Classe Abstraite simulation de parcours de golf Arbre application de p´pini`re e e Maison application d’architecte application de photo satellite Ville JoueurDeFootball application d’entraˆ ınement Chaise Client Commande Livre Magasin Fournisseur ClubDeGolf Carburateur Four4.11.2 Compilateur Voici un bout de programme Java incomplet :public class MonstreTest{ public static void main(String [] args) { Monstre [] ma = new Monstre[3]; ma[0] = new Vampire(); ma[1] = new Dragon(); ma[2] = new Monstre(); for(int x = 0; x < 3; x++){ ma[x].fairePeur(x); } }}class Monstre{// -- m´thode A -- e}class Vampire extends Monstre{// -- m´thode B -- e}class Dragon extends Monstre{
    • 4.11. EXERCICES DE COURS 89 boolean fairePeur(int degre){ System.out.println("Souffler du feu"); return true; }} Si l’on suppose que le programme produit le r´sultat ci-dessous : e>java MonstreTestmordre ?souffler du feuarrrgh Quelles paires de m´thodes A et B peuvent ˆtre utilis´es dans les classes Monstre et Dragon e e e(respectivement) pour produire le r´sultat ci-dessus ? e 1. A: boolean fairePeur(int d){ System.out.println("arrrgh"); return true; } B: boolean fairePeur(int x){ System.out.println("mordre ?"); return false; } 2. A: boolean fairePeur(int d){ System.out.println("arrrgh"); return true; } B: int fairePeur(int f){ System.out.println("mordre ?"); return 1; } 3. A: boolean fairePeur(int d){ System.out.println("arrrgh"); return false; } B: boolean effrayer(int x){ System.out.println("mordre ?"); return true; } 4. A: boolean fairePeur(int z){ System.out.println("arrrgh"); return true; } B: boolean fairePeur(byte b){ System.out.println("mordre ?"); return true; }R´ponse : e 1. Cet ensemble fonctionne, false est une valeur de retour acceptable. 2. Cet ensemble ne compile pas. La m´thode fairePeur() de Vampire n’est ni une red´finition e e l´gale, ni une surcharge l´gale de la m´thode fairePeur() de Monstre. Une red´finition de e e e e m´thode ne peut pas modifier les arguments ni le type de retour, et ne changer QUE le type e ne suffit pas ` rendre une surcharge valide. a
    • 90 ´ CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME 3. Cet ensemble compile mais ne produit pas le bon r´sultat parce que la m´thode fairePeur() e e de la classe Monstre n’est pas red´finie dans la classe Vampire. e 4. Cet ensemble compile mais ne produit pas le bon r´sultat parce que la m´thode fairePeur() e e de Vampire accepte un byte alors qu’il faut un int.Les ensembles 3 et 4 produisent en fait le r´sultat suivant : earrrghsouffler du feuarrrgh4.11.3 Qui suis-je ? Associer ` chaque ligne ci-dessous un ou plusieurs mots parmi : superclasse, sous-classe, atableau, ArrayList (cf section 8.3.2), objet, tableau polymorphe, argument polymorphe,interface, m´thode abstraite, classe abstraite. e – Je suis incapable de grandir : tableau – Je dis quoi faire, pas comment le faire : m´thode abstraite, interface e – J’accepte le m´lange de chiens et de chats : ArrayList, tableau polymorphe e – J’autorise les r´f´rences h´t´rog`nes : argument polymorphe, ArrayList, tableau po- ee ee e lymorphe – Je peux dire si je suis vide : ArrayList – Ma vie est une existence plus sp´cialis´e : sous-classe e e – Mon contenu est toujours homog`ne : tableau e – Je peux rester floue sur certains d´tails : interface, m´thode abstraite, classe abstraite, e e superclasse – Je peux recevoir des choses que je n’ai jamais vues : tableau polymorphe, argument polymorphe, ArrayList – Les autres me regardent avec respect : superclasse, classe abstraite – Je profite du travail d’une autre : sous-classe, classe – Faites ce que je dis, pas ce que je fais : classe abstraite, interface – Je peux avoir un aspect diff´rent pour diff´rentes personnes : objet e e – J’ai oubli´ d’o` vous veniez : ArrayList e u – Rien de nouveau : interface, classe abstraite4.11.4 Vrai ou Faux ? Pour r´pondre ` certaines affirmations, il peut ˆtre utile de consulter les sections 8.1,8.2 e a e 1. Pour utiliser la classe Math il faut d’abord cr´er une instance. Faux e 2. On peut marquer un constructeur avec le mot cl´ static. Faux e 3. Les variables statiques n’ont pas acc`s ` l’´tat des variables d’instance de l’objet this. Vrai e a e 4. C’est une bonne pratique d’appeler une m´thode statique avec une variable de r´f´rence. e ee Faux 5. Les variables statiques peuvent servir ` compter les instances d’une classe. Vrai a 6. Les constructeurs sont appel´s avant que des variables statiques ne soient initialis´es. Faux e e 7. MAX SIZE serait un bon nom pour une variable statique finale. Vrai 8. Un bloc initialisateur statique s’ex´cute avant un constructeur de la classe. Vrai e 9. Si une classe est finale, toutes ses m´thodes doivent ˆtre finales. Faux e e 10. Une m´thode finale ne peut ˆtre red´finie que si la classe est ´tendue. Faux e e e e 11. Il n’y a pas de classe enveloppe pour les bool´ens. Faux e 12. On utilise une classe enveloppe pour traiter une valeur primitive comme un objet. Vrai 13. Les m´thodes parseXXX retournent toujours une chaˆ de caract`res. Faux e ıne e
    • Chapitre 5La gestion d’exceptions5.1 Pr´sentation e La gestion d’exceptions permet : – de d´tecter une anomalie et de la traiter ind´pendamment de sa d´tection, e e e – de s´parer la gestion des anomalies du reste du code. e Une anomalie peut ˆtre due, par exemple, ` des donn´es incorrectes, ` une fin de fichier e a e apr´matur´e, ` un ´v´nement non pr´vu par le programmeur. e e a e e eExemple. On dispose d’une classe Point pour laquelle on ne veut pas g´rer de donn´es n´gatives. e e eNous lan¸ons une exception lorsque les coordonn´es sont n´gatives par l’instruction throw. Pour c e ecommencer nous cr´ons un objet dont le type sert ` identifier l’exception concern´e. Une classe e a ed’exception se d´finit en h´ritant de la classe Exception d´j` d´finie dans l’API java. e e ea epublic class ErreurCoordonnees extends Exception{ } Ensuite, pour “lancer” une exception nous utiliserons :throw new ErreurCoordonnees(); Avant cela il faut indiquer le type d’exceptions qui peuvent ˆtre rencontr´es dans les m´thodes e e ede la classe Point. On ajoute alors throws ErreurCoordonnees dans la d´claration des m´thodes e equi peuvent rencontrer ces exceptions. Voici un exemple :public class Point{ private int x,y; public Point(int x,iny y) throws ErreurCoordonnees { if(x<0 || y<0) throw new ErreurCoordonnes(); this.x = x; this.y = y; } public void affiche() { System.out.println("Je suis un point de coordonn´es "+x+" "+y); e 91
    • 92 CHAPITRE 5. LA GESTION D’EXCEPTIONS }} Ensuite pour r´cup´rer une exception lanc´e par une m´thode, on utilise les instructions try e e e eet catch :public class TestExcept{ public static void main(String args[]) { try{ //Instructions qui peuvent voir une exception se d´clencher e Point a = new Point(1,4); a.affiche(); a = new Point(-3,5); a.affiche(); } catch(ErreurCoordonnees e) { //gestion de l’exception System.err.println("Erreur de construction"); System.exit(-1); } }}R´sultat. eJe suis un point de coordonn´es 1 4 eErreur de constructionAttention : le bloc catch doit suivre imm´diatement le bloc try. e Note : L’instruction throws d´clar´e au niveau d’une m´thode qui peut contenir une exception, e e edoit ˆtre ´galement ajout´e pour toutes les autres m´thodes qui appelle cette m´thode. Ceci doit e e e e ese faire r´cursivement pour remonter ´ventuellement jusqu’` la m´thode main. Pour se passer e e a ede l’instruction throws, il faut mettre un gestionnaire d’exception avec des catch permettant”d’attrapper” l’exception dans le corps de la m´thode concern´e. e e5.2 Gestion de plusieurs exceptions et transmission d’infor- mationsExemple.class ErreurCoord extends Exception{ private int abs,ord; public ErreurCoord(int abs,int ord) { this.abs = abs; this.ord = ord; } public int getAbs() {
    • 5.2. GESTION DE PLUSIEURS EXCEPTIONS ET TRANSMISSION D’INFORMATIONS 93 return abs; } public int getOrd() { return ord; }}class ErreurDepl extends Exception{ private int depx,depy; public ErreurDepl(int depx,int depy) { this.depx = depx; this.depy = depy; } public int getDepx() { return depx; } public int getDepy() { return depy; }}public class Point{ private int x,y; public Point(int x,iny y) throws ErreurCoord { if(x<0 || y<0) throw new ErreurCoord(x,y); this.x = x; this.y = y; } public void deplace(int dx,int dy) throws ErreurDepl { if((x+dx<0) || (y+dy<0)) throw new ErreurDepl(dx,dy); x+=dx; y+=dy; }
    • 94 CHAPITRE 5. LA GESTION D’EXCEPTIONS public void affiche() { System.out.println("Je suis un point de coordonn´es "+x+" "+y); e }}public class TestExcept{ public static void main(String args[]) { try{ //Instructions qui peuvent voir une exception se d´clencher e Point a = new Point(1,4); a.affiche(); a.deplace(-3,5); a = new Point(-3,5); a.affiche(); } catch(ErreurCoord e) { //gestion de l’exception System.err.println("Erreur de construction"+e.getAbs()+" "+e.getOrd()); System.exit(-1); } catch(ErreurDepl e) { System.err.println("Erreur de deplacement "+e.getDepx()+" "+e.getDepy()); System.exit(-1); } //l’execution se poursuit ici s’il n’y a pas d’erreurs System.out.println("Fin du programme"); }}R´sultat. eJe suis un point de coordonn´es 1 4 eErreur de deplacement -3 5Transmission de messages On peut transmettre un message au gestionnaire d’exception enutilisant un constructeur sans argument et la m´thode getMessage h´rit´e de la classe Exception. e e ePar exemple, avec la classe Point :public class ErreurCoord extends Point{ public ErreurCoord(String msg) { super(msg); }}public class Point{ ... public Point(int x,int y) { if(x<0 || y<0)
    • ´ ´5.3. DERIVATION ET REDECLENCHEMENT D’EXCEPTIONS 95 throw new ErreurCoord("Erreur dans le constructeur de Point avec"+x+" "+y); this.x=x; this.y=y; } ...}public class TextExcept3{ public static void main(String args[]) { try{ ... } catch (ErreurCoord e) { System.out.println(e.getMessage()); System.exit(-1); } ... }}5.3 D´rivation et red´clenchement d’exceptions e eIl est possible de d´river des classes d’exceptions. eclass ErreurPoint extends Exception { ... }class ErreurCoord extends ErreurPoint { ... }class ErreurDepl extends ErreurPoint { ... } Lorsque l’on souhaite r´cup´rer les exceptions il faut le faire en ordre inverse par rapport ` e e al’ordre d´fini par la hi´rarchie. e etry{ ...}catch(ErreurCoord e){ ...}catch(ErreurDepl e){ ...}catch(ErreurPoint e){ ...}Red´clenchement d’exceptions. Il est possible de d´clencher une exception dans le traitement e ed’une autre exception.
    • 96 CHAPITRE 5. LA GESTION D’EXCEPTIONStry{ ...}catch(MonException e){ throw new Except();} Il est possible de red´clencher une exception pour la transmettre ` un niveau englobant. e atry{ ...}catch(MonException e){ ... throw e;}Exemple complet.class ErreurCoord extends Exception { }class ErreurBidon extends Exception { }public class Point{ private int x,y; public Point(int x,int y) throws ErreurCoor { if(x<0 || y<0) throw new ErreurCoord(); this.x = x; this.y = y; } public void f() throws ErreurCoord,ErreurBidon { try{ Point p = new Point(-3,2); } catch(ErreurCoord e) { System.err.println("ErreurCoord dans le catch de f"); throw new ErreurBidon(); } }}public class Test{ public static void main(String [] args) { try{
    • 5.4. LE BLOC FINALLY 97 Point a = new Point(1,3); a.f(); } catch(ErreurCoord e) { System.err.println("ErreurCoord dans le catch de main"); } catch(ErreurBidon e) { System.err.println("ErreurBidon dans le catch de main"); } System.err.println("Apr`s le bloc try-catch de main"); e }}R´sultat. eErreurCoord dans le catch de fErreurBidon dans le catch de mainApr`s le bloc try-catch de main e5.4 Le bloc finally Il est possible, en Java, d’introduire ` la suite d’un bloc try, un bloc particulier d’instructions aqui seront toujours ex´cut´es : e e – soit apr`s la fin normale du bloc try, si aucune exception n’a ´t´ d´clench´e, e ee e e – soit apr`s le gestionnaire d’exception (` condition que ce dernier n’est pas provoqu´ l’arrˆt e a e e de l’ex´cution). e Ce bloc est introduit par le mot cl´ finally et doit obligatoirement ˆtre plac´ apr`s le dernier e e e egestionnaire.try{ ... } catch(Ex e) { ... } finally{ ... }Ici le mˆme r´sultat aurait pu ˆtre obtenu en supprimant tout simplement le mot cl´ finally et e e e een mettant les instructions de ce bloc ` la suite du gestionnaire catch. aCe n’est pas la mˆme chose dans ce cas : evoid f() throws MonException{ try{ ... } finally{ ... }}
    • 98 CHAPITRE 5. LA GESTION D’EXCEPTIONSSi une exception se produit dans f, on ex´cutera d’abord les instructions du bloc finally avant ede sortir de f et de se brancher sur le gestionnaire d’exceptions. De mani`re g´n´rale, le bloc finally peut s’av´rer int´ressant dans le cadre de l’acquisition e e e e ede ressources, c’est-`-dire tout ce qui n´cessite une action pour la bonne bonne poursuite des a eop´rations (fermer un fichier, cr´er un objet, enlever un verrou, ...). e eAutre cas. try{ ... if(...) break; ... } finally{ ... } //suite ...Si la commande break est ex´cut´e, on ex´cute d’abord le bloc finally avant de passer ` la suite. e e e aAutre exemple possible.try{ ... return 0;}finally{ ... return -1;}Ici la m´thode semble devoir ex´cuter une instruction return 0 ;, mais il faut quand mˆme e e eex´cuter le bloc finally contenant ` son tour return -1 ;. Dans ce cas c’est la derni`re va- e a eleur qui sera renvoy´e (-1). e5.5 Les exceptions standard Java fournit de nombreuses classe pr´d´finies d´riv´es de la classe Exception qui sont utilis´es e e e e epar certaines m´thodes standard. Par exemple : IOException et ses d´riv´es sont utilis´es par les e e e em´thodes d’entr´e/sortie. e e D’autres exceptions sont utilis´es par la JVM lors de situation anormales comme un indice de etableau hors limites, une taille de tableau n´gative, une op´ration de lecture ` la fin d’un fichier, e e a... Il existe 2 cat´gories d’exception : e – les exceptions explicites (ou sous contrˆle) correspondant ` celles que nous venons d’´tudier. o a e Elles doivent ˆtre trait´es dans une m´thode ou bien ˆtre mentionn´es par la clause throws. e e e e e – les exceptions implicites (ou hors contrˆle) n’ont pas ` ˆtre mentionn´es dans une clause o a e e throw et on n’est pas obliger de les traiter (mais il est quand mˆme possible de le faire). eExemple de traitement.public class TestExcept{
    • 5.6. EXERCICES DE COURS 99 public static void main(String [] args) { try { //on ne fait pas de v´rification sur les arguments pour all´ger le code e e int t[]; int n,i; n = Integer.parseInt(args[0]); System.out.print("taille voulue "+n); t = new int[n]; i = Integer.parseInt(args[1]); System.out.print(" indice : "+i); t[i] = 12; System.out.println(" *** fin normale"); } catch(NegativeArraySizeException e) { System.out.println("Exception de taille de tableau n´gative "+e.getMessage()); e } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Exception indice de tableau "+e.getMessage()); } }} Il existe beaucoup d’exceptions et les traiter toutes serait fastidieux, on traite celles qui sontles plus pertinentes pour le probl`me a traiter. e `5.6 Exercices de Cours5.6.1 Vrai ou Faux ? 1. Un bloc try doit ˆtre suivi d’un bloc catch et d’un bloc finally : Faux, l’un ou l’autre ou e les deux. 2. Si on ´crit une m´thode susceptible de d´clencher une exception v´rifi´e par le compila- e e e e e teur, on doit envelopper le code dans un bloc try/catch : Faux, vous pouvez d´clarer e l’exception. 3. Les blocs catch peuvent ˆtre polymorphes : Vrai. e 4. Seules les exceptions v´rifi´es par le compilateur peuvent ˆtre intercept´es : Faux, les ex- e e e e ceptions se produisant ` l’ex´cution peuvent ˆtre intercept´es. a e e e 5. Si on d´finit un bloc try/catch, le bloc finally correspondant est optionnel : Vrai. e 6. Si on d´finit un bloc try, on peut l’apparier avec un bloc catch ou un bloc finally, ou les e deux : Vrai, les 2 sont acceptables 7. Si on ´crit une m´thode qui d´clare qu’elle peut lancer une exception v´rifi´e par le compi- e e e e e lateur, on doit envelopper le code dans un bloc try/catch : Faux, la d´claration suffit. e 8. La m´thode main dot g´rer toutes les exceptions non g´r´es qui lui parviennent : Faux, e e e e mais si elle ne le fait pas la JVM peut s’arrˆter. e 9. Un seul bloc try peut avoir plusieurs blocs catch diff´rents : Vrai. e 10. Une m´thode ne peut lancer qu’un seul type d’exception : Faux. e 11. Un bloc finally peut s’ex´cuter sans qu’une exception soit lanc´e : Vrai, c’est ce que l’on e e fait souvent pour “faire le m´nage” apr`s une tˆche partiellement termin´e. e e a e
    • 100 CHAPITRE 5. LA GESTION D’EXCEPTIONS 12. Un bloc finally peut exister sans bloc try : Faux. 13. Un bloc try peut exister seul, sans catch ni finally : Faux. 14. Lorsqu’on g`re une exception on dit parfois qu’on l’esquive : Faux, esquiver est synonyme e de d´clarer. e 15. L’ordre des blocs catch n’a jamais d’importance : Faux, les exceptions les plus g´n´rales e e doivent ˆtre intercept´es par les derniers blocs catch. e e 16. Une m´thode ayant un bloc try et un bloc finally peut ´ventuellement d´clarer l’exception : e e e Faux, en l’absence du bloc catch, vous devez d´clarer l’exception. e 17. Les exceptions susceptibles de survenir ` l’ex´cution doivent ˆtre g´r´es ou d´clar´es : Faux. a e e e e e e
    • 5.6. EXERCICES DE COURS 1015.6.2 Mots crois´s e 1 2 3 M T D 4 5 6 7 A F F E C T A T I O N C A T C H E T L O R R P 8 9 10 11 H I E R A R C H I E D Y O I N S O N E W L 12 S S M S U P E R C L A S S E T E P T E 13 14 15 16 A E I A L G O R I T H M E S 17 F N T L N E X 18 L C A E C O D E S C 19 O I N T R E T E 20 A E I S P I 21 22 T H R O W C O N C R E T E T N I 23 24 O B J E T S D E C L A R A T I O N N HORIZONTALEMENT VERTICALEMENT 4 Donne une valeur (-) 1 A beaucoup de m´thodes statiques (-) e 6 Intercepte (-) 2 D´clare une exception (-) e 8 Arbre g´n´alogique (-) e e 3 Ot´es de la pile (-) e 12 On en h´rite (-) e 5 Patron d’objet (-) 14 Recette de code (-) 6 Programmer (-) 18 Programme (-) 7 Avant le catch (-) 19 Le plus petit primitif (-) 9 Faire du nouveau (-) 20 Constante (-) 10 Transformerions en bytecode (-) 21 Lance (-) 11 Objet (-) 22 Non abstraite (-) 13 Pas un comportement (-) 23 Instances de classes (-) 15 Posent des conditions (-) 24 Gestion ou ... telle est la loi (-) 16 Erreur ou probl`me (-) e 17 A des d´cimales (-) e
    • 102 CHAPITRE 5. LA GESTION D’EXCEPTIONS
    • Chapitre 6Les chaˆ ınes de caract`res en Java e6.1 Le type String6.1.1 Les chaˆ ınes de caract`res sont des objets e Voici plusieurs mani`res de cr´er des chaˆ e e ınes : ch1 String ch1 = new String(); String ch2 = new String("hello"); ch2 hello String ch3 = new String(ch2); String ch4 = "hello"; ch3 hello ch4 helloLa derni`re instruction est ´quivalente ` la deuxi`me. e e a eLes objets de type String ne sont pas modifiables6.1.2 Affichage d’une chaˆ ıne Pour afficher une chaˆ sur la sortie standard on peut utiliser : System.out.println(ch2); ınePour afficher une erreur, on peut utiliser : System.err.println("Attention Erreur");6.1.3 Longueur d’une chaˆ ıneString ch = "bonjour";int l = ch.length(); Attention : pour les chaˆ ınes on utilise une m´thode pour obtenir la taille, d’o` l’usage des e uparenth`ses (dans le cas de tableaux il s’agissait d’un champ !). e6.1.4 acc`s aux caract`res e eString ch = "bonjour";char c1=ch.charAt(0); //caract`re ` la position 0 : le ’b’ e achar c2=ch.charAt(2); //caract`re ` la position 2 : le ’n’ e a Note : on peut int´grer des caract`res sp´ciaux e e eString salutation="tBonjourntt` tous"; a 103
    • 104 CHAPITRE 6. LES CHAˆ ` INES DE CARACTERES EN JAVA6.1.5 Concat´nation : l’op´rateur + e e String ch1 = "le langage"; ch1 le langage ch2 java String ch2 = " java"; String ch3 = ch1 + ch2; ch3 le langage java Lorsque l’op´rateur + est utilis´ avec au moins une chaˆ les autres op´randes sont convertis e e ıne, eautomatiquement en chaˆ ıne.int n=24;int y=2005;String d=new String("Nous le somme le " + n + " octobre " + y); L’op´rateur += est aussi utilisable : eString ch="bonjour ";ch +=" monsieur";Un nouvel objet contenant la chaˆ bonjour monsieur est cr´´ et l’ancienne chaˆ bonjour de- ıne ee ınevient candidate au ramasse-miettes. Autre exemple : ` la fin on affiche : chiffres= 0123456789 aString ch="chiffres= ";for(int i=0;i<10;i++) ch+=i;System.out.println(ch);6.1.6 Recherche dans une chaˆ : la m´thode indexOf ıne e Elle cherche ` partir du d´but (ou la fin) d’une chaˆ ou d’une position donn´e : a e ıne e – soit la premi`re position d’un caract`re, e e – soit la premi`re occurrence d’une chaˆ e ıne.Elle renvoie la position si une correspondance a ´t´ trouv´e, -1 sinon. ee eString mot="anticonstitutionnellement"; //mot de 25 lettresint n;n=mot.indexOf(’t’); //renvoie la position 2n=mot.lastIndexOf(’t’); //renvoie la position 24 (derni`re occurrence) en=mot.lastindexOf("ti"); //renvoie la position 12n=mot.indexOf("ti"); //renvoie la position 2n=mot.indexOf(’x’); //renvoie la position -1n=mot.indexOf("ti",6); // recherche ` partir de la position 6, renvoie 8 an=mot.lastIndexOf(’t’,9); //recherche ` partir de la position 9, renvoie 24 a6.1.7 La comparaison de chaˆ ınes Les chaˆ ınes ´tant des objets, les op´rateurs == et ! = testent les adresses des objets et non le e econtenu. On ne peut pas les utiliser directement pour comparer des chaˆ ınes.Tester l’´galit´ de deux chaˆ e e ınes ch1.equals(ch2) renvoie true si le contenu de ch1 est le mˆme que le contenu de ch2 et f alse esinon.
    • 6.1. LE TYPE STRING 105Comparer deux chaˆ ınes ch1.compareTo(ch2) renvoie – un entier n´gatif si ch1 est situ´e avant ch2 e e – un entier nul (0) si les 2 chaˆınes sont ´gales e – un entier positif si ch1 est situ´e apr`s ch2 e eL’ordre utilis´ est l’ordre classique sur les caract`res d´fini par la table ascii (correspondant ` e e e al’ordre alphab´tique pour les lettres). e ch1 ch2 ch1.compareTo(ch2) bonjour monsieur <0 bonj monsieur <0 prix12 prix10 >0 Element ´lement e <0 Element element <0 element ´l´ment ee >0 bonjour bonjour 0 monsieur bonjour >06.1.8 Modification d’un caract`re eString ch="bonjour";String ch1=ch.replace(’o’,’a’);Attention un nouvel objet est cr´´, r´f´renc´ par ch1, on aurait pu ´crire ch=ch.replace(’o’,’a’); ee e e e e6.1.9 Extraction de sous-chaˆ ınesString ch="bonjour";String ch1=ch.subString(3); // ch1 contient "jour"String ch2=ch.subString(2,4); // ch2 contient "njo"6.1.10 Passage en majuscules/minusculesString ch1=ch.toLowerCase(); // passage en minusculeString ch2=ch.toUpperCase(); // passage en majuscule6.1.11 Conversion d’une chaˆ vers un type primitif ıne Vous pouvez utiliser les m´thodes explicites suivantes : e – Byte.parseByte(ch); – Short.parseShort(ch); – Integer.parseInt(ch); – Long.parseLong(ch); – Float.parseFloat(ch); – Double.parseDouble(ch);S’il y a un caract`re qui pose probl`me lors de la conversion une exception est lev´e (BuildException). e e e6.1.12 Conversion d’un type primitif vers une chaˆ ıne On peut soit utiliser l’op´rateur +, soit la m´thode String.value() e efloat f=2.5f;String ch0=""+f; // premi`re possibilit´ e eString ch1=String.value(f); //deuxi`me possibilit´ e e
    • 106 CHAPITRE 6. LES CHAˆ ` INES DE CARACTERES EN JAVA6.1.13 Chaˆ ınes et tableaux de caract`res e – Convertir un tableau de caract`res en chaˆ e ıne char mot[]={’b’,’o’,’n’,’j’,’o’,’u’,’r’}; String ch=new String(mot); – Convertir une chaˆ en tableau de caract`res ıne e String ch="bonjour"; char mot[]=ch.toCharArray();6.1.14 Tableau de chaˆ ınes Le tableau args de la m´thode main, contenant les arguments du programme, est un tableau ede chaˆ ıne.public static void main(String [] args){ System.out.println("Voici la liste des arguments"); for(int i=0; i < args.length; i++) System.out.println("Argument "+String.value(i+1)+" de longueur "+args[i].length()+" : " + args[i]);}Notez la diff´rence entre args.length qui la longueur du tableau et args[i].length() qui est elongueur de la chaˆ ` la position i du tableau. ıne a6.2 La classe StringBuffer La classe StringBuffer fait partie du package java.lang et contrairement ` la classe String, aelle utilise un buffer de taille variable pour m´moriser une chaˆ de caract`res modifiables. Cette e ıne eclasse f inal maintient elle-mˆme l’allocation d’espace suppl´mentaire pour m´moriser l’ajout de e e ecaract`res. Elle permet donc de manipuler des chaˆ e ınes modifiable. Voici la liste des m´thodes de ecette classe : – public StringBuffer() : construit une chaˆ vide ıne – public StringBuffer(int length) : construit une chaˆ de longueur length ıne – public StringBuffer(String str) : construit une chaˆ de type StringBuffer ` partir ıne a d’une chaˆ de caract`res classique ıne e – int length() : renvoie la taille de la chaˆ (comme dans String) ıne – void setCharAt(int index, char c) : modifie le caract`re ` la position index en le rem- e a pla¸ant par c c – StringBuffer append(String str) : ajoute la chaˆ str en fin (possibilit´ de mettre un ıne e tableau de caract`res ou un objet au lieu d’une String) e – StringBuffer insert(int offset, String str) : ins`re une chaˆ ` l’indice of f set e ıne a – String toString() convertit la chaˆ au type String ınePour plus d’informations, consulter la documentation de la classe StringBuffer.6.3 La classe StringTokenizer La classe StringTokenizer fait partie du package java.util (il faut importer le package sivous voulez l’utiliser). Elle permet de d´composer une chaˆ de caract`res en une suite de ”mots” e ıne es´par´s par des ”d´limiteurs”. e e eVoici les constructeurs :
    • 6.3. LA CLASSE STRINGTOKENIZER 107 – StringTokenizer(String str, String delim, boolean returnDelims) : str est la chaˆ ıne a ` analyser, delim est une chaˆ contenant les d´limiteurs reconnus, returnDelims indique ıne e si les d´limiteurs doivent ˆtre renvoy´s comme parties de la chaˆ e e e ıne. – StringTokenizer(String str) : cr´e un objet StringTokenizer, str est la chaˆ ` ana- e ıne a lyser ; les d´limiteurs sont les caract`res espace, tabulation, retour chariot et changement de e e ligne. – StringTokenizer(String str, String delim) : cr´e un objet StringTokenizer, str est e la chaˆ ` analyser, delim est une chaˆ contenant les d´limiteurs reconnus. Par d´faut, ıne a ıne e e les d´limiteurs ne sont pas renvoy´s comme ´l´ments de la chaˆ e e ee ıne.La liste des m´thodes : e – int countTokens() : calcul le nombre de fois que la m´thode nextToken() peut ˆtre appel´e e e e avant la g´n´ration d’une exception. e e – boolean hasMoreElements() : retourne la mˆme valeur que la m´thode hasMoreTokens(). e e – boolean hasMoreTokens() : v´rifie s’il n’y a plus de jetons disponibles ` partir de l’objet e a StringTokenizer. – Object nextElement() : retourne la mˆme valeur que la m´thode nextToken(). e e – String nextToken() : retourne le prochain jeton ` partir de l’objet StringTokenizer. a – String nextToken(String delim) : retourne le prochain jeton par rapport au d´limiteur e sp´cifi´. e eExemple :StringTokenizer st = new StringTokenizer("C’est une ligne");while (st.hasMoreTokens()) { System.out.println(st.nextToken());}Ce bout de code provoque l’affichage de :C’estuneligneAutre exemple :StringTokenizer st = new StringTokenizer("/home/toto/TP-JAVA","/-",false);System.out.println("Il y a "+st.countTokens()+" ´l´ments dans la cha^ne"); e e ıwhile (st.hasMoreTokens()) { System.out.println(st.nextToken());}Ce bout de code provoque l’affichage de :hometotoTPJAVA
    • 108 CHAPITRE 6. LES CHAˆ ` INES DE CARACTERES EN JAVA
    • Chapitre 7Les entr´es/sorties e7.1 Les fichiers, la classe File L’objet File constitue une repr´sentation abstraite d’un chemin vers un fichier ou un r´pertoire. e e Le s´parateur de chemin d´pend de la plateforme. Sous Unix la valeur de ce s´parateur est ’/’ e e ealors que sous Windows sa valeur est ´gale ` ’’. e a7.1.1 Les champs – static String pathSeparator : Ce champ repr´sente le caract`re de s´paration par d´faut e e e e d´pendant du syst`me sous-jacent, sous la forme d’une chaˆ de caract`res pour des raisons e e ıne e de commodit´s. e – static char pathSeparatorChar : Ce champ repr´sente le caract`re de s´paration de che- e e e min par d´faut d´pendant du syst`me sous-jacent. e e e – static String separator : Ce champ repr´sente le caract`re de s´paration par d´faut e e e e d´pendant du syst`me sous-jacent, sous la forme d’une chaˆ de caract`res pour des raisons e e ıne e de commodit´s. e – static char separatorChar : Ce champ repr´sente le caract`re de s´paration par d´faut e e e e d´pendant du syst`me sous-jacent. e e7.1.2 Les constructeurs – File(File parent, String child) cr´e un nouvel objet File ` partir d’un autre chemin e a abstrait d´signant le parent et d’une chaˆ de caract`res indiquant un chemin enfant. e ıne e – File(String pathname) cr´e un nouvel objet File ` partir d’un chemin donn´ sous la forme e a e d’une chaˆ de caract`res. ıne e – File(String parent, String child) cr´e un nouvel objet File ` partir de deux chaˆ e a ınes de caract`res d´signant respectivement un chemin parent et un autre enfant. e e – File(URI uri) cr´e un nouvel objet File en convertissant l’URI fourni en chemin abstrait. e7.1.3 Les m´thodes e – boolean canRead() teste si l’application peut lire le fichier d´sign´ par l’objet File. e e – boolean canWrite() teste si l’application peut modifier le fichier d´sign´ par le chemin e e abstrait. – int compareTo(File pathname) compare lexicographiquement deux objets File. – int compareTo(Object o) compare l’objet File par rapport ` un autre objet. a – boolean createNewFile() cr´e atomiquement un nouveau fichier vide d´sign´ par le chemin e e e abstrait si et seulement si un fichier de mˆme nom n’existe pas encore. e 109
    • 110 ´ CHAPITRE 7. LES ENTREES/SORTIES – static File createTempFile(String prefix, String suffix) cr´e un nouvel objet File e vide dans le r´pertoire temporaire par d´faut en utilisant le pr´fixe et le suffixe donn´s pour e e e e g´n´rer son nom. e e – static File createTempFile(String prefix, String suffix, File directory) cr´e e un nouvel objet File vide dans le r´pertoire sp´cifi´ en utilisant le pr´fixe et le suffixe donn´s e e e e e pour g´n´rer son nom. e e – boolean delete() supprime le fichier ou le r´pertoire d´sign´ par l’objet File. e e e – void deleteOnExit() demande que le fichier ou le r´pertoire d´sign´ par le chemin abstrait e e e soit supprim´ lorsque la Machine Virtuelle Java s’arrˆte. e e – boolean equals(Object obj) teste l’´galit´ de l’objet File par rapport ` un autre objet. e e a – boolean exists() teste si le fichier d´sign´ par le chemin abstrait existe. e e – File getAbsoluteFile() retourne la forme absolue du chemin abstrait. – String getAbsolutePath() retourne le chemin absolu sous la forme d’une chaˆ de ca- ıne ract`res de l’objet File. e – String getName() retourne le nom du fichier ou du r´pertoire d´sign´ par le chemin abstrait. e e e – String getParent() retourne le chemin parent, sous la forme d’une chaˆ de caract`res, ıne e de l’objet File, ou null si ce dernier n’a pas de parent. – File getParentFile() retourne le chemin abstrait parent de l’objet File, ou null si ce dernier n’a pas de parent. – String getPath() convertit l’objet File vers un chemin sous forme de chaˆ de caract`res. ıne e int hashCode() cacule un hash code pour l’objet File. – boolean isAbsolute() teste si le chemin abstrait est absolu. – boolean isDirectory() teste si le fichier d´sign´ par le chemin abstrait est un r´pertoire. e e e – boolean isFile() teste si le fichier d´sign´ par le chemin abstrait est un fichier normal. e e – boolean isHidden() teste si le fichier d´sign´ par le chemin abstrait est un fichier cach´. e e e – long lastModified() retourne le temps de la derni`re modification du fichier donn´ par le e e chemin abstrait. – long length() Renvoie la longueur du fichier d´sign´ par le chemin asbtrait. e e – String[] list() retourne un tableau de chaˆ ınes de caract`res indiquant les fichiers et e r´pertoires dans le r´pertoire sp´cifi´ par le chemin abstrait. e e e e – boolean mkdir() cr´e le r´pertoire d´sign´ par le chemin abstrait. e e e e – boolean mkdirs() cr´e le r´pertoire et ´ventuellement ses r´pertoires parents d´sign´s par e e e e e e le chemin abstrait. – boolean renameTo(File dest) renomme le fichier d´fini par le chemin abstrait. e – boolean setLastModified(long time) fixe le temps de la derni`re modification du fichier e ou du r´pertoire d´sign´ par le chemin abstrait. e e e – boolean setReadOnly() marque le fichier ou le r´pertoire nomm´ par le chemin abstrait de e e telle fa¸on que des op´rations en lecture seule sont autoris´es. c e e7.2 Les flux L’´criture et la lecture de fichiers impliquent l’utilisation de flux (streams). Ces derniers erepr´sentent des canaux de transmission de donn´es ` partir d’une source ou vers une destination. e e a Dans ces canaux, deux types d’informations peuvent transiter de l’application vers un fichierou inversement. Il s’agˆ de flux de donn´es binaires ou de caract`res. Cette distinction permet de ıt e etraiter diff´remment les fichiers textes dont l’extension peut ˆtre .txt, .ini, .log, .xml, etc., et les e efichiers binaires comme les images, vid´os, sons et autres... e Les flux sont ´galement capables de faire transiter des informations provenant d’une entr´e e estandard (System.in) telle que le clavier, ou allant vers une sortie standard (System.out) commel’´cran. e Ainsi, on distingue quatre familles de flux appel´s ´galement flots : e e – Les flots en lecture ou d’entr´e, e – Les flots en ´criture ou de sortie, e
    • ´7.3. LECTURE/ECRITURE 111 – Les flots binaires, – Les flots de caract`res. e Les flots d’entr´e et de sortie peuvent ˆtre utilis´s pour n’importe quel p´riph´rique, ` l’image e e e e e ad’un ´cran, d’une imprimante, d’un fichier disque ou du r´seau (sortie du programme) et d’un e eclavier, d’une souris, d’un ordinateur distant ou d’un fichier disque (entr´e du programme). e Il est possible de combiner les flux ci-dessus, de cette fa¸on : c – Les flots binaires en lecture, – Les flots binaires en ´criture, e – Les flots de caract`res en lecture, e – Les flots de caract`res en ´criture. e e Les flux sont unidirectionnels, et poss`dent donc seulement une entr´e et une sortie. Ils ne e epeuvent envoyer des informations que dans un seul et unique sens. Les classes appropri´es pour l’utilisation des flux se trouvent dans le paquetage java.io. e On distingue quatre classes principales dont toutes les autres h´ritent des repr´sentations et e ecomportements propre ` chaque famille. a – java.io.InputStream (flot binaire en lecture), – java.io.OutputStream (flot binaire en ´criture), e – java.io.Reader (flot de caract`res en lecture), e – java.io.Writer (flot de caract`res en ´criture). e e7.3 Lecture/´criture e Voici un exemple de classe effectuant une lecture/´criture d’un fichier. Dans un premier temps, eon lit le contenu d’un fichier nomm´ "poeme.txt" et on range chacune des lignes dans une structure ede type StringBuffer (cf le chapitre pr´c´dent pour ce type). Dans un second temps, on ´crit e e edans un fichier nomm´ "poeme copie.txt", on commence par y ´crire Ma chaine puis un saut de e eligne, ensuite on ´crit le contenu stock´ dans un StringBuffer. e eimport java.io.*;class GestionFichier { public static void litEtEcrit(String args[]) { StringBuffer contenu = new StringBuffer(); try{ //exemple de lecture File cheminAbstraitEntree = new File("poeme.txt"); FileReader fluxLectureTexte = new FileReader(cheminAbstraitEntree); BufferedReader tamponLecture = new BufferedReader(fluxLectureTexte); String ligne; while((ligne = tamponLecture.readLine()) != null){ System.out.print (ligne); contenu.append(ligne); contenu.append("rn"); } tamponLecture.close(); fluxLectureTexte.close(); } catch(IOException e) { System.err.println("Erreur de lecture"); }
    • 112 ´ CHAPITRE 7. LES ENTREES/SORTIES try{ //exemple d’´criture e File cheminAbstraitSortie = new File("poeme_copie.txt"); FileWriter fluxEcritureTexte = new FileWriter(cheminAbstraitSortie); BufferedWriter tamponEcriture = new BufferedWriter(fluxEcritureTexte); tamponEcriture.write("Ma chainen"); tamponEcriture.flush(); tamponEcriture.write(contenu.toString()); tamponEcriture.flush(); tamponEcriture.close(); fluxEcritureTexte.close(); } catch(IOException e) { System.err.println("Erreur d’´criture"); e } }} On commence par cr´er une variable de type File. Ensuite, dans le cas d’une lecture de fichier, eon cr´e une flux de type FileReader et ce flux est mis dans un tampon de type BufferedReader. eLa lecture dans le tampon se fait ` l’aide de la m´thode readLine(). Pour l’´criture, on cr´e a e e eun flux de type FileWriter, que l’on met dans un tampon BufferedWriter et l’´criture se fait ea` l’aide de la m´thode write. La m´thode flush sert ` vider le contenu du tampon. A chaque e e afois, les diff´rents flux doivent ˆtre d’abord ouverts (instructions new), puis ferm´s (instructions e e eclose ` la fin. aNote : pour limiter les acc`s au disque dur, java conserve les caract`res devant ˆtre ´crits dans e e e eun fichier dans un tampon (buffer en anglais), puis ´crit le contenu du tampon dans le fichier elorsque le tampon est plein. Si l’on veut forcer l’´criture du contenu du tampon dans le fichier on epeut utiliser la commande flush. Il faut toujours appliquer flush au moins une fois juste avantla fermeture du fichier.
    • Chapitre 8Quelques ´l´ments de l’API ee8.1 La classe Math La classe Math poss`de 2 constantes Math.PI (le nombre pi) et Math.E (exponentielle e1 ). Elle eposs`de ´galement plusieurs m´thodes statiques, en voici quelques-unes : e e e – Math.random() : retourne un nombre compris entre 0.0 et 1.0 (exclu). – Math.abs(nombreEnArgument) : retourne la valeur absolue du nombre fourni en argument, le type de retour correspond au type de l’argument. – Math.round(decimalEnArgument) : arrondi ` l’entier le plus proche (renvoie un int pour a un float et un long pour un double). – Math.min(nombre1,nombre2) : renvoie le plus petit des 2 arguments. – Math.max(nombre1,nombre2) : renvoie le plus grand des 2 arguments. – Math.sin(nombreDouble) : renvoie le sinus du nombre, le type de retour est double. Les fonctions cos, tan, acos, asin, atan sont ´galement disponibles. e – Math.pow(nombre1,nombre2) : renvoie nombre1nombre2 , retour de type double. – Math.log(nombreDouble) : renvoie le logarithme n´p´rien d’un nombre, retour de type e e double. – Math.sqrt(nombreDouble) : renvoie la racine carr´ d’un nombre, retour de type double. e Il en existe quelques autres, ` vous d’aller les consulter dans l’API. a8.2 Les classes enveloppes pour les valeurs primitives Il est parfois n´cessaire de traiter des valeurs primitives comme des objets, par exemple pour eles stocker dans des vecteurs (ArrayList, Vector, . . .), ensembles ou tables de correspondance(HashMap). En effet, on ne peut pas ajouter un entier, par exemple, directement dans un ArrayListpuisque celui-ci ne peut contenir que des objets. Il existe une classe enveloppe (un wrapper) pour chaque type primitif. Elles trouvent dans lepackage java.lang, vous n’avez donc pas besoin de les importer. Elles sont faciles ` reconnaˆ a ıtreparce que chacune d’elles est nomm´e d’apr`s le type primitif qu’elle enveloppe, mais la premi`re e e elettre est une majuscule pour respecter la convention de nommage des classes. Voici les 8 classesenveloppe qui existent, notez que la classe Integer correspond aux int, que la classe Characteraux char, et que les autres classes ont le mˆme nom que leur type associ´. e e – Boolean – Character – Byte – Short – Integer – Long – Float 113
    • 114 ´ ´ CHAPITRE 8. QUELQUES ELEMENTS DE L’API – DoubleVoici maintenant comment faire pour envelopper une valeur et revenir au type primitif. On trans-met la valeur au constructeur de la classe enveloppe.int i = 145;Integer valeurI = new Integer(i);...int valeurOriginale = valeurI.intValue();Notez que toutes les classes fonctionnent de la mˆme mani`re, Boolean a une m´thode booleanValue(), e e eCharacter a une m´thode characterValue(), etc. e Ces classes ont ´galement des m´thodes statiques tr`s utiles comme Integer.parseInt(). e e eDe mani`re g´n´rale, les m´thodes de transformation parseXXX() acceptent une valeur de type e e e eString et retournent une valeur de type primitif.String s = "2";int x = Integer.parseInt(s);double d = Double.parseDouble("420.24");//Attention petite diff´rence pour les booleens e//qui n’acceptent que des valeurs true/falseboolean b = new Boolean("true").booleanValue();Notez que lorsqu’une chaˆ de caract`re ne peut ˆtre convertie, une exception NumberFormatException ıne e epeut se produire. Elle se produit ` l’ex´cution, vous n’ˆtes pas oblig´ de la g´rer ou de la d´clarer. a e e e e e Nous pouvons ´galement faire l’inverse : transformer un nombre en chaˆ de caract`res. Il e ıne eexiste 2 m´thodes principales : edouble d = 42.5;String doubleString1 = "" + d;String doubleString2 = Double.toString(d);8.3 Les collections8.3.1 D´finition e Les principales structures de donn´es des classes utilitaires (java.util) sont regroup´es sous e eune mˆme interface Collection. Cette interface est impl´ment´ par des ensembles, vecteurs dyna- e e emiques, tables associatives que nous allons voir dans cette partie. Les ´l´ments de type collection eeposs`dent des m´thodes pour ajouter, supprimer, modifier des ´l´ments de type divers. Elles e e eepeuvent ˆtre parcourues ` l’aide d’it´rateur (autrefois ceux-ci portaient le nom d’´numeration). e a e eNous verrons une illustration des diff´rentes possibilit´s des collections lors des descriptions des e eclasses pr´sent´es ci-dessous impl´mentant l’interface Collection (nous ne verrons cependant pas e e ela classe LinkedList mais ses fonctionnalit´s sont proches de celles des autres classes). e Notez que lorsque que l’ordre des ´l´ments est important la m´thode compareTo (d´j` vue lors ee e eade la partie sur la classe Object) est utilis´e. e8.3.2 ArrayList Il s’agit d’une sorte de tableau d’objets de taille variable, fonctionnant comme une sorte deliste. Il peut ˆtre vu comme un vecteur. e
    • 8.3. LES COLLECTIONS 115ConstructionArrayList v = new ArrayList(); //vecteur dynamique videAjout d’un ´l´ment eeObject elem;...v.add(elem);Taille de la liste On utilise la m´thode size() qui renvoie le nombre d’´l´ments contenus dans e eela liste.Suppression d’un ´l´ment eeObject o = v.remove(3); //supprime le 3eme ´l´ment que l’on obtient dans o e e //l’element renvoy´ est de type objet e //les ´l´ments suivants sont d´cal´s vers la gauche e e e ev.removeRange(3,8); //supprime les ´l´ments de rang 3 ` 8 e e aAcc`s aux ´l´ments e eeArrayList v = new ArrayList();...for(int i=0;i<v.size();i++){ System.out.println(v.get(i)+" ");}Syste.out.println();Modifier un ´l´ment ` l’indice i ee aArrayList v = new ArrayList();Object o;...Object o1 = v.set(i,o);La m´thode set renvoie la valeur de l’objet ` l’indice i avant modification. e aParcours ` l’aide d’un it´rateur a eListIterator it = v.listIterator();while(it.hasNext()){ Object o = it.next(); ...}Autes m´thodes e – La m´thode boolean contains(Object o) renvoie true si l’objet est dans la liste et false e sinon. – boolean isEmpty() renvoie true si la liste est vide et false sinon. – int indexOf(Object o) renvoie l’indice de l’objet o dans la liste ou -1 s’il n’est pas pr´sent e
    • 116 ´ ´ CHAPITRE 8. QUELQUES ELEMENTS DE L’APIL’ancienne classe Vector Dans ses versions ant´rieures, on y trouvait une classe Vector permettant comme ArrayList ede manipuler des vecteurs dynamiques. Cette classe est synchronis´e, c’est-`-dire que 2 processus e aconcurrents (threads) peuvent acc´der au mˆme vecteur. e e Dans la version 5 de Java, la classe Vector a ´t´ fortement remani´e et offre de nouvelles ee epossibilit´s (` la fois en facilit´ d’´criture et en fonctionnalit´s). A vous de d´couvrir cette nouvelle e a e e e eclasse Vector.8.3.3 Les ensembles Deux classes impl´mentent la notion d’ensemble : HashSet et TreeSet. Un ensemble est une ecollection non ordonn´e d’´l´ments, un ´l´ment ne pouvant apparaˆ qu’au plus une fois. Nous e ee ee ıtrenous focaliserons plutˆt ici sur la notion de HashSet. oConstruction et parcoursHashSet e1 = new HashSet(); // ensemble videHashset e2 = new HashSet(c); // ensemble contenant tous les elements d’une collection c Un parcours d’un ensemble se fait ` l’aide d’un it´rateur. a eHashSet e;...Iterator it = e.iterator();while(it.hasNext()){ Object o = it.next(); ....}Ajout d’un ´l´m´nt ee eHashSet e;Object elem;...boolean existe = e.add(elem);if(existe) Sytem.out.println(elem+" existe deja");else Sytem.out.println(elem+" a ete ajoute");SuppressionHashSet e;Object elem;...boolean existe = e.remove(elem);if(existe) Sytem.out.println(elem+" a ete supprime");else Sytem.out.println(elem+" n’existe pas");Autre possibilit´. eHashSet e;...Iterator it = e.iterator();it.next(); it.next();it.remove();
    • 8.3. LES COLLECTIONS 117Op´rations ensemblistes e – e1.addAll(e2) place dans e1 tous les ´l´ments de e2. ee – e1.retain(e2) garde dans e1 tout ce qui appartient ` e2. a – e1.removeAll(e2) supprime de e1 tout ce qui appartient ` e2. aNotion de Hachage Un ensemble HashSet est impl´ment´ par une table de hachage, c’est-`- e e adire que ses ´l´ments sont stock´s selon une position donn´e. Cette position est d´finie selon un code ee e e ecalcul´ par la m´thode int hashCode() utilisant la valeur effective des objets. Les classes String e eet File par exemple impl´mentent d´j` cette m´thode. Par contre les autres classes utilisent par e ea ed´faut une m´thode d´riv´e de Object qui se content d’utiliser comme valeur la simple adresse e e e edes objets (dans ces conditions 2 objets de mˆme valeur auront toujours des codes de hachage ediff´rents). Si l’on souhaite d´finir une ´galit´ des ´l´ments bas´s sur leur valeur effective, il faut e e e e ee ered´finir la m´thode hashCode dans la classe correspondante. e e Voici une exemple avec la classe Point. La red´finition de la m´thode equals sert ` d´finir e e a el’´galit´ entre les objets de mani`re ` n’avoir qu’un seul ´l´ment dans un ensemble (pour rappel e e e a eedans un HashSet les ´l´ments ne peuvent apparaitre qu’une seule fois). eeimport java.util.*;class Point{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; } public int hashCode() { return x+y; } public boolean equals(Object pp) { Point p = (Point) pp; return ((this.x=p.getX()) && (this.y==p.getY())); } public String toString() { return "["+x+" "+"] "; } public int getX() { return x; } public int getY() { return y; }}public class EnsPt{ public static void main(String [] args) { Point p1 = new Point(1,3);
    • 118 ´ ´ CHAPITRE 8. QUELQUES ELEMENTS DE L’API Point p1 = new Point(2,2); Point p1 = new Point(4,5); Point p1 = new Point(1,8); Point [] p = {p1, p2, p1, p3, p4, p3}; HastSet ens = new HashSet(); for(int i=0; i<p.length; i++) { System.out.print("le point "+p[i]); boolean ajoute = ens.add(p[i]); if(ajoute) System.out.println(" a ete ajoute"); else System.out.println(" est deja present"); System.out.print("ensemble : "); affiche(ens); } } public static void affiche(HashSet ens) { Iterator iter = ens.iterator(); while(iter.hashNext()) { Point p = (Point) iter.next(); System.out.print(p); } System.out.println(); }}R´sultat. ele point [1 3] a ete ajouteensemble = [1 3]le point [2 2] a ete ajouteensemble = [2 2] [1 3]le point [1 3] est deja presentensemble = [2 2] [1 3]le point [4 5] a ete ajouteensemble = [4 5] [2 2] [1 3]le point [1 8] a ete ajouteensemble = [1 8] [4 5] [2 2] [1 3]le point [4 5] est deja presentensemble = [1 8] [4 5] [2 2] [1 3]Remarque la fonction de hachage est dict´e par la simplicit´, des points de coordonn´es diff´rentes e e e epeuvent avoir la valeur de hashCode. Il faudrait trouver une fonction qui renvoie une valeur uniquepour chaque point.8.3.4 Les algorithmesRecherche de maximum ou minimumimport java.util.*;
    • 8.3. LES COLLECTIONS 119/*la methode compareTo est definie dans l’interface Comparableclass Point implements Comparable{ private int x,y; public Point(int x,int y) { this.x = x; this.y = y; } /*ordre simple defini sur la valeur de x*/ public int compareTo(Object pp) { (Point) p = (Point) pp; if(this.x < p.getX()) return -1; else if(this.x==p.getX()) return 0; else return 1; } public String toString() { return "["+x+" "+y+"]"; } public int getX() {return x;} public int getY() {return y;}}public class MaxMin{ public static void main(String [] args) { Point p1 = new Point(1,3); Point p2 = new Point(2,2); Point p3 = new Point(4,5); Point p4 = new Point(1,8); ArrayList l = new ArrayList(); l.add(p1); l.add(p2); l.add(p3); l.add(p4); /*Max selon compareTo de Point*/ Point pMax1 = (Point)Collections.max(l); //max suivant compareTo System.out.println("Max suivant compareTo "+pMax1); }}R´sultat. eMax suivant compareTo = [4 5]Algorithme de tris et m´langes eExemple complet. L’ordre utilis´ est celui d´finit par la m´thode compareTo ; e e eimport java.util.*;
    • 120 ´ ´ CHAPITRE 8. QUELQUES ELEMENTS DE L’APIpublic class Tri{ public static void main(String [] args) { int nb[] = {4, 9, 2, 3, 8, 1, 3, 5}; ArrayList t = new ArralyList(); for(int i = 0; i<nb.length; i++) t.add(new Integer(nb[i])); System.out.println("t initial = "+t); Collections.sort(t); //tri des ´lements de t e System.out.println("t trie = "+t); Collections.shuffle(t); //melange des ´lements de t e System.out.println("t melange = "+t); Collections.sort(t,Collections.reverseOrder()); //tri des ´lements de t en ordre inverse e System.out.println("t trie inverse= "+t); }}R´sultat. et initial = [4, 9, 2, 3, 8, 1, 3, 5]t trie = [1, 2, 3, 3, 4, 5, 8, 9]t melage = [9, 2, 1, 4, 3, 5, 3, 8]t trie inverse= [9, 8, 5, 4, 3, 3, 3, 1]8.3.5 Les tables associatives (HashMap) Une table associative (ou de hachage) permet de conserver une information association deuxparties nomm´es cl´ et valeur. Elle est principalement destin´e ` retrouver la valeur associ´e ` une e e e a e acl´ donn´e. Les exemples les plus caract´ristiques de telles tables sont : e e e – le dictionnaire : ` un mot (cl´) on associe une valeur qui est sa d´finition, a e e – l’annuaire usuel : ` un nom (cl´) on associe une valeur comportant le num´ro de t´l´phone a e e ee et ´ventuellement une adresse, e – l’annuaire invers´ : ` un num´ro de t´l´phone (qui devient la cl´) on associe une valeur e a e ee e comportant le nom et ´ventuellement une adresse. e Ces tables sont tr`s utilis´es lorsque l’on souhaite manipuler des donn´es provenant de bases e e ede donn´es : on peut associer ` un enregistrement un ensemble de valeurs. e aAjout d’informationHashMap m = new HashMap(); //table vide...m.put("p",new Integer(3)); //ajoute ` la table m un nouvel element a //associant la cl´ "p" (String) ` la valeur 3 (Integer) e a Si la cl´ fournie ` put existe d´j`, la valeur associ´e remplacera l’ancienne (une cl´ donn´e ne e a ea e e epouvant figurer qu’une seule fois dans la table). put fourni en retour soit l’ancienne valeur si lacl´ existait d´j` soit null. e ea Les cl´s et les valeurs doivent obligatoirement ˆtre des objets. Il n’est pas n´cessaire que les e e ecl´s soient de mˆme type, pas plus que les ´l´ments, ce sera cependant souvent le cas pour des e e eeraisons ´videntes de facilit´ d’exploitation de la table. e e
    • 8.3. LES COLLECTIONS 121Recherche d’informationObject o = m.get("x");if(o==null) System.out.println("Aucune valeur associ´e ` la cl´"); e a eif(m.containsKey("p")) Integer n = (Integer) m.get("p");Suppression d’informationObject cle = "x";Object val = m.remove(cle); //supprime cle+valeur de cle xif(val!=null) System.out.println("On a supprime l’element de cle "+cle+" et de valeur"+val);else System.out.println("la cl´ "+cle+" n’existe pas"); eParcours d’une table : la notion de vueHashMap m;....Set entrees = m.entrySet(); //entrees est un ensemble de pairesIterator iter = entrees.iterator();while(iter.hasNext()){ Map.Entry entree = (Map.Entry) iter.next(); //paire courante Object cle = entree.getKey(); //cle de la paire courante Object valeur = entree.getValue(); //valeur de la paire courante ...}L’ensemble renvoy´ par entrySet n’est pas une copie de la table, c’est une vue. eAutre vues – L’ensemble des cl´s : e HashMap m; ... Set cles = m.keySet(); – La collection des valeurs : Collection valeurs = m.values();Exemple completimport java.util.*;public class Map1{ public static void main(String [] args) { HashMap m = new HashMap(); m.put("c","10"); m.put("f","20"); m.put("k","30"); m.put("x","40"); m.put("p","50"); m.put("g","60"); System.out.println("map initial "+m); //retrouver la valeur associ´e ` la cl´ "f" e a e String ch = (String) m.get("f");
    • 122 ´ ´ CHAPITRE 8. QUELQUES ELEMENTS DE L’API System.out.println("Valeur associ´e ` f e a "+ch); //ensemble des valeurs Collection valeurs =m.values(); System.out.println("Liste des valeurs initiales : "+valeurs); valeurs.remove("30");//on supprime la valeur "30" par la vue associee Sytem.out.println("liste des valeurs apres suppression : "+valeurs); //ensemble des cles Set cles = m.keySet(); System.out.println("liste des cles initiales : "+cles); cles.remove("p"); //on supprime la cle "p" par la vue associee System.out.println("liste des cles apres suppression : "+cles); //modification de la valeur associee a la cle x Set entrees = m.entrySet(); Iterator Iter = entrees.iterator(); while(iter.hasNext()) { Map.Entry entree = (Map.Entry) iter.next(); String valeur = (String) entree.getValue(); if(valeur.equals("20")) { System.out.println("Valeur 20 trouvee en cle "+(String)entree.getKey()); iter.remove(); break; } } System.out.println("map apres supression element 20 "); //on supprime l’element de cle "f" m.remove("f"); System.out.println("map apres suppression f: "+m); System.out.println("liste des cles apres suppression f : "+cles); System.out.println("liste des valeurs apres suppression de f : "+valeurs); }}R´sultat. emap initial : {c=10, x=40, p=50, k=30, g=60, f=20}valeur associee a f : 20liste des valeurs initiales : {10, 40, 50, 30, 60, 20}liste des valeurs apres suppression : {10, 40, 50, 60, 20}liste des cles initiales : [c, x, p, g, f]liste des cles apres suppression : [c, x, g, f]valeur associee a x avant modif : 40map apres modif de x {c=10, x=25, g=60, f=20}liste des valeurs apres modif de x : [10, 25, 60, 20]valeur 20 trouvee en cle fmap apres supression element 20 : {c=10, x=25, g=60}map apres suppression f : {c=10, x=25, g=60}liste des cles apres suppression f : [c, x, g]liste des valeurs apres suppresion de f : [10, 25, 60]Note. Vous pourrez rencontrer la classe Hashtable qui est l’ancˆtre de la classe HashMap. e
    • 8.4. DIVERS 1238.4 Divers8.4.1 El´ments disponibles ` partir de Java 1.5 e a Il existe plusieurs instructions et structures qui ont ´t´ ajout´es ` partir de la version 1.5. Nous ee e aindiquons deux principales ici, ` vous de d´couvrir les autres si vous souhaitez aller plus loin. a eBoucle for am´lior´e e e Une nouvelle boucle for a ´t´ ajout´e au language dans le but d’all´ger l’´criture de deux ee e e esortes de boucles fr´quemment utilis´es : le parcours d’un tableau et le parcours d’une collection. e e – Si un tableau contient des ´l´ments d’un certain type TypeElement (qui peut-ˆtre un type ee e primitif, un tableau ou une classe), la boucle for(int i=0;i<tableau.length;i++) { lancerMethode(tableau[i]); } peut ˆtre ´crite plus simplement : e e for(TypeElement elt : tableau) lancerMethode(elt); – si liste est une structure de donn´e capable d’ˆtre parcourue par un it´rateur (c’est-`-dire e e e a un objet de type Collection) et contenant toujours des ´lements de type TypeElement, la e boucle for(Iterateur it=liste.iterator() ; it.hasNext() ; ) lancerMethode( (TypeElement) it.next()); peut ˆtre ´crite plus simplement : e e for(TypeElement elt: liste) lancerMethode(elt);8.4.2 G´n´ricit´ e e e Si on souhaite d´finir une collection (vector, arraylist, ...) contenant un ensemble d’objets de esorte que tous ces objets soient de type TypeObjet, on peut d´finir des collections ne contenant que ece type d’objet en d´clarant : List<TypeElement>. Ceci permet de v´rifier que l’ajout d’´l´ments e e eea` la liste sont bien de type TypeElement et que lors d’acc`s ` des ´l´ments de la liste on a la e a eecertitude qu’ils sont bien de type TypeElement. Un petit exemple.Vector<TypeElement> v=new Vector<TypeElement>(); //d´claration e...//on peut ajouter uniquement des objets de TypeElement//ici monobjet doit etre obligatoirement de ce typev.add(monobjet);...//on peut r´cup´rer directement des objets TypeElement e efor(int i=0;i<v.size();i++){ TypeElement e=v.get(i); lancerMethode(e);}8.4.3 R´flection et Manipulation des types e Note : cette section sort du cadre de ce cours et est l` uniquement ` titre d’information. Le a a
    • 124 ´ ´ CHAPITRE 8. QUELQUES ELEMENTS DE L’APIcontenu de cette section est tir´ du polycopi´ Java d’Henri Garreta. e e La classe java.lang.Class et les classes du paquet java.lang.reflect (aux noms ´vocateurs, ecomme Field, Method, Constructor, Array, etc.) offrent la possibilit´ de pratiquer une cer- etaine introspection : un objet peut inspecter une classe, ´ventuellement la sienne propre, acc´der e ea` la liste de ses membres, appeler une m´thode dont le nom n’est connu qu’` l’ex´cution, etc. Une e a einstance de la classe java.lang.Class repr´sente un type (c’est-`-dire un type primitif ou une e aclasse). Supposons que nous ayons une variable d´clar´e ainsi : Class uneClasse; e e Nous avons plusieurs mani`res de lui donner une valeur : e – une classe-enveloppe d’un type primitif (Integer, Double, etc.) poss`de une constante de e classe TYPE qui repr´sente le type primitif en question ; de plus, l’expression type.class e a le mˆme effet. Ainsi, les deux expressions suivantes affectent le type int ` la variable e a uneClasse : uneClasse = Integer.TYPE; uneClasse = int.class; – si uneClasse est l’identificateur d’une classe, alors l’expression uneClasse.class a pour valeur la classe en question. L’exemple suivant affecte le type java.math.BigInteger ` la a variable uneClasse : uneClasse = java.math.BigInteger.class; Notez la diff´rence entre TYPE et class pour les classes-enveloppes des types primitifs : e Integer.TYPE est le type int, tandis que Integer.class est le type java.lang.Integer. – on peut aussi demander le chargement de la classe, ` partir de son nom compl`tement sp´cifi´. a e e e C’est un proc´d´ plus on´reux que les pr´c´dents, ou la plupart du travail de chargement e e e e e (dont ` la d´tection d’´ventuelles erreurs dans les noms des classes) ´tait fait durant la a e e e compilation alors que, dans le cas pr´sent, il sera fait pendant l’excution. L’exemple suivant e affecte encore le type java.math.BigInteger ` la variable uneClasse : a uneClasse = Class.forName("java.math.BigInteger"); – enfin, le moyen le plus naturel est de demander ` un objet quelle est sa classe. L’exemple a suivant affecte encore le type java.math.BigInteger ` la variable uneClasse : a Object unObjet = new BigInteger("92233720368547758079223372036854775807"); ... uneClasse = unObjet.getClass(); Pour survoler cette question assez pointue, voici un exemple qui illustre quelques unes despossibilit´s de e la classe Class et du paquet reflect. La m´thode demoReflexion ci-dessous, e epurement d´monstrative, prend deux objets quelconques a et b et appelle successivement toutes eles m´thodes qui peuvent ˆtre appel´es sur a avec b pour argument, c’est-`-dire les m´thodes e e e a ed’instance de la classe de a qui ont un unique argument de type la classe de b :
    • ´ ´8.5. LES AUTRES ELEMENTS DE L’API 125import java.lang.reflect.Method;import java.math.BigInteger;public class DemoReflexion { static void demoReflexion(Object a, Object b) { try { Class classe = a.getClass(); Method[] methodes = classe.getMethods(); for (int i = 0; i < methodes.length; i++) { Method methode = methodes[i]; Class[] params = methode.getParameterTypes(); if (params.length == 1 && params[0] == b.getClass()) { Object r = methode.invoke(a, new Object[] { b }); System.out.println( a + "." + methode.getName() + "(" + b + ") = " + r); } } } catch (Exception exc) { System.out.println("Probl‘me : " + exc); } } public static void main(String[] args) { demoReflexion(new BigInteger("1001"), new BigInteger("1003")); }} Le programme pr´c´dent affiche la sortie suivante : e e1001.compareTo(1003) = -11001.min(1003) = 10011001.add(1003) = 2004...1001.gcd(1003) = 11001.mod(1003) = 10011001.modInverse(1003) = 5018.5 Les autres ´l´ments de l’API ee A vous de consulter r´guli`rement l’API pour trouver les classes dont vous pouvez avoir besoin. e eSachez, par exemple, qu’il existe des classes pour traiter des dates, du son, . . .