Programmation Orientée Objets Le Langage JAVA

Module IP1

Programmation Orientee ObjetsLe Langage JAVA

Amaury HabrardUniversite de Saint-Etienne

[email protected]

Mis a jour par Francois-Xavier DupeUniversite d’Aix-Marseille

[email protected]

2

Table des matieres

1 Avant propos 7

2 Introduction : le langage JAVA 92.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.2 Historique du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.2.1 Quelques mots cles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.3 Java et la programmation orientee objet . . . . . . . . . . . . . . . . . . . . . . . . 10

2.3.1 Le concept d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.3.2 Independance vis a vis de la plateforme . . . . . . . . . . . . . . . . . . . . 11

2.4 Structure d’un programme JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.4.1 Que contient un fichier source ? . . . . . . . . . . . . . . . . . . . . . . . . . 112.4.2 Execution d’un programme Java . . . . . . . . . . . . . . . . . . . . . . . . 122.4.3 La machine virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.4.4 La methode main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.4.5 Utilisation d’arguments dans la fonction main . . . . . . . . . . . . . . . . . 13

2.5 Installation et utilisation de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.6 Types, expressions et structures de controle fondamentales . . . . . . . . . . . . . . 15

2.6.1 les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15La notion de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15le type entier (int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Les flottants/reels (float ou double) . . . . . . . . . . . . . . . . . . . . . . 16Le type caractere (char) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Le type booleen (boolean) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Initialisations et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.6.2 Operateurs et expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Operateurs arithmetiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Operateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Operateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Operateurs d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Operateur conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Priorite des operateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.6.3 Les structures de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Les instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . 24

2.6.4 Les elements specifiques au langage JAVA . . . . . . . . . . . . . . . . . . . 252.7 Une premiere introduction au type String . . . . . . . . . . . . . . . . . . . . . . . 252.8 Regles d’ecriture d’un programme JAVA . . . . . . . . . . . . . . . . . . . . . . . 26

3

4 TABLE DES MATIERES

2.8.1 Les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.8.2 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

2.8.3 Mots cles reserves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 croises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3 La notion d’objets : definition et utilisation 31

3.1 Introduction au developpement objets . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.2 La notion de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.2.1 Exemple de classe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.2.2 Creation d’un objet a l’aide d’une classe . . . . . . . . . . . . . . . . . . . . 34

3.2.3 Exemple d’utilisation dans un programme complet . . . . . . . . . . . . . . 35

3.3 La notion de constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.4 Affectation et comparaison d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.4.1 La reference null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.5 Le ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.6 L’encapsulation de donnees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.7 Champs et methodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.7.1 Variables statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.7.2 Les methodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.8 Surdefinition/surcharge de methodes . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.8.1 Surdefinition de constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.9 La copie d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.10 Autoreferencement : le mot cle this . . . . . . . . . . . . . . . . . . . . . . . . . . 47

3.11 Remarques sur la definition de methodes . . . . . . . . . . . . . . . . . . . . . . . . 49

3.11.1 Methodes de type procedures et fonctions . . . . . . . . . . . . . . . . . . . 49

3.11.2 Les arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.11.3 Les variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.11.4 La recursivite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.12 Les paquetages (packages) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.12.1 Attribution d’une classe a un paquetage . . . . . . . . . . . . . . . . . . . . 51

3.12.2 Utilisation d’une classe situee dans une paquetage . . . . . . . . . . . . . . 52

3.12.3 Droits d’acces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.13 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.13.1 Declaration et creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.13.2 Tableau en argument ou en retour . . . . . . . . . . . . . . . . . . . . . . . 56

3.13.3 Les tableaux a plusieurs indices . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.14 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

3.14.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

3.14.2 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

3.14.3 Compilateur 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

3.14.4 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

3.14.5 Compilateur 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

3.14.6 Mots croises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

3.14.7 Mots croises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

TABLE DES MATIERES 5

4 Les concepts d’Heritage et de Polymorphisme 694.1 Presentation et definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694.2 Construction et initialisation des objets derives . . . . . . . . . . . . . . . . . . . . 724.3 Redefinition, surdefinition et heritage . . . . . . . . . . . . . . . . . . . . . . . . . . 74

4.3.1 Redefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744.3.2 La surchage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754.3.3 En resume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

4.4 Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754.4.1 Tableaux heterogenes d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . 774.4.2 Regles du polymorphisme en Java . . . . . . . . . . . . . . . . . . . . . . . 78

4.5 La super-classe Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784.6 Acces par membres proteges : protected . . . . . . . . . . . . . . . . . . . . . . . 804.7 Methodes et classes finales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804.8 Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804.9 Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

4.9.1 Definition et mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . 824.9.2 Interet des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

4.10 Connaıtre la classe et les types d’un objet . . . . . . . . . . . . . . . . . . . . . . . 834.10.1 L’operateur instanceof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 834.10.2 La class Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

4.11 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854.11.1 Classes abstraites - classes concretes . . . . . . . . . . . . . . . . . . . . . . 854.11.2 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864.11.3 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.11.4 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

5 La gestion d’exceptions 895.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 895.2 Gestion de plusieurs exceptions et transmission d’informations . . . . . . . . . . . 905.3 Derivation et redeclenchement d’exceptions . . . . . . . . . . . . . . . . . . . . . . 935.4 Le bloc finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955.5 Les exceptions standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965.6 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

5.6.1 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975.6.2 Mots croises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

6 Les chaınes de caracteres en Java 996.1 Le type String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

6.1.1 Les chaınes de caracteres sont des objets . . . . . . . . . . . . . . . . . . . . 996.1.2 Affichage d’une chaıne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 996.1.3 Longueur d’une chaıne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 996.1.4 acces aux caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 996.1.5 Concatenation : l’operateur + . . . . . . . . . . . . . . . . . . . . . . . . . . 1006.1.6 Recherche dans une chaıne : la methode indexOf . . . . . . . . . . . . . . . 1006.1.7 La comparaison de chaınes . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

Tester l’egalite de deux chaınes . . . . . . . . . . . . . . . . . . . . . . . . . 100Comparer deux chaınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

6.1.8 Modification d’un caractere . . . . . . . . . . . . . . . . . . . . . . . . . . . 1016.1.9 Extraction de sous-chaınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1016.1.10 Passage en majuscules/minuscules . . . . . . . . . . . . . . . . . . . . . . . 1016.1.11 Conversion d’une chaıne vers un type primitif . . . . . . . . . . . . . . . . . 1016.1.12 Conversion d’un type primitif vers une chaıne . . . . . . . . . . . . . . . . . 1016.1.13 Chaınes et tableaux de caracteres . . . . . . . . . . . . . . . . . . . . . . . . 1026.1.14 Tableau de chaınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

6 TABLE DES MATIERES

6.2 La classe StringBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1026.3 La classe StringTokenizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

7 Les entrees/sorties 1057.1 Les fichiers, la classe File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

7.1.1 Les champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057.1.2 Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057.1.3 Les methodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

7.2 Les flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067.3 Lecture/ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

8 Quelques elements de l’API 1098.1 La classe Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1098.2 Les classes enveloppes pour les valeurs primitives . . . . . . . . . . . . . . . . . . . 1098.3 Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

8.3.1 Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1108.3.2 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

L’ancienne classe Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1128.3.3 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1128.3.4 Les algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

Recherche de maximum ou minimum . . . . . . . . . . . . . . . . . . . . . . 114Algorithme de tris et melanges . . . . . . . . . . . . . . . . . . . . . . . . . 115

8.3.5 Les tables associatives (HashMap) . . . . . . . . . . . . . . . . . . . . . . . . 1168.4 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

8.4.1 Elements disponibles a partir de Java 1.5 . . . . . . . . . . . . . . . . . . . 119Boucle for amelioree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

8.4.2 Genericite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1198.4.3 Reflection et Manipulation des types . . . . . . . . . . . . . . . . . . . . . . 119

8.5 Les autres elements de l’API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Chapitre 1

Avant propos

Ce polycopie de cours a pour objectif d’introduire les concepts fondamentaux de la program-mation objet a l’aide du langage java. Il est compose de 4 chapitres de cours et de 3 chapitrespresentant des elements de la bibliotheque du langage. A l’issue de chaque chapitre de cours, unensemble d’exercices originaux sont proposes. Ces exercices sont complementaires au exercices detravaux diriges et au travaux pratiques. Ils ont pour objectif de faire travailler les notions vues encours sous une forme differente et d’insister sur le vocabulaire specifique a java ou a la program-mation objets, il est donc fortement conseille de chercher serieusement ces exercices. Voici un brefdescriptif des differents chapitres :

— Chapitre 2 : chapitre d’introduction presentant le langage dans sa globalite, son historiqueet les principes de bases pour ecrire un premier programme. On y detaille tous les typesprimitifs, les structures de controles et quelques structures fondamentales du langage. Onpresente egalement les conventions a suivre lorsque l’on programme en Java.

— Chapitre 3 : ce chapitre presente la philosophie du langage : l’objet. On detaille les differentesstructures permettant de declarer et de creer les objets ainsi que les implications de chacuned’elles.

— Chapitre 4 : on y introduit des concepts fondamentaux de la programmation objet l’heritageet le polymorphisme. Ils font la force de ce type de programmation en permettant notam-ment une meilleure lisibilite des programmes et une plus grande facilite de reutilisation del’existant.

— Chapitre 5 : dans ce chapitre la gestion d’erreurs via la notion d’exception est presentee.Ce type de gestion est propre au langage java.

— Chapitre 6 : detail de la plupart des classes de la bibliotheque permettant de gerer deschaınes de caracteres, type fondamental et traiter de maniere specifique en Java.

— Chapitre 7 : presentation des elements permettant de lire des flux et notamment de lire etd’ecrire dans des fichiers.

— Chapitre 8 : chapitre presentant une partie de la bibliotheque. On parle de l’acces a desfonctions mathematiques, de l’utilisation de listes ou de tables associatives, de quelquesalgorithmes utilisables, ansi que la genericite.

Ce document en est a sa troisieme version, il existe de maniere certaine des coquilles, des fautesde frappes, des oublis de mot, des erreurs de code involontaire, des copier/coller non pertinents, . . .Dans le but d’ameliorer ce document, merci de signaler toutes ces erreurs. Si vous avez quelquessuggestions pour ameliorer certaines parties, corriger certaines affirmations, elles sont les bienve-nues.

Bonne lecture et bon travail !

7

8 CHAPITRE 1. AVANT PROPOS

Chapitre 2

Introduction : le langage JAVA

2.1 Presentation

Java est une technologie composee d’un langage de programmation oriente objet et d’un en-vironnement d’execution. Prealablement nomme Oak, il a ete cree par James Gosling et PatrickNaughton chez Sun Microsystems avec le soutien de Bill Joy.

Le langage Java fut officiellement presente le 23 mai 1995 au SunWorld.Java est a la fois un langage de programmation et une plateforme d’execution. Le langage Java

a la particularite principale d’etre portable sur plusieurs systemes d’exploitation tels que Windows,MacOS ou Linux. C’est la plateforme qui garantit la portabilite des applications developpees enJava.

Le langage reprend en grande partie la syntaxe du langage C++, tres utilise par les infor-maticiens. Neanmoins, Java a ete epure des concepts les plus subtils du C++ et a la fois lesplus deroutants, tels que les pointeurs. Les concepteurs ont privilegie l’approche orientee objet desorte qu’en Java, tout est objet a l’exception des primitives (nombres entiers, nombres a virguleflottante, etc.).

Java permet de developper des applications autonomes mais aussi, et surtout, des applicationsclient-serveur. Cote client, les applets sont a l’origine de la notoriete du langage. C’est surtout coteserveur que Java s’est impose dans le milieu de l’entreprise grace aux servlets, le pendant serveurdes applets, et plus recemment les JSP (Java Server Pages) qui peuvent se substituer a PHP etASP.

Les applications Java peuvent etre executees sur tous les systemes d’exploitation pour lesquels aete developpee une plateforme Java, dont le nom technique est JRE (Java Runtime Environment -Environnement d’execution Java). Cette derniere est constituee d’une JVM (Java Virtual Machine- Machine Virtuelle Java), le programme qui interprete le code Java et le convertit en code natif.Mais le JRE est surtout constitue d’une bibliotheque standard a partir de laquelle doivent etredeveloppes tous les programmes en Java. C’est la garantie de portabilite qui a fait la reussite deJava dans les architectures client-serveur en facilitant la migration entre serveurs, tres difficilepour les gros systemes.

Dans le cadre de ce cours notre objectif sera d’etudier les concepts fondamentaux de la pro-grammation objet a l’aide du langage java. Le but est d’acquerir les bases permettant ensuite dedevelopper des applications plus consistantes.

2.2 Historique du langage

— Naissance ≡ 1991 : conception d’un langage applicable a de petits appareils electriques (onparle de code embarque) par la societe Sun Microsystem. La syntaxe est proche du C++,utilisant le concept de machine virtuelle. Le code source est traduit dans un langage uni-versel disposant de fonctionnalites communes a toutes les machines. Ce code intermediaire

9

10 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA

est dit forme de byte code et est compact et portable sur n’importe quelle machine : il suffitqu’elle dispose d’un programme permettant d’interpreter le langage, on parle de machinevirtuelle. Ce projet s’appelait Oak.

— Ete 1992 : premiere presentation interne des possibilites de Oak. Un appareil appele ”StarSeven” permet de visualiser une animation montrant Duke, l’actuelle mascotte de Java.

— 1994 : developpement de HotJava, un navigateur internet entierement ecrit en Java capabled’executer des applets ecrites en byte code.

— 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 bibliotheque).— 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 egalement appele J2SE 5.0 ou Java 5 (≈ 3500 classes).— 2006 : version du J2SE 1.6 egalement appele J2SE 6.0 ou Java 6 (≈ 3800 classes).— 2011 : version du J2SE 1.7 egalement appele J2SE 7.0 ou Java 7 (≈ 3900 classes).— 2014 : version du J2SE 1.8 egalement appele J2SE 8.0 ou Java 8 (≈ 4000 classes).

2.2.1 Quelques mots cles

— JRE : Java Runtime Environnement logiciel permettant d’executer des applications java.— JDK : Java Development Kit logiciel permettant de concevoir et d’executer des applications

java.— J2SDK : Java 2 Software Development Kit meme chose que precedemment.— API : Application Programming Interface (interface de programmation) qui definit la maniere

dont un composant informatique peut communiquer avec un autre. Dans le cas de Java,ce terme designe une bibliotheque de classes et de fonctionnalites mises a disposition duprogrammeur.

— J2EE : Java 2 Platform, Enterprise Edition Java 2 Platform, Enterprise Edition est unespecification pour le langage de programmation Java de Sun plus particulierement destineeaux applications d’entreprise. Dans ce but, toute implementation de cette specificationcontient un ensemble d’extension au cadre d’applications Java standard (J2SE, Java 2standard edition) afin de faciliter la creation d’applications reparties. Voici quelques APIpresentes dans cette extension : Servlets, JSP, JDBC, JAXB, RMI, . . .

— 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 creer automatiquement une documentation

HTML a partir de sources java.— jar programme contenu dans le JDK pour compresser un (ou des programmes java) dans

un seul fichier.

2.3 Java et la programmation orientee objet

La programmation orientee objets se caracterise par 3 points importants :

— une programmation structures,— fiabilite des logiciels accrue,— facilite la reutilisation du code existant.

2.4. STRUCTURE D’UN PROGRAMME JAVA 11

2.3.1 Le concept d’objets

En programmation imperative (par exemple le langage C), un programme est forme de differentesprocedures et structures de donnees generalement independantes des procedures.

En programmation orientee objets, on met en œuvre differents objets. Chaque objet associedes donnees et des methodes agissant exclusivement sur les donnees de l’objet.

— On parle de methodes plutot que de procedures.— On utilisant indifferemment le mot champ, donnee ou encore attribut.

L’encapsulation de donnees : il n’est pas possible d’agir directement sur les donnees d’un objet,il est necessaire de passer par des methodes associees a l’objet. Ces methodes jouent le role d’in-terface obligatoire. L’appel d’une methode peut etre vu comme l’envoi d’un message a un objet.Vu de l’exterieur, un objet se caracterise uniquement par ses specification (donnees attributs) etses methodes.

La notion de classe :— elle generalise la notion de type de donnee— elle permet de decrire un ensemble d’objets ayant une structure de donnees commune et

disposant de memes methodes.— Les objets apparaissent comme des variables d’un type de classe donnee, on parle d’instances

de classe.

La notion d’heritage. Elle permet de definir une nouvelle classe a partir d’une autre. On reutilisecette derniere en bloc et on lui ajoute de nouvelles fonctionnalites. La conception d’une nouvelleclasse, qui herite (recupere) toutes les proprietes et aptitudes de l’ancienne. Il est ainsi possiblede s’appuyer sur des realisations anterieures parfaitement au point et les specifier a volonte. Cecifacilite donc la reutilisation de code ou de logiciel deja existant.

La programmation objet facilite enormement la realisation d’interfaces graphiques. Chaqueelement de l’interface est vu comme un objet, par exemple un objet fenetre, plusieurs objets bou-tons, un objet ascenseur, etc.

2.3.2 Independance vis a vis de la plateforme

La portabilite du code. Un programme est portable si un meme code source peut etre exploitedans des environnements differents moyennant une nouvelle compilation. En Java, il existe lanotion de machine virtuelle java - la JVM (pour Java Virtual Machine) - qui peut executer lememe code sur n’importe quelle plateforme en utilisant un code source sous forme de bytecode : unlangage machine specifique a la plateforme Java. La creation d’un programme Java s’effectue en2 temps : une phase de compilation qui transforme le code source en bytecode. Le code est ensuiteinterprete sur une machine virtuelle Java

2.4 Structure d’un programme JAVA

2.4.1 Que contient un fichier source ?

Un fichier source porte l’extension .java et contient la definition de classe. La definition d’uneclasse est definie par 2 accolades.

public class Chien{

//code de la classe JAVA

}


Une classe contient une ou plusieurs methodes. Par exemple dans la classe Chien, la methodeaboyer() va contenir des instructions specifiant la facon dont un chien aboie. Les methodes sontobligatoirement declarees dans une classe.

public class Chien{

void aboyer()

{

// code de la methode aboyer ou l’on indique comment

// la methode doit etre executee

}

}

2.4.2 Execution d’un programme Java

Source Compilation Execution

On cree un document sourceavec une extension .java, parexemple Toto.java

On compile le(s) fichier(s)source(s) avec le programmejavac, par exemple javac

Toto.java. Si la compilationa reussi, un fichier .class

Toto.class est cree, ce fi-chier est constitue de bytecode

L’execution est lancee en uti-lisant le programme java

avec le nom du fichier princi-pal du programme sans l’ex-tension .class. Par exemplejava Toto.

2.4.3 La machine virtuelle

Un programme s’execute en lancant la JVM sur le fichier principal (Toto.class). Ce fichiercontient du byte code et la JVM traduit ce byte code en code machine comprehensible par laplateforme sous-jacente et execute le programme.

Lorsque la JVM demarre elle cherche la classe specifiee a l’execution, puis elle recherche unemethode speciale – la methode main – qui ressemble exactement a ceci :

public static void main(String [] args)

{

//le code de la methode main

}

La JVM execute ensuite tout ce qui se trouve entre les accolades{ } de la methode main.

2.4.4 La methode main

Toute application java a au moins une methode main. Attention, pas une par classe, mais aumoins une par application. La methode main correspond a l’endroit ou le programme commencea s’executer.

Voici un exemple de programme complet :

public class PremiereAppli{


{

System.out.println("Bonjour a tous");

System.out.println("Je m’appelle toto");

}

}

2.4. STRUCTURE D’UN PROGRAMME JAVA 13

1. Enregistrement dans le fichier PremiereAppli.java

2. Compilation javac PremiereAppli.java

3. Lancement du programme java PremiereAppli

4. Le resultat du programme consiste a afficher les 2 lignes suivantes :Bonjour a tousJe m’appelle toto

2.4.5 Utilisation d’arguments dans la fonction main

Les arguments de la methode main sont places dans le tableau args, qui est un tableau constituede chaınes.

Lors du lancement d’un programme, les arguments se placent a la suite de l’identificateur declasse du programme lance et sont separes par un espace. Exemple :

java AfficheArguments Le langage Java

Voici le programme correspondant :

public class AfficheArguments{


{

for(int i=0;i<args.length;i++)

{

System.out.println("contenu de args[" + i +"] : "+ args[i]);

}

}

}

A l’execution, ce programme affiche le resultat suivant :

contenu de args[0] : Le

contenu de args[1] : langage

contenu de args[2] : Java

N.B. Les arguments sont passes sous la forme de chaınes de caracteres, si nous voulons desnombres nous devons convertir les arguments.

Exemple.

public class Addition2Entiers{


{

int entier1, entier2, resultat;

entier1=Integer.parseInt(args[0]);

entier2=Integer.parseInt(args[1]);

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{


{

final float taux = 6.55957f;

float somme = 0f, 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 developpement java, il suffit de recuperer un outil de developpement(JDK ou SDK) sur http://www.oracle.com/technetwork/java/javase/downloads/index.html,puis de lancer le programme d’installation. Sous linux vous pouvez l’installer par exemple dans/usr/local pour le rendre accessible a tout le monde, ou sous votre compte.

Ensuite nous allons principalement utiliser les programmes situes dans le repertoire bin -/Chemin Installation/jdk1.8.0 10/bin (/Chemin Installation correspondant au repertoired’installation de java), par exemple si vous avez recupere la version 10 du jdk 1.8 - javac, java,

javadoc, jar, . . .). Pour faciliter leur utilisation vous pouvez mettre le repertoire bin dans votrevariable d’environnement PATH (cf le cours systeme). Notez que sous certains systemes linux/unix,certaines distributions java sont pre-installees, mais ne correspondent pas aux versions officiellesfournies par Sun Microsystems.

Pour ecrire nos programmes nous aurons seulement besoin d’un editeur (par exemple emacs

sous linux, ou tout un autre editeur si vous le souhaitez) et d’un terminal (xterm).

Vous pourrez eventuellement avoir de besoin de configurer une variable d’environnement CLASSPATHqui indique les repertoires ou sont situes les programmes java. Ce n’est pas obligatoire, par defautles programmes sont cherches dans le repertoire courant et il est possible d’indiquer des repertoiresen specifiant des options aux differents programmes disponibles dans le jdk (voire la documentationofficielle indiquee dans les liens ci-dessous).

Quand vous serez plus experimente (par exemple a partir du 4eme TP), vous pourrez essayed’autres editeurs facilitant le developpement de programmes java tels qu’eclipse ou NetBeans. Avous de les essayer et eventuellement d’en adopter un. Neanmoins, il est d’abord conseille d’utiliserun editeur non specifique pour commencer, puis de passer a un editeur specialise une fois que l’onmaıtrise les bases du langage.

Pour ceux qui souhaitent essayer leurs programmes sous windows, la procedure d’installation estla meme. Il peut cependant etre necessaire de creer une variable d’environnement supplementaire.Voici la procedure a suivre.

— Verifier que la variable d’environnement JAVA HOME est specifiee.— Si ce n’est pas le cas allez dans Menu Demarrer → Settings → Control Panel → System→ Advanced, menu variables d’environnement. Entrez le nom de JAVA HOME puis sa valeur(par exemple C:2sdk1.8.0 10/).

— Pour verifier tapez echo %JAVA HOME dans une console MS-DOS.

Vous pouvez utiliser la meme methode pour modifier le contenu de la variable PATH ou confi-gurer CLASSPATH. En guise de terminal vous utiliserez alors une console MS-DOS.

2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 15

2.6 Types, expressions et structures de controle fondamen-tales

Cette partie a pour objectif de presenter rapidement l’utilisation des types, des expressionset des instructions de controle en JAVA. Les elements abordes ne sont pas forcement toujourscaracteristiques du langage JAVA mais sont necessaires pour l’utilisation de n’importe quel lan-gage de programmation. Lorsque certaines situations sont specifiques au langage JAVA, nous leprecisons.

2.6.1 les types primitifs

Ils servent a definir les champs (attributs) de toutes les classes que vous pourrez definir, ainsique les variables que vous pourrez utiliser dans les differentes methodes. Attention, les typesprimitifs ne sont pas des classes.

La notion de type

La memoire centrale est un ensemble de ” positions binaires ” appelees. Ces bits sont regroupesen octets, un octet correspondant a 8 bits. Les ordinateurs (actuels) ne savent representer et traiterque des informations representees sous forme binaire. Il est donc necessaire de savoir comment uneinformation a ete codee pour pouvoir attribuer une signification a une suite de bits d’un emplace-ment de la memoire.

Il existe 4 categories de type primitif en JAVA :

— nombres entiers— nombres flottants— caracteres— booleens

le type entier (int)

Il sert a representer les nombres entiers relatifs. Il existe quatre sortes d’entier permettant derepresenter des valeurs differentes. Le tableau suivant decrit chacun de ces types avec le nom dutype, la taille occupee en memoire en octets, la valeur minimale et la valeur maximale possibleavec la constante correspondante dans le langage.

Nom Taille Valeur minimale Valeur maximalebyte 1 -128 127

Byte.MIN VALUE Byte.MAX VALUE

short 2 -32768 32767Short.MIN VALUE Short.MAX VALUE

int 4 -2,147,483,648 2,147,483,647Integer.MIN VALUE Integer.MAX VALUE

long 8 -9,223,372,036,854,775,808 9,223,372,036,854,775,807Long.MIN VALUE Long.MAX VALUE

Les constantes peuvent s’ecrire sous forme decimale (548, -78, +5), ou sous forme hexadecimaleen precisant la valeur de 0x ou 0x (0x1A 0X12), ou octale en faisant preceder la valeur de 0 (032,05).

Une constante entiere est forcement de l’un des types int ou long. On peut forcer une constantea etre du type long en faisant suivre sa valeur de la lettre l ou L, exemple 25L. Le compilateurrejettera toute constante ayant une valeur superieure la capacite du type long.


Les flottants/reels (float ou double)

Il en existe deux sortes. Le tableau suivant decrit chacun d’eux avec leur nom, la taille occupeeen memoire en octets, la precision correspondant au nombre de chiffres significatifs pris en comptedans la partie decimale, la valeur minimale et la valeur maximale possible avec la constantecorrespondante dans le langage.

Nom Taille Precision Valeur absolue minimale Valeur absolue maximalefloat 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 decimale : 12.43 -0.38 -.38 4. .27— 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 defaut toutes les constantes creees sont de type double, pour forcer a avoir un type floaton fait suivre la valeur de la lettre f, exemple : 12.5f

Le type caractere (char)

Les caracteres, designes par le type char, sont codes sur 2 octets, notation d’une constantecaractere : ’a’, ’B’, ’e’, ’+’. Exemplechar lettre=’a’;

Certains caracteres avec notation speciale :

— ’\b’ pour le retour arriere (backspace)— ’\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 booleen (boolean)

Il sert a representer une valeur logique de type vrai ou faux, il existe deux valeurs possibles pourun booleen en java : true et false (pour vrai et faux). Exemple boolean est ordonne=false;.

Attention, en JAVA, les valeurs logiques ne sont pas representees par des valeurs mais par untype specifique : le type boolean, toute utilisation de valeur numerique dans des tests provoqueraune erreur !

Initialisations et constantes

Variables Exemples : int n=15; egalement equivalent a int n; n=15;.

En JAVA, les declarations peuvent apparaıtre a n’importe quel endroit du programme. D’unpoint de vue methodologique, il est souvent conseille d’effectuer la declaration de toutes lesvariables (importantes) ensembles au debut puis de les initialiser avant de les utiliser.

N.B. Les variables n’ayant pas recu de valeur ne peuvent pas etre utilisees sous peine d’aboutira une erreur de compilation. Il est donc important de penser a initialiser les variables des leurcreation.


Constantes : le mot cle final Pour indiquer qu’une variable ne peut pas etre modifiee pendantl’execution d’un programme, on peut utiliser le mot cle final :final int nombre de mois=12;

Toute modification de la variable nombre de mois, de valeur initiale 12, sera rejetee par le compi-lateur.

2.6.2 Operateurs et expressions

Operateurs arithmetiques

Il existe cinq operateurs principaux :— + : 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 probleme de la conversion de type :

float x; float res;

int n; int p;

res=n*x+p;

La variable n etant de type int, x de type float, le compilateur va convertir n en float puis faire lecalcul. Le resultat final sera de type float, comme le montre la Figure 2.1.

*

*

n +

float

px

long

float float

float

+

float

int

Figure 2.1 – Evaluation de res=n*x+p;

La hierarchie de conversion permettant de ne pas denaturer la valeur initiale : int → long

→ float → double.Note : par defaut, pour les types byte, char, short, si un de ces types apparaıt dans une expression,la valeur est d’abord convertie en int. Exemple :short p1=1, p2=1 ,p3=1;

float x=2;

L’evaluation de p1*p2+p3*x est faite comme le montre la Figure 2.2.

* + p3p1 *p2

int int

x

int

float float

float

float

float

int

* *

+

Figure 2.2 – Evaluation de p1*p2+p3*x


Operateurs de comparaison

Ils servent a faire des comparaisons relatives et sont principalement utilises dans les testsconditionnels.

— < : inferieur strictement a— <= : inferieur ou egal a— > : superieur a— >= : superieur ou egal a— == : egal a— ! = : different de.

Ces operateurs peuvent s’utiliser avec des expressions : 2 ∗ a > b + 5, x + y < (a + 2) ∗ 5, . . .Note : ordre sur les caracteres ′0′ <′ 1′ < . . . <′ 9′ <′ A′ <′ B′ < . . . <′ Z ′ <′ a′ < . . . <′ z′.

Operateurs logiques

Ces operateurs permettent de manipuler des valeurs logiques.— ! : negation— & : ”ET”— ∧ : ”OU” exclusif— | : ”OU” inclusif— && : ”ET” avec court-circuit— || : ”OU” inclusif avec court-circuit

Exemples :— (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) dansle cas contraire.

— (a < b) || (c < d), (a < b) | (c < d) : prend la valeur true si l’une au moins des deuxconditions 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 etc < 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 cascontraire. Cette expression possede en fait la meme valeur que a >= b.

— Les deux operateurs && et || possedent une propriete interessante : leur second operande(celui qui figure a droite de l’operateur) n’est evalue que si la connaissance de sa valeurest indispensable pour decider si l’expression est vraie ou fausse. Par exemple, si on al’expression (a < b)&&(c < d), on commence par evaluer (a < b), si le resultat est fauxon n’evalue pas c < d puisque le resultat est deja connu. Les operateurs ∧ et | evaluenttoujours les deux operandes, il est donc plutot conseille d’utiliser les operateurs && et ||.

Operateurs d’affectation

— = : exemples c=b+3; c=i;. L’operateur possede une associativite de gauche a droite, ainsidans l’expression i = j = 5; on evalue j=5 d’abord, puis i=j, i et j ont a la fin la memevaleur 5.Attention aux problemes de conversion, supposons que nous ayons une variable de typeint n et une variable de type float x, l’expression n=x+5; est rejetee par le compilateur.Il faut en fait ecrire n=(int) x + 5;. Il est necessaire de faire une conversion explicite.Les conversions pour lesquelles il n’y a pas besoin de faire une conversion explicite sont lessuivantes :— byte → short → int → long → float → double

— char → int → long → float → double— L’incrementation et la decrementation. Ces operations consistent respectivement a aug-

menter une variable (en general entiere) 1 et a diminuer une variable de 1 (i = i-1; n =

n+1;). Ces operations sont definies par les operateurs ++ et -- : i--; n++; ou --i; ++n;.


Il existe cependant un difference suivant ou est place l’operateur lors de l’evaluation d’uneexpression, s’il est place avant(on parle d’operateur prefixe) la variable l’operation est ef-fectuee avant l’evaluation de l’expression, s’il est place apres (on parle d’operateur postfixe)l’operation est effectuee apres.— n= ++i -5; : on affecte d’abord la valeur 6 a i puis la valeur 1 a n.— n= i++ - 5; : on affecte d’abord la valeur 0 a n puis la valeur 6 a i.

— Affectation elargie, les instructions suivantes sont equivalentes :— i = i + k; et i+=k;Il existe la meme chose avec les operateurs *, / et -.

Conversion de types

Lorsque l’on desire convertir un type vers autre qui a une taille de representation inferieure,les regles suivantes s’appliquent :

— entier vers entier (long vers int, short vert byte, . . .) les octets les moins significatifs sontconserves.

— 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.

Operateur conditionnel

condition ? etape1 : etape2; : si condition est vraie alors etape1 sinon etape2. Exemple :max = a<b ? b :a;

Si a < b, alors la variable max recoit la valeur de la variable b, sinon elle recoit la valeur de lavariable a.

Priorite des operateurs

Operateurs associativite() [] . ++(postfixe) –(postfixe) g a d+(unaire) -(unaire) ++(prefixe) –(prefixe) (unaire) ! cast new d a g/ % g a d+ - g a d<< >> >>> g a d< <= > >= instanceof g a d== != g a d& g a d∧ g a d— g a d&& g a d— g a d? : g a d= += -= *= /= %= <<= >>= >>>= & = | = ∧ = d a g

2.6.3 Les structures de controle

Dans cette partie, les crochets [] signifient que ce qu’ils renferment est facultatif. Il servent soita exprimer le fait que pour lier plusieurs instructions a une structure de controle il est necessairede 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 a indiquer qu’une instruction facultative.

Le terme condition correspond a une expression qui peut etre evaluee sous forme logique (vraiou 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 {


{

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);

}

}

switch

L’instruction switch (branchement) est une instruction de choix, permettant de tester plusieursvaleurs d’une expression. L’expression peut etre de type byte, short, char ou int.

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{


{

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 execute un ensemble d’instructions tant qu’une conditionest vraie.

Syntaxe :

while(condition)

[{]

instruction_1

[instruction_2

...

instruction_n

}]

Exemple

public class Boucle{


{

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("Apres la boucle");

}

}

do-while

Il s’agit d’une boucle faire-tant que similaire a la boucle while sauf que la condition est evalueeapres chaque parcours de boucle. La boucle do-while est executee au moins une fois, alors que laboucle while peut ne jamais etre executee.

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("Apres la boucle");

}

}

for

L’instruction for est une boucle (pour) dont la syntaxe est divisee en trois expressions.Syntaxe :

for([initialisation] ; [condition] ; [incrementation])

[{]

instruction_1

[instruction_2

...

instruction_n

}]

— initialisation est une declaration ou une suite d’expressions quelconques separees pardes virgules, cette partie est evaluee une seule fois avant d’entrer dans la boucle.

— condition est une expression booleenne (logique) quelconque, cette partie conditionne lapoursuite de la boucle et est evaluee avant chaque parcours.

— incrementation est une suite d’expressions quelconques separees par des virgules, cettepartie est evaluee a la fin de chaque parcours.


Exemple 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 precedent est equivalent a

public class ExFor2

{


{

int i;

i=1;

while(i<=5)

{


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 egalement etre ecrit de la maniere suivante :

public class ExFor4

{


{

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 a interrompre le deroulement d’une boucle en passant a

l’instruction situee apres la boucle. L’execution de cette instruction est conditionnee par un choix.Exemple :

public class ExBreak

{


{

int i;

for(i=1;i<=10;i++)

{

System.out.println("debut tour"+i);


if(i==3) break;

System.out.println("fin tour"+i);

}

System.out.println("apres ma boucle")

}

}

Le resultat du programme precedent est le suivant :

debut tour 1

bonjour

fin tour 1

debut tour

bonjour

fin tour 2

debut tour 3

bonjour

apres la boucle

En cas de boucles imbriquees, l’instruction break fait sortir de la boucle la plus interne.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++)

{

System.out.println("debut tour"+i);

if (i<4) continue;

System.out.println("fin tour"+i);

}

System.out.println("apres la boucle");

2.7. UNE PREMIERE INTRODUCTION AU TYPE STRING 25

}

}

Exemple d’execution :

debut tour 1

debut tour 2

debut tour 3

debut tour 4

fin tour 4

debut tour 5

fin tour 5

apres la boucle

2.6.4 Les elements specifiques au langage JAVA

Parmi les points abordes ci-dessus, quatre sont plutot specifiques au langage JAVA.— Le mot cle final qui permet de declarer des constantes a l’aide de variables.— Le type byte qui permet de representer des entiers entre -128 et 127.— Le type boolean pour representer les valeurs true (vrai) et false (faux). Tous les tests

conditionnels doivent etre compatibles avec le type boolean. Mettre une valeur entiere dansun test provoque une erreur de compilation en JAVA (par exemple if(1)... est interditen JAVA).

— Les conversions de type doivent etre explicites en JAVA chaque que l’on veut convertir untype general vers une representation plus petite. Exemple :int n=2;

float x=1.0;

...

n=(int) x;

Un autre element est traite de maniere specifique en JAVA : le type chaıne de caracteres(String). Une introduction est proposee dans la section suivante.

2.7 Une premiere introduction au type String

En JAVA, les chaınes de caracteres sont definies par un type specifique : le type String. Nouspresentons ici une courte introduction, nous reviendrons sur ce type plus tard.

Declaration

String chaineSalutation = "bonjour";

Une chaıne de caractere constante se declare toujours entre guillemets "... ".

Connaıtre la longueur d’une chaıne

int l = chaineSalutation.length();

Acces a un caractere

char cara1 = chaineSalutation.charAt(0);

char cara1 = chaineSalutation.charAt(2);

La variable cara1 contient le caractere b, la variable cara2 contient le caractere n.


Concatenation : l’operateur +

String ch1 = "Bonjour";

String ch2 = " a tous";

String ch = ch1 + ch2;

La variable ch contient la chaıne ”Bonjour a tous”.

Impression d’une chaıne de caracteres

System.out.println(chaineSalutation);

System.out.println(ch1+ch2);

System.out.println(ch);

Comparaison de chaınes La methode equals qui teste l’egalite de deux chaınes de caracteres :ch1.equals(ch2) ou ch1.equals("Bonjour").

La methode compareTo pour comparer deux chaınes de caracteres dans l’ordre lexicographique(alphabetique) : ch1.compareTo(ch2)

— renvoie un entier strictement negatif si ch1 est situee avant ch2 dans l’ordre lexicographique— renvoie un entier strictement positif si ch1 est situee apres ch2 dans l’ordre lexicographique— 0 si ch1 contient la meme chaıne que ch2.

2.8 Regles d’ecriture d’un programme JAVA

Ce document a pour objectif de synthetiser les regles d’ecriture generalement utilisees pour ledeveloppement d’applications en JAVA.

2.8.1 Les identificateurs

Les identificateurs sont des suites de caracteres servant a designer les entites manipulees parun programme (variables, methodes, classes, objets, . . .). En JAVA, un identificateur est forme delettres et de chiffres ou du caractere . Le premier caractere est forcement une lettre A-Z, a-z oueventuellement . Il n’existe aucune limitation sur le nombre de caracteres. Exemples :ligne, valeur 5, total, 56, ma variable 1, i, MaClasse, ...

Attention, on distingue les minuscules des majuscules (ligne 6= Ligne).

Certaines conventions sont traditionnellement utilisees :

— Les noms de variables et de methodes sont ecrits en minuscule sauf s’ils sont formes de lajuxtaposition de plusieurs mots, auquel cas chaque sous-mot, sauf le premier, comporte unemajuscule a la premiere lettre. Exemples : valeur, nombreValeur, tauxEmprunt,

calculNombreReponsesExactes, getX2, ...

— Les noms de classe suivent la meme regle, mais leur premiere lettre est ecrite en majuscule.Exemples : PremierProgramme, Clavier,

CalculMoyenne, ...

Remarque : cette convention permet de distinguer le fait que System est une classe et queout n’en est pas une (System.out.println).

— Des identificateurs successifs doivent etre separes par un espace ou un saut de ligne quandil n’y a pas de separateur ou de syntaxe particuliere. Exemple : x = a + 5; y += 4; Unevirgule est utilisee pour faire plusieurs declarations d’un meme type. Exemple :int x, y;

float n, compteur, total, valeur;

2.8. REGLES D’ECRITURE D’UN PROGRAMME JAVA 27

2.8.2 Commentaires

Il existe trois types de commentaires en JAVA.

— les commentaires commencant par /∗ et se terminant par ∗/, exemple : /* Ceci est un

commentaire usuel*/

— les commentaires de fin de ligne //, exemple :int valeur; // valeur avec commentaire de fin de ligne

— les commentaires de documentation commencant par / ∗ ∗ et finissant par ∗/. C’est un casparticulier des commentaires usuels puisqu’ils commencent de maniere legerement differentepar rapport a ces derniers. Leur interet est de pouvoir etre extrait automatiquement pourfaire de la documentation avec, par exemple, le programme javadoc.

2.8.3 Mots cles reserves

Les mots suivant sont des mots cles reserves pour le langage et ne peuvent etre utilises

abstract boolean break byte casecatch char class const continuedefault do double else extendsfinal finally float for gotoif implements import instanceof intinterface long native new packageprivate protected public return shortstatic super switch synchronized thisthrow throws transient try voidvolatile while

2.8.4 Remarques globales

— Les instructions se terminent par un point virgule ;.— Les blocs de code sont definis entre accolades {}.— On declare une variable avec un nom et un type : int x;.— Un operateur d’affectation est avec un seul signe : =.— Un operateur d’egalite est avec deux signes : ==.— Lorsque l’on ecrit du code, il est imperatif de respecter les regles d’indentation : les ins-

tructions a l’interieur d’un bloc doivent etre decalees a droite, c’est egalement lorsque l’onutilise une structure de controle. La definition de methodes et d’attributs de classes doiventetre indentes par rapport a la definition de la classe elle-meme.

— Pensez a commenter votre code et a bien decrire ce que font vos fonctions et a quoi serventvos 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 differentselements de votre projet. Une archive correctement constituee devrait contenir :

— une bonne documentation comprenant— un Fichier README contenant des informations pour lancer le projet, l’installer, les pre-

requis eventuels et qui documente le contenu de l’archive (liste des fichiers et differentsrepertoires et ce qu’il y a dedans).

— un manuel utilisateur indiquant comment utiliser le logiciel— un manuel technique sur la conception du projet (notamment a destination des developpeurs)

contenant - par exemple - des schemas UML (au moins une description du code consti-tuant le projet), les points a ameliorer, les bugs, les difficultes, les choix .... Pour des


projets java, la documentation technique peut idealement etre completee par une java-doc (important pour continuer le developpement plus tard).

— une architecture correcte : idealement a la racine on a le README et que des sous-repertoires contenant la documentation, le code executable, le code source, les drivers,plus d’autres choses tout le temps dans un sous-repertoire specifique et documente dansle README. Les fichiers sources sont separes des executables, soit dans 2 repertoiresdifferents, soit - idealement - dans un repertoire contenance uniquement les sources et lesexecutables sont stockes dans une archive .jar On mettra dans des repertoires specifiquesdes fichiers de log, de sauvegarde, les images, ...

— Un code de bonne qualite. Le code doit respecter les conventions de nommage java, avoirdes noms de variables explicites, etre indente correctement, et bien commente. On peutdistinguer des commentaires generaux decrivant le contenu d’une classe et son objectif,et des commentaires decrivant une methode et ce qu’elle fait (on les retrouve dans lajavadoc). Ensuite des commentaires internes qui se situent a l’interieur des methodes pourexpliquer des des attributs d’une classe, des variables de methode , des algorithmes, deschoses techniques .... Le code importe d’ailleurs doit etre signale dans la documentiontechnique par exemple et la provenance doit etre indiquee. On peut meme signaler pourquoion a eu besoin de ce code.

— L’archive DOIT etre nettoyee et ne pas posseder de fichiers inutiles pour l’utilisateur(fichiers de log, de sauvegardes, de tests, inutilises, ...)

Ces remarques sont d’ordre generales mais il est pertinent d’essayer de les respecter. Le nomde l’archive doit correspondre au nom du projet, lorsque c’est un travail a rendre a un enseignantil est de bon ton d’ajouter le nom de la personne envoyant le projet. En general, lorsque que l’ondecompresse l’archive, celle-ci doit creer un dossier contenant tous les elements.

Lorsque que vous envoyez une archive par courrier electronique, il est parfois conseille d’indi-quer dans le message le nom de l’archive envoyee (sa taille notamment si elle est volumineuse).Il est egalement judicieux de commencer votre message par une formule de salutation (du genrebonjour) et de terminer par une formule de politesse (Bonne reception, cordialement, ...) et veilleza ne pas oublier de mettre votre nom a la fin du message ! Pensez egalement a mettre un sujetpertinent au message et a vous mettre en copie (cc) notamment lorsque ce sont des projets notesa rendre.

Je vous conseille aussi pour votre activite professionnelle, dans la mesure du possible, d’utiliserune adresse electronique qui ne soit pas trop fantaisiste.

2.8.6 Liens sur la programmation JAVA

Voici quelques liens qui pourront vous permettre de completer vos connaissances en JAVA.Il existe de nombreux liens, en voici une liste non exhaustive pour commencer vos bookmarkspersonnels.

— http://www.oracle.com/technetwork/java/api-141528.html : informations sur les apistandards de java, par versions.

— http://www.oracle.com/technetwork/articles/java/index-141532.html documenta-tion sur les differentes versions de java.

— http://ibiblio.org/javafaq : des nouvelles quotidiennes sur java, un cours en HTML,de nombreux liens

— http://www.java-channel.org : site modifie quotidiennement, contenant des liens versd’autres sites.

— http://www.javaworld.com : nouvelles et articles techniques— http://java.developpez.com/faq/java/ : FAQ en francais— http://www.eclipse.org : un environnement de developpement (IDE - Integrated Deve-

lopment Environment) qui facilite l’ecriture de programmes java.

2.9. EXERCICES DE COURS 29

2.8.7 Bibliographie

Voici quelques references bibliographiques, ce cours est inspire de certaines d’entre elles, cesont des choix non exhaustifs et subjectifs.

— Programmer en Java. Claude Delannoy. Editions Eyrolles.— Java Tete la premiere. Kathy Sierra et Bert Bates. Editions O’Reilly.— Java in a nutshell - manuel de reference. David Flanagan. Editions O’Reilly.— 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 cours

2.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{


{

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");

}

}

}

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’execute, mais il faut ajouter une ligne au programme dans la bouclewhile sinon il boucle sans fin. On peut, par exemple, ajouter x = x + 1; juste apres lewhile et avant le if.

2. Ce fichier ne compile pas, il manque une declaration de classe pour mettre la methode main

dedans, par exemple public class Test{ et il faudra rajouter une accolade } a la fin.

3. Ce fichier ne compile pas, une classe doit avoir au moins une methode (par forcement unemethode main).

2.9.2 Mots croises

19

1817

1615

14

131211

10

98

76

54

321

HORIZONTALEMENT

4 Commande pour executer un programmejava (-)

8 Entier (-)

9 Prefixe (-)

10 Acronyme d’un fabricant de puces (-)

11 Pour afficher quelque chose (-)

15 A beaucoup de caracteres (-)

16 Annoncer une nouvelle classe ou unemethode (-)

17 Element de programme (-)

19 Elle a une ligne (-)

VERTICALEMENT

1 Patrons de classes (-)

2 Pas entier (-)

3 Tout le monde peut y acceder (-)

5 Tant que (-)

6 Transformer en bytecode (-)

7 Inconstance (-)

9 Vaut zero ou un (-)

12 Modificateur de main (-)

13 Ma methode principale (-)

14 Definit un comportement (-)

18 Machine fonctionnant au bytecode (-)

Chapitre 3

La notion d’objets : definition etutilisation

3.1 Introduction au developpement objets

Dans une entreprise, un projet est soumis avec les specifications suivantes :

3 formes doivent s’afficher sur une interface graphique : un cercle, un carre et un triangle.Lorsque l’utilisateur cliquera sur un bouton, la forme pivotera de 360 degres dans le sens desaiguilles d’une montre (tour complet sur elle-meme), et le systeme jouera un son d’un fichier

WAV (format de son) specifique a cette forme.

2 prototypes sont proposes pour realiser le programme : une en programmation imperative et uneen programmation objets avec une classe pour chaque forme.

Programmation imperative

tourner(typeForme){

//faire tourner la forme

//de 360 degres

}

jouerSon(typeForme){

//utiliser typeForme

//pour chercher

//quel son WAV jouer

//puis le jouer

}

Programmation Objets

Carretourner(){

//code pour

//faire tourner

//un carre

}

jouerSon(){

//code pour

//jouer le son

//d’un carre

}

Cercletourner(){

//code pour

//faire tourner

//un cercle

}

jouerSon(){

//code pour

//jouer le son

//d’un cercle

}

Triangletourner(){

//code pour

//faire tourner

//un triangle

}

jouerSon(){

//code pour

//jouer le son

//d’un triangle

}

En programmation objet, on va creer ”un objet” par type de forme demandee, et on associera achaque forme ses fonctionnalites propres (tourner, jouer un son). En programmation imperative,on utilisera des procedures generiques et les choix des operations a effectuer se feront a l’aide detests (par exemples des if). Les 2 solutions repondent au probleme, mais la modelisation objetest plus rigoureuse et offre de meilleures garanties en cas de modifications futures.

Justement, supposons que les specifications soint ensuite modifiees par le commanditaire du projet :

31

32 CHAPITRE 3. LA NOTION D’OBJETS : DEFINITION ET UTILISATION

Il y aura en plus une forme d’amibe a l’ecran, au milieu des autres. Lorsque l’utilisateur cliquerasur l’amibe elle tournera comme les autres formes, mais jouera un son .AIF

Ceci implique des modifications dans le code


tourner(typeForme){

//faire tourner la forme

//de 360 degres

}


//Si la forme n’est pas

//une amibe


//pour chercher


//puis le jouer

//sinon

//jouer le son AIF

//de l’amibe

}


Amibetourner(){

//code pour

//faire tourner

//l’amibe

}

jouerSon(){

//code pour

//jouer le son

//de l’amibe

}

En programmation imperative on va etre oblige de modifier le code, ce qui peut provoquer l’ajoutd’erreurs (bugs). En programmation objet, on va rajouter un nouvel objet de forme amibe et luiassocier ses comportements propres. On n’a pas a modifier le code existant deja valide.

Probleme : le centre de rotation differe des autres.

(a) Une amibe. (b) Les centres de rotation ne sont pas les memes.

Ceci implique une nouvelle modification pour tourner les formes.

3.1. INTRODUCTION AU DEVELOPPEMENT OBJETS 33


tourner(typeForme, centreX, centreY){

//si la forme n’est pas

//une amibe

//calculer le centre

//sur la base d’un

//rectangle puis

//faire tourner la

//forme de 360 degres

//sinon

//utiliser centreX et

//centreY comme centre

//de rotation puis faire

//tourner la forme

}


//Si la forme n’est pas

//une amibe


//pour chercher


//puis le jouer

//sinon

//jouer le son AIF

//de l’amibe

}


Amibe

int centreX;

int centreY;tourner(){

//faire tourner

//l’amibe en utilisant

//centreX et centreY

}

jouerSon(){

//code pour

//jouer le son

//de l’amibe

}

En programmation objets on n’a pas besoin de modifier le code des autres formes (carre, triangle,cercle). On peut meme aller plus loin et creer une classe contenant les parties communes, puis dessous-classes contenant les parties specifiques. Si la classe Forme contient une fonctionnalite donneetoutes ses sous-classes en heritent automatiquement. La classe Triangle, par exemple, suit lesdirectives de la classe forme, pour la classe Amibe on a modifie les parties de code necessaires.

jouerSon(){

//code de

// l’amibe

}

jouerSon(){

//code

}

Carre Triangle Cercle Amibe

tourner(){

//code de

//l’amibe

}

Forme

tourner(){.

}

//code

Sous−classes

Super−classe

Héritage

Figure 3.1 – Conception generale a l’aide d’une hierarchie de classes.


3.2 La notion de classe

Les classes ne sont pas des objets, mais servent a les construire. Elles sont des patronsd’objets, indiquant a la JVM comment produire un objet d’un type donne. Chaque objet peutaffecter ses propres valeurs aux variables d’instances definies dans la classe a partir de laquelle ila ete cree.

Analogie : un objet peut etre compare a des fiches d’un carnet d’adresses, la classe corresponda la structure d’une fiche (nom, telephone, adresse, . . .), les objets correspondent aux personnesstockees dans les fiches.

3.2.1 Exemple de classe :

/**

*Classe de definition d’un point dans le plan

*/

public class Point

{

private int x; //abscisse

private int y; //ordonnee

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 coordonnees "+x+" "+y);

}

}

De part la definition de cette classe Point, nous pouvons noter deux choses :— 2 variables d’instances sont definies x et y. Le mot private indique que l’on ne peut avoir

acces a ces variables qu’a l’interieur de la classe. (On appelle parfois ces variables champsou attributs)

— 3 methodes sont definies initialise, deplace et affiche. Le mot public indique que cesmethodes sont utilisables depuis un programme quelconque. Ces 3 methodes ne possedentpas de valeur de retour, dans ce cas on utilise le mot cle void dans la declaration. Notons,de plus, que la methode initialise – par exemple – possede 2 arguments abs et ord, tousdeux de type entier. (Note : il est possible d’avoir des methodes private dans une classe,dans ce cas elles ne pourront etre utilisees que dans la classe)

3.2.2 Creation d’un objet a l’aide d’une classe

On declare un objet de type Point en definissant une variable de type Point de la manieresuivante :

3.2. LA NOTION DE CLASSE 35

Point a;

ceci implique la creation d’une reference de type Point nommee a, a ce stade aucun objet n’a etecree.

Pour creer un objet, il faut utiliser l’operateur new :Point a = new Point();

??

y

xa

Un objet point a ete cree, mais x et y n’ont pas recu de valeur, par defaut ces variables sont initia-lisees a zero. Ensuite on peut initialiser les valeurs de l’objet en utilisant la methode initialise :a.initialise(3,5);

y

xa

35

3.2.3 Exemple d’utilisation dans un programme complet

public class TestPoint{


{

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’execute, ce programme produira le resultat suivant :

Je suis un point de coordonnees 3 5



Remarques : Pour utiliser ce programme, il faut creer 2 classes, on enregistre la classe Point

dans un fichier Point.java et la classe TestPoint dans un fichier TestPoint.java.En regle generale, on separe la fonction d’utilisation (c’est-a-dire le main) dans une classe a

part de maniere a faciliter la reutilisation des classes deja construites.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 lefichier Point.class existe ;

3. lancer le programme TestPoint.


Java impose au minimum que :

— Un fichier source peut contenir une ou plusieurs classes, mais exactement une seule doitetre publique.

— La classe contenant la methode main doit obligatoirement etre publique.— Une classe n’ayant aucun attribut d’acces (public/private) est accessible a toutes les classes

du meme paquetage, et donc a fortiori du meme fichier source. (Nous verrons les paquetagesplus tard).

3.3 La notion de constructeur

Un constructeur permet d’automatiser le mecanisme d’utilisation d’un objet en evitant d’ap-peler une methode specifique (comme la methode initialise de la classe Point).

Un constructeur est une methode sans valeur de retour, portant le meme nom que laclasse pouvant definir tout un tas d’actions utiles au bon fonctionnement d’un objet. Le construc-teur peut disposer d’un nombre quelconque d’arguments.

Exemple

public class Point

{

private int x;

private int y;

public Point(int abs,int ord) //constructeur

{

x=abs;

y=ord;

}


{

x+=dx;

y+=dy;

}


{


}

}

Nous creons ensuite un point via Point a = new Point(1,3);

Voici quelques lignes de code qui pourraient etre mises dans une methode main pour tester leprogramme.

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 37

Attention : dans notre nouvelle classe, l’utilisation de a = new Point(); n’est plus possibleet provoque une erreur. Si l’on desire conserver un constructeur sans arguments, il faut ecrire 2constructeurs.

Lors de la construction d’un objet, il se passe, dans l’ordre :

1. initialisation par defaut des champs de l’objet

2. initialisation explicite des champs donnee lors de leur declaration

3. execution du corps du constructeur.

Liste des initialisations par defaut des champs d’un objet en fonction de leur type. Ces valeurscorrespondent en general a une valeur nulle :

— boolean → false

— char → null

— entier → 0

— flottant → 0.0 (ou 0.f)— objet quelconque → null

Cas des champs declares avec l’attribut final. Ces champs ne doivent etre declares qu’unseule fois. Toute tentative de modification ulterieure aboutira a une erreur de compilation. Unchamp final doit etre initialise au plus tard par le constructeur. Il n’est pas permis de comptersur l’initialisation par defaut d’un tel champ.

Exemple de programme recapitulatif

public class Init{


{

A a = new A();

a.affiche();

}

}

class A

{

private 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;

}


{

System.out.println("n="+n+", p="+p+", np="+np);

}

}

Cependant, il est preferable d’effectuer les initialisations par le constructeur pour que l’utilisateurn’ait pas a s’interroger sur l’ordre des differentes operations.

public A()

{

n=20, p=10;

np = n * p;


n=5;

}

3.4 Affectation et comparaison d’objets

Nous venons de voir qu’il existe des variables de type ”classe” (Point a;) destinees a contenirdes references sur des objets. Une reference est simplement une autre valeur de variable possible.Pour ces variables, les affectations portent sur les references et non les objets.

Point a,b;

a = new Point(3,5);

b = new Point(2,0);

y

xa

35

y

xb

20

Exemple Si maintenant nous ajoutons :

a = b; y

xb

20

y

xa

35

On recopie en fait dans a la reference de b, a et b designent alors le meme objet et non lameme valeur.

Second 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 schema suivant represente le resultat final du codeci-dessous.

y

xa

110

b

y

xc

220

3.4.1 La reference null

Si on effectue une declaration sans initialisation, par exemple Point p;, par defaut p estinitialise a null (rien). On ne peut pas avoir acces aux champs de l’objet ni utiliser ses methodes.Dans ce cas, une erreur (exception) de type NullPointerException sera levee a l’utilisation.

3.5. LE RAMASSE-MIETTES 39

p

null

On peut cependant tester la non nullite d’une reference a un objet.

if(p!=null)

{

p.affiche();

}

3.5 Le ramasse-miettes

Nous avons vu que grace a l’operateur new, la JVM alloue un emplacement memoire a l’objet etl’initialise. Il n’existe pas de mecanisme de destruction d’objets. Il existe par contre un mecanismede gestion automatique de la memoire connu sous le nom de ramasse-miettes (en anglais garbagecollector). Son principe est le suivant :

— A tout instant, la JVM connaıt le nombre de references a un objet donne (tout est gere parreferences en Java).

— Lorsqu’il n’existe plus aucune reference sur un objet, on est certain que le programme nepourra plus y acceder. Il est donc possible de liberer l’emplacement correspondant. Cepen-dant, pour des raisons d’efficacite ( ? ?), Java n’impose pas que ce soit fait immediatement.On dit que l’objet est candidat au ramasse-miettes.

Note : La zone memoire utilisee pour allouer de l’espace a de nouveaux objets s’appelle le tas.Tous les objets resident sur le tas. Avant qu’un objet ne soit candidat au ramasse-miettes, Javaappelle la methode finalize, qui est une methode permettant d’effectuer des operations lors dela destruction de l’objet.

3.6 L’encapsulation de donnees

L’encapsulation de donnees est une convention de manipulation des variables d’instances enJava. Il est plus que fortement conseille de suivre cette demarche, elle s’avere meme obligatoirepour l’ecriture d’un code correct et lisible dans certaines structures.

En general, une bonne programmation objet protege les donnees relatives a un objet : lesvariables definies dans une classe. Pour cela, on declare ces champs private, et on utilise desmethodes declarees public pour y acceder.

Par exemple, pour la classe Point, on rajoutera les methodes suivantes

public 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;


y = ord;

}

Suivant les cas, il peut-etre preferable d’avoir une seule methode de changement de variableslorsque 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{


{

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 41

3.7 Champs et methodes statiques

En Java on peut definir des champs qui n’existent qu’en un seul exemplaire pour toutes lesinstances de la classe, au lieu d’exister dans chacune des instances. Il s’agit en quelque sorte dedonnees globales partagees par toutes les instances d’une meme classe. On parle de champs(ou variables) de classe ou de champs (ou variables) statiques, nous verrons plus tard qu’il existeaussi des methodes statiques.

3.7.1 Variables statiques

Exemple classique

class A

{

public int n;

public float y;

public A()

{

n = 3;

y = 5.5;

}

}

Chaque objet de type A possede ses propres champs n et y.Si on cree 2 objets, leur occupation en memoire peut se representer de la maniere suivante :

A a1 = new A();

A a2 = new A();

a2.n -= 1;

a2.y -= 5.0;

a2.y

a2.na2

20.5

a1.y

a1.na1

35.5

Avec un champ statique

class B

{

public static int n = 2;

public float y;

public B()

{

y = 5.5;

}

}

B b1 = new B();

B b2 = new B();

b2.y -= 5.0;

2

b2b1 0.55.5

b1.n ou B.n b2.n ou B.n

b1.y b2.y


b1.n et b2.n designent le meme champ, il est cependant preferable de s’y referer par B.n. nest 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

{


{

ExObjet a,b,c;

System.out.println("Avant la creation de l’objet a");

a = new ExObjet();

System.out.println("Apres la creation de l’objet a");

System.out.println("Avant la creation de l’objet b");

b = new ExObjet();

System.out.println("Apres la creation de l’objet b");

c = new ExObjet();

System.out.println("Apres la creation du dernier objet c");

}

}

Resultat du programme

Avant la creation de l’objet a

++ creation de l’objet ExObjet numero 0 il y a maintenant 1 objet(s)

Apres la creation de l’objet a

Avant la creation de l’objet b


Apres la creation de l’objet b


Apres la creation du dernier objet c

Remarque lorsque l’on compte le nombre d’objets, on ne prend pas en compte les eventuelsobjets detruits par le ramasse-miettes (il faudrait utiliser la methode statique finalize).

Les champs statiques peuvent etre initialises avant l’appel a un constructeur. Il peut memene pas y avoir de constructeur, dans ce cas la seule initialisation possible est une initialisationexplicite lors de la declaration.

3.7.2 Les methodes statiques

Les methodes statiques jouent un role independant d’un objet quelconque. Elles peuvent etreappeles sans qu’un objet de la classe n’ait ete cree.

3.7. CHAMPS ET METHODES STATIQUES 43

Exemple

public class B2

{

private float x;

private static int n;

public static void f() //methode de classe ou statique

{

//ici on ne peut pas acceder a x, mais on peut acceder a n

}

}

Exemple

class 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

{


{

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("Apres la creation de l’objet a, NB objet" +

ExObjet2.pluriel() + ":"+ExObjet2.getNb());

System.out.println("Avant la creation de l’objet b, NB objet" +


b = new ExObjet2();

System.out.println("Apres la creation de l’objet b, NB objet" +



c = new ExObjet2();

System.out.println("Apres la creation du dernier objet c, NB objet" +


}

}

Resultat du programme

Avant la creation de l’objet a, NB objet: 0

++ creation de l’objet ExObjet numero 0 il y a maintenant 1 objet

Apres la creation de l’objet a, NB objet: 1

Avant la creation de l’objet b, NB objet: 1

++ creation de l’objet ExObjet numero 1 il y a maintenant 2 objets

Apres la creation de l’objet b, NB objets: 2

++ creation de l’objet ExObjet numero 2 il y a maintenant 3 objets

Apres la creation du dernier objet c, NB objets: 3

Les methodes statiques s’averent utiles— pour permettre aux objets de disposer d’informations ”collectives”,— fournir des services n’ayant une signification que pour la classe elle-meme (par exemple

pour l’identification d’une classe),— fonctionnalites n’etant pas liees a un objet quelconque (par exemple la methode pluriel,

ou des methodes mathematiques comme le calcul d’un cosinus ou d’une racine carre avecla classe Math).

3.8 Surdefinition/surcharge de methodes

On parle de surcharge lorsqu’un meme symbole possede plusieurs significations differenteschoisies en fonction du contexte d’utilisation. Par exemple, l’operateur + peut, suivant les cas,correspondre a une somme d’entiers, de flottants ou une concatenation de chaınes de caracteres.

Ceci s’applique egalement en Java aux methodes. Plusieurs methodes peuvent porter le memenom pour peu que le nombre et le type de leurs arguments permettent au compilateur d’effectuerson choix.

Exemple introductif : une classe Point avec 3 methodes deplace

public 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;

y += dy;

}

public void deplace(int dz)

3.8. SURDEFINITION/SURCHARGE DE METHODES 45

{

x += dz;

}

public void deplace(short dz)

{

y += dz;

}

}

public class TestSurdef

{


{

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ıte lors de l’appel, il y aura erreur de compilation.

Remarques importantes :— Le type de la valeur de retour n’intervient pas dans le choix de la methode surchargee.— On peut surcharger des methodes statiques.— L’attribut final n’a aucune influence sur le choix d’une methode surchargee.

public void deplace (int dx) { ... }

public void deplace (final int dx){ ... } //erreur de compilation !!!

3.8.1 Surdefinition de constructeurs

Exemple

public class Point

{

private int x,y;

public Point()

{

x = 0;

y = 0;

}

public Point(int a)

{

x = y = a;

}

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;

}

}

Utilisation


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 a la recopie de reference et neprovoque pas la recopie de la valeur des objet.

En general pour copier efficacement un objet, on cree une methode specifique.

public class Point

{

private int x,y;

.

.

.

public Point copie()

{

Point p = new Point(x,y);

return p;

}

}

Utilisation


Point b = a.copie();

Cette demarche est utilisable tant que la classe concernee ne comporte pas des variables quisont de type objet (par exemple lorsque dans une classe Point on a un champ qui est aussi unevariable de type Point). Il faut alors decider si la copie soit porter sur les objets references oujuste sur les references.

3.10. AUTOREFERENCEMENT : LE MOT CLE THIS 47

— Copie superficielle d’un objet : on copie la valeur de tous les champs, y compris ceux quisont d’un type classe.

— Copie profonde : on recopie la valeur des champs d’un type primitif, mais pour les champsde type classe on cree une nouvelle reference a un nouvel objet de meme type et de memevaleur.

Exemple : permutation des valeurs de 2 objets

public 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();

}

}


Point b = new Point(0,2);

y

xa

35

y

xb

20

a.permute(b)

y

xa

20

y

xb

35

x

y2

0

c

A la fin de la methode permute, le point reference par c devient candidat au ramasse-miettes.

3.10 Autoreferencement : le mot cle this

Il permet de faire reference a l’instance de l’objet courant dans sa globalite au sein d’unemethode.

Exemple : Methode coıncide pour savoir si un point coı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 ecrit :

public Point(int abs,int ord)

{

x = abs;

y = ord;

}

Ce constructeur peut se re-ecrire de la maniere suivante en utilisant un auto-referencement :

public Point(int x,int y)

{

this.x = x;

this.y = y;

}

Le mot cle this permet d’employer des noms d’arguments identiques a des noms de champs(ce qui peut eviter l’utilisation de nouveaux identificateurs).

Il est egalement possible de s’en servir pour appeler un autre constructeur au sein de la memeclasse.

public class Point

{

private int x,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 etre la premiere instructiondu constructeur.

Les instructions :

3.11. REMARQUES SUR LA DEFINITION DE METHODES 49


Point b = new Point();

provoquent le resultat suivant :

Constructeur avec 2 arguments 1 et 2

Constructeur avec 2 arguments 0 et 0

Constructeur sans argument

3.11 Remarques sur la definition de methodes

3.11.1 Methodes de type procedures et fonctions

Si une methode ne fournit aucun resultat, le mot cle void figure dans son en-tete a la place dutype de valeur de retour. Une telle methode sera appelee une procedure.

Si une methode fournit un resultat, elle porte alors le nom de fonction. Le type de sa valeurde retour doit etre indique dans son en-tete, l’instruction return doit egalement etre utilisee pourretourner le resultat.

Exemple : une methode distance qui calcule la distance du point par rapport a l’origine (0, 0)que l’on pourrait ajouter a la classe Point.

public class Point

{

private int x,y;

.

.

.

public double distance()

{

double d;

d = Math.sqrt(x*x + y*y);

return d;

}

}

Utilisation de cette methode :


double r;

r = a.distance();

System.out.println("La distance par rapport a l’origine est de "+r);

Il est egalement possible de ne pas utiliser la valeur de retour, dans ce cas on appelle juste lamethode :

a.distance();

3.11.2 Les arguments

Ils figurent dans l’en-tete de la definition d’une methode et peuvent etre utilises dans le corpsde la methode.


public void f(int arg1,int arg2,int arg3)

{

...

}

On peut theoriquement changer la valeur des arguments, mais c’est assez deconseille.

void f(final int n,double x)

{

...

x = 2.5 //correct mais deconseille

}

Il egalement deconseille de modifier la valeur des arguments comme le montre la methodeprecedente. Dans le cas d’arguments de type primitif, les modifications a l’interieur de la methodene sont plus prises en compte a la sortie de la methode. On conseille en general de creer unevariable locale supplementaire et de copier la valeur de l’argument dedans avant de l’utiliser.

Notez que dans la methode precedente, toute modification de la valeur de n provoque uneerreur de compilation.

3.11.3 Les variables locales

void f(int n)

{

float x; //variable locale a f

float n; //INTERDIT en Java

...

}

void g()

{

double x; //variable locale a g, independante de la variable de f

...

}

L’emplacement memoire d’une variable locale est alloue au moment ou l’on entre dans lamethode, il est libere lorsque l’on en sort.

N.B. Les variables locales n’ont pas d’initialisation par defaut.

Il est possible de creer des variables locales a un bloc (par exemple dans une boucle for) qui neseront 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) 51

3.11.4 La recursivite

La recursivite de methodes peut prendre 2 formes :— directe : une methode comporte dans sa definition au moins un appel a elle-meme,— croisee : l’appel d’une methode entraıne l’appel d’une autre methode qui a son tour appelle

la methode initiale.La recursivite peut s’appliquer aussi bien aux methodes statiques qu’aux autres methodes.

Exemple : Calcul de la factorielle d’un nombre par une methode statique (pour n = 8 le resultatest 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 definie

}

}

public class TestFact

{


{

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 memoire pour les variables locales, la valeurde retour et l’argument. Chaque nouvel appel de fact entraıne donc une telle allocation sans queles emplacements precedents n’aient ete liberes (empilement d’espace memoire). Ce n’est qu’a lapremiere instruction return qu’il y a un depilement des arguments.

3.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 bibliotheque (ou librairie) que l’ontrouve dans d’autres langages. Elle facilite le developpement et la cohabitation de logiciels.

3.12.1 Attribution d’une classe a un paquetage

Un paquetage est caracterise par un nom qui est soit un simple identificateur soit une suited’identificateur separes par des points. Exemple :

MesClasses

Utilitaires.Mathematiques

Utilitaires.Tris

L’utilisation du point . implique une hierarchie logique de package. Ainsi, dans l’exempleprecedent, les packages Mathematiques et Tris sont en dessous du package Utilitaires.


Mathematiques Tris

Utilitaires

L’attribution a un package se fait au niveau du fichier source. Toutes les classes d’un memefichier appartiendront toujours a un meme package. On place en debut de fichier une instructionde la forme :

package nompaquetage;

La plupart des environnements imposent des contraintes quant a la localisation des fichierscorrespondant a un package. En particulier un paquetage de nom X.Y.Z se trouvera toujoursdans un sous-repertoire de nom X.Y.Z (les repertoires de niveau hierarchique superieur peuventetre quelconques). Deux paquetages X.Y.Z et X.Y.U n’ont pas l’obligation d’etre dans le memerepertoire.

Avec le JDK (ou SDK) de Sun la recherche d’un package se fait dans les repertoires indiquesdans la variable d’environnement CLASSPATH.

S’il n’y a pas de paquetage indique dans un fichier source, le compilateur considere que ceux-ciappartiennent au paquetage par defaut.

Si l’on ne souhaite pas utiliser la variable d’environnement CLASSPATH, il est possible de specifierles chemins ou se trouvent les paquetages a l’aide de l’option -classpath des commandes java etjavac. Par exemple si une classe Toto utilise des packages ou des classes situees dans les repertoires~/MesPackages et /usr/local/packages standard, on utilisera les commandes suivantes :

javac -classpath ~/MesPackages;/usr/local/packages_standard Toto.java

java -classpath ~/MesPackages;/usr/local/packages_standard Toto

Ceci implique si le package affaires de toto est utilise, le dossier contenant les elements dece package doit etre situe soit dans ~/MesPackages/affaires_de_toto ou dans/usr/local/packages standard/affaires de toto ; evidemment une seule des 2 solutions estvalable.

3.12.2 Utilisation d’une classe situee dans une paquetage

Il faut :— citer le nom du paquetage avec le nom de la classe,— utiliser une instruction import en indiquant soit une classe particuliere d’un paquetage,

soit un paquetage entier.

Avec une citation de nom de classe. Si vous avez attribue la classe Point au packageMesClasses, 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 ici

En important une classe avec l’instruction import

import MesClasses.Point, MesClasses.Cercle;

Il est ensuite possible d’utiliser les classes Point et Cercle sans avoir a mentionner leurs noms.

3.13. LES TABLEAUX 53

En important un package en entier.

import MesClasses.*;

Toutes les classes du package MesClasses et les classes des packages hierarchiquement en dessoussont 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 ajoute par le compilateur.

3.12.3 Droits d’acces

— Avec le mot cle public, une classe est accessible a partir de toutes les autres classes(eventuellement via une instruction import).

— Sans le mot cle public, une classe n’est accessible qu’aux classes du meme paquetage.Tant que l’on travaille avec le paquetage par defaut, l’absence du mot public n’a guered’importance.

Note : le mot cle private n’a pas de sens au niveau d’une classe.

3.13 Les tableaux

En programmation, un tableau designe un ensemble d’elements de meme type identifies parun nom unique. Chacun des elements etant ensuite repere par un indice precisant sa position ausein de l’exemple.

En Java, les tableaux sont consideres comme des objets, les tableaux a plusieurs indices s’ob-tiennent par composition de tableaux.

3.13.1 Declaration et creation

Imaginons que nous voulions creer un tableau d’entiers, deux declarations sont possibles :

int t[];

int []t;

La difference entre les 2 declarations a une importance lorsque l’on souhaite declarer plusieurstableaux :

int [] t1,t2; //declaration de 2 tableaux d’entiers

int t1[], t2[]; //meme chose

int t1[], n, t2[]; //2 tableaux t1 et t2, n est un entier

Point a, tp[], b; //a et b sont de type Point, tp est un tableau

// d’objets Point

N.B. : une declaration de tableau ne doit pas preciser de dimension.

Pour creer un tableau on utilise l’operateur new comme pour des objets classiques. Voici unexemple montrant comment creer un tableau de 10 entiers :

int t[] = new int[10];

Il est egalement possible de fournir une liste d’expression entre accolades. Voici un exemple decreation d’un tableau d’entiers a 5 elements.

int t[] = {1, 2, 7, 10, 0};


L’instruction precedente equivaut aux instructions suivantes :

int [] t = new int[5];

t[0] = 1;

t[1] = 2;

t[2] = 7;

t[3] = 10;

t[4] = 0;

Attention. Une fois un tableau cree, on ne peut plus modifier sa taille. Par contre, on peut creerun 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 acces a la taille d’un tableau a l’aide du champlength.

int t[] = new int[6];

System.out.println("taille de t "+t.length); //affiche 6

t = new int[2];

System.out.println("taille de t "+t.length); //affiche 2

Ici length est vu comme un champ et non comme une methode.

Acces aux elements d’un tableau Un element est designe en placant entre crochets sa positionapres le nom du tableau. Une position est designee par une expression entiere comprise entre 0 (lepremier element du tableau) et la taille du tableau-1 (dernier element du tableau).

Exemple : calcul d’une moyenne de notes

public class TestCalculMoyenne

{


{

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;


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 superieures a cette moyenne");

}

}

Affectation de tableaux. Exemple.

int [] t1 = new int[3];

for(int i=0; i<t1.length; i++)

t1[i] = i;


for(int i=0; i<t2.length; i++)

t2[i] = 10+ i;

La situation peut-etre schematisee comme ceci :

0

1

t2

10

11

2

t1

Si maintenant on execute :

t1 = t2; //la reference contenue dans t2 est recopiee dans t1

Nous aboutissons alors a cette situation :

0

1

t2

10

11

2

t1

Maintenant si l’on execute les instructions suivantes :

t1[1] = 5;

System.out.println(t2[1]); //affiche 5 !!!

L’ancien objet reference par t1 devient candidat au ramasse-miettes. Lors de l’affectation dereferences de tableau, il n’y a aucune recopie des valeurs des elements du tableau.


Exemple de tableau d’objets

public class Point

{

private int x,y;


{

this.x = x;

this.y = y;

}


{

System.out.println("Point : "+x+", "+y);

}

}

public class TabPoint

{


{

Point [] tp;

tp = new Point[3];

tp[0] = new Point(1,2);



for(int i=0; i<tp.length; i++)

tp[i].affiche();

}

}

Resultat :

Point : 1, 2

Point : 4, 5

Point : 8, 9

3.13.2 Tableau en argument ou en retour

Lorsque l’on transmet un nom de tableau en argument d’une methode, on transmet en fait unecopie de la reference au tableau. La methode agit directement sur le tableau concerne et non surune copie.

Voici un exemple de manipulations de tableau par des methodes statiques.

class Util

{

static void raz(int t[])

{

for(int i=0; i<t.length; i++)

t[i] = 0;

}

static void affiche (int t[])

{



System.out.print(t[i] + " ");

System.out.println();

}

}

public class TabArg

{


{

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);

}

}

Resultat.

t avant: 1 3 5 7

t apres 0 0 0 0

La meme chose s’applique a un tableau fourni en valeur de retour. Par exemple, la methodesuivante fourni un tableau forme des n premiers entiers :

public static int[] suite(int n)

{

int [] res = new int[n];


res[i]=i+1;

return res;

}

Un appel a suite fournira une reference a un tableau dont on pourra eventuellement modifierla valeur des elements.

3.13.3 Les tableaux a plusieurs indices

De nombreux langages disposent de la notion de tableau a plusieurs indices. Par exemple, untableau a deux indices permet de representer une matrice mathematique.

Java ne dispose pas d’une telle notion. Neanmoins, il permet de la simuler en creant destableaux de tableaux dont les elements sont eux-memes des tableaux. Cette possibilite s’avere enfait tres riche puisqu’elle peut permettre de creer des tableaux irreguliers (par exemple lorsque lesdifferentes lignes ont un nombre de colonnes qui varie).

Premier exemple. Ces trois declarations sont equivalentes pour un tableau a 2 dimensions :

int t [] [];

int [] t [];

int [] [] t;

Elles declarent une reference a un tableau, dans lequel chaque element est lui-meme une referencea un tableau d’entiers. Notez que pour l’instant aucun tableau n’existe encore.

Considerons la declaration :


int t [] [] = { new int [3], new int [2] };

t comporte deux elements de sorte que le premier soit un tableau de 3 entiers et que le deuxiemesoit un tableau de 2 entiers. On aboutit a la situation suivante (les elements des tableaux d’entierssont comme d’habitude initialises a 0) :

0

0

0

0

0

t

On constate alors que :— la notation t[0] designe la reference au premier tableau de 3 entiers,— la notation t[0][1] designe le deuxieme element de ce tableau (pour rappel les indices

commencent a 0),— la notation t[1] designe la reference au deuxieme tableau de 2 entiers,— la notation t[0][i-1] designe le ieme element de ce tableau pour i compris entre 1 et 2,— 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] [];



t[0] = t1;

t[1] = t2;

La situation peut s’illustrer comme ceci :

0

0

0

0

0

t

t1

t2

Troisieme exemple.

class Util

{

static void raz(int t[] [])

{

int i,j;


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] + " ");


}

}

}

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);

}

}

Resultat.

t avant raz

ligne de rang 0= 1 2 3

ligne de rang 1= 11 12

ligne de rang 2= 21 22 23 24

t apres raz

ligne de rang 0= 0 0 0

ligne de rang 1= 0 0

ligne de rang 2= 0 0 0 0

Cas des tableaux reguliers. Si on souhaite creer une matrice de NL lignes et NC colonneson peut toujours proceder comme ceci :

int t[][] = new int [NL] [];

int i;

for(i=0; i<NL; i++)

t[i] = new int [NC];

On peut egalement ecrire en Java :

int t[][] = new int [NL] [NC];


3.14 Exercices de cours

3.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{


{

t.setCanRecord(true);

t.playTape();

if(t.getCanRecord()==true){

t.recordTape();

}

}

}

2. Deuxieme Fichier :

class DVDPlayer{

private boolean canRecord=false;

void recordDVD()

{

System.out.println("enregistrement du DVD");

}


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();

}

}

}

Reponses :

1. Le fichier ne compile pas, il manque la creation d’une instance TapeDeck, il faut donc creerun objet. Pour cela il faut rajouter juste apres la declaration de la methode main, et avantla ligne t.canRecord = true; la ligne TapeDeck t = new TapeDeck();

2. Le fichier ne compile pas, il manque la methode playDVD() dans la classe DVDPlayer, onpourra 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 des le debut, il n’y a pasde droits d’acces indiques pour les variables d’instances, elles sont donc publiques par defaut. Cecin’est pas une bonne pratique : il vaut mieux declarer les variables privees et utiliser l’encapsula-tion. A vous donc d’ameliorer la correction de l’exercice !

3.14.2 Qui suis-je ?

Associer a chaque ligne ci-dessous un ou plusieurs mots parmi : Classe, Methode, Objet,Variable d’instance.

1. Je resulte de la compilation d’un fichier .java :

2. Mes variables d’instances peuvent etre differentes de celles de mes copains :

3. Je me comporte comme un patron :

4. J’aime faire des choses :

5. Je peux avoir plusieurs methodes :

6. Je represente un “etat” :

7. J’ai des comportements :

8. On me trouve dans des objets :

9. Je reside sur le tas :


10. Je sers a creer des instances d’objets :

11. Mon etat peut changer :

12. Je declare des methodes :

13. Je peux changer lors de l’execution :

Note : classes et objets ont tous deux un etat et un comportement. Ils sont definis dans la classemais on dit aussi que c’est l’objet qui les “possede”.

3.14.3 Compilateur 2

Voici trois programmes, indiquez si ces programmes compilent ; si la reponse est oui dites cequ’ils font, sinon comment les corrigez vous ?

1. public class XCopie{


{

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{


{

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();


}

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;

}

}

}

}

Reponses :

1. La classe compile et s’execute, le resultat est 42 84

2. Le fichier ne compile pas, il manque le type de retour String pour la methode getHeure.

3. java Resultat

13 15 x = 6


Associer a chaque ligne ci-dessous un ou plusieurs mots parmi : variable d’instance, argu-ment, retour, methode get, methode set, encapsulation, public, private, passage parvaleur, methode.

1. Une classe peut en avoir un nombre quelconque :

2. Une methode ne peut en avoir qu’un :

3. Peut etre converti implicitement :

4. Je prefere mes variables d’instances private :

5. Signifie reellement “faire une copie” :

6. Seules les methodes set devraient les modifier :

7. Une methode peut en avoir plusieurs :

8. Je retourne quelque chose par definition :

9. Ne m’utilisez pas avec des variables d’instance :

10. Je peux avoir plusieurs arguments :

11. Par definition, j’accepte un seul argument :

12. Ils aident a creer l’encapsulation :

13. Je vole toujours en solo :

3.14.5 Compilateur 3

Voici deux programmes, indiquez si ces programmes compilent ; si la reponse est oui dites cequ’ils font, sinon comment les corrigez vous ? (Pour des raisons de simplicite, l’encapsulation desdonnees a ete omise dans cet exercice, nous rappelons cependant que cet aspect est primordial enprogrammation objet)


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{


{

Livres [] mesLivres = new Livres[3];

int x=0;

mesLivres[0].setTitre("Panique a Java");

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{

String nom;


{

Hobbits [] h = new Hobbits[3];


int z = -1;

while(z < 2)

{

z=z+1;

h[z]= new Hobbits();

h[z].nom="bilbo";

if(z==1){

h[z].nom="frodon";

}

if( z == 2)

{

h[z].nom="sam";

}

System.out.print(h[z].nom + " est un ");

System.out.println("bon nom de Hobbit ");

}

}

}

Reponses :

1. Il manque la creation des objets livres, juste apres int x=0; il faut rajouter

mesLivres[0] = new Livres();



2. Cette classe compile et fonctionne, nous rappelons que les indices de tableaux commencenta zero.


3.14.6 Mots croises

26

2524

23

22212019

18

17

16

151413

121110

98

76

54

321

HORIZONTALEMENT

1 Mettre en oeuvre (-)

4 Teste d’abord (-)

5 32 bits (-)

7 Reponse d’une methode (-)

8 Avant le vrai code (-)

11 Changement de type (-)

12 Executrice (-)

13 Fait partie d’un tableau (-)

14 Peut etre locale (-)

16 Package contenant les classes essentielles (-)

17 A une methode parseInt (-)

19 Pour generer des nombres au hasard (-)

21 Impossible a convertir (-)

24 Certaines realites le sont (-)

25 Plus petit qu’un int (-)

26 Interface de developpement d’applications(-)

VERTICALEMENT

2 Type d’incrementation (-)

3 Elle fait le travail (-)

4 Specifie l’action dans un for (-)

5 Fixe la valeur de depart (-)

6 Methode qui modifie (-)

9 Contraire d’increment (-)

10 Repetition (-)

12 Package pour les E/S (-)

15 Faits pour etre transmis (-)

18 Methode qui accede (-)

20 Classe qui calcule (-)

22 Plus petit qu’un short (-)

23 Type de boucle (-)

24 Editeur prefere des puristes (-)


3.14.7 Mots croises

Certains mots sont introduits dans la section 8.3.2 sur les ArrayList.

23

222120

19

18

17

16

15

14

13121110

98

76

5

4321

HORIZONTALEMENT

1 Ils n’ont pas de comportement (-)

6 Tous les objets en derivent (-)

7 Premier indice (-)

10 Ajoute un objet (-)

11 Loup y es-tu ? (-)

14 Mutateur (-)

16 Croıt dynamiquement (-)

18 Homologue de 4 (vertical) (-)

20 Inconstante (-)

22 Sinon (-)

23 Unite adressable (-)

VERTICALEMENT

2 Implemente un comportement (-)

3 Retourne une position (-)

4 Retourne un nombre d’elements (-)

5 Grand decimal (-)

8 Groupe de classes (-)

9 Pour savoir si une liste est vide (-)

12 Sorte (-)

13 Position d’un element (-)

15 Pas reel (-)

16 Acronyme de la bibliotheque (-)

17 Commun aux courses et aux tableaux (-)

19 Recupere une valeur (-)

21 Article (rien a voir avec Java) (-)


Chapitre 4

Les concepts d’Heritage et dePolymorphisme

4.1 Presentation et definition

L’heritage permet de specifier une classe generale donnee en sous-classe.

Premier exemple. Voici une premiere hierarchie de classe.

traiterPatient()

travailleALHopital

Medecin

MedecinDeFamille

faitDesVisites

donnerConseil()

Chirurgien

faireUneIncision()

traiterPatient()

Super classe

Sous classes

En Java, cette hierarchie s’ecrira comme ceci :

public class Medecin

{

boolean travailleALHopital;

void traiterPatient()

{

//traiter le patient

}

}

public class MedecinDeFamille extends Medecin

{

boolean faitDesVisites;

void donnerConseil()

{

//donner un simple conseil

}

69

70 CHAPITRE 4. LES CONCEPTS D’HERITAGE ET DE POLYMORPHISME

}

public class Chirurgien extends Medecin

{

void traiterPatient()

{

//traitement d’un chirurgien

}

void faireUneIncision()

{

//action specifique du chirurgien

}

}

Autre exemple : retour a la classe Point.

public class Point

{

private int x,y;


{

this.x = x;

this.y = y;

}

public Point()

{

this(0,0);

}


{

x += dx;

y += dy;

}

public void modifie(int x,int y)

{

this.x = x;

this.y = y;

}


{

System.out.println("Je suis en "+x+" "+y);

}

}

Imaginons que nous ayons besoin de manipuler des points colores de maniere a :— garder les meme fonctionnalites de Point,— ajouter le traitement d’une couleur,— redefinir l’affichage d’un point avec sa couleur.

4.1. PRESENTATION ET DEFINITION 71

public 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);


}

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 derivee. Un objet de type PointCouleur peut alors faire appel aux methodespubliques de PointCouleur et aux methodes publiques de Point.

Un objet d’une classe derivee peut acceder directement aux membres public de sa classe debase, mais pas aux membres prives.

A retenir :— Une classe derivee n’accede pas aux membres prives (champs et methodes) de sa su-

perclasse. Par exemple, les points x et y ne sont pas accessibles directement de la classePointCouleur.

— Une classe derivee a acces aux membres publiques de sa superclasse. Pour acceder a unemethode public de la superclasse on utilise le mot cle super.

— Un objet d’une classe derivee accede aux membres publics de sa classe de base exactementcomme s’ils etaient definis directement dans la classe derivee elle-meme.

Exemple d’utilisation des 2 classes precedentes.

PointCouleur 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.deplace(1,-3);


Ces lignes de code provoquent le resultat suivant :

Je suis en 3 5

Je suis en 3 5

de couleur 3


Je suis en 5 8

de couleur 2

Je suis en 6 5

de couleur 2

4.2 Construction et initialisation des objets derives

Quand il n’y a pas de constructeur, un pseudo-constructeur par defaut est appele, nous nousinteressons maintenant au constructeur de la classe derivee.

En Java, le constructeur de la classe derivee doit prendre en charge l’integralite de la construc-tion de l’objet. Pour l’initialiser certains champs private de la classe de base, on peut soit utiliserdes methodes de modifications publiques, soit appeler le constructeur de la super-classe.

Attention. Si un constructeur d’une classe derivee appelle un constructeur d’une classe de base,il doit obligatoirement s’agir de la premiere instruction du constructeur (meme principe que pourl’utilisation du this). La reference a un constructeur est designee par super.

public class Point

{

private int x,y;


{

this.x = x;

this.y = y;

}

...

}


{

public PointCouleur(int x,int y,byte couleur)

{

super(x,y); //appel du constructeur de la classe Point


}

...

}

Attention.

— Les mots cles this et super ne peuvent pas etre utilises en meme temps.— Lorsqu’une classe derive d’une classe qui derive elle aussi d’une autre classe, l’appel par

super ne concerne que le constructeur de la classe de base de niveau immediatementsuperieur.

4.2. CONSTRUCTION ET INITIALISATION DES OBJETS DERIVES 73

super()

Remarques importantes sur la definition d’un constructeur.

— Si la super-classe ne possede pas de constructeur, il est possible d’appeler le constructeurpar defaut a partir de la classe derivee via super();. Cet appel peut paraıtre superflu,mais ne nuit pas. Ceci est pratique lorsque l’on construit une classe derivee sans connaıtreles details de la classe de base : on s’assure que les differents elements de la super-classeseront correctement initialises. Ceci justifie egalement le principe de toujours mettre unconstructeur par defaut sans argument dans une classe.

— Si la classe derivee ne possede pas de constructeur, le constructeur par defaut de la classesera appelee et par consequent le constructeur par defaut de la super-classe. Si ce construc-teur n’existe pas (s’il y a que des constructeurs avec arguments qui sont definis), il y a uneerreur 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 derive d’un objet A entraıne 6 etapes :

1. Allocation memoire pour un objet de type B (y compris les champs definis dans la super-classe A).

2. Initialisation par defaut de tous les champs de B (aussi bien ceux herites de A que ceuxdefinis dans B) aux valeurs nulles classiques.

3. Initialisation explicite des champs herites de A.

4. Execution du corps du constructeur de A.

5. Initialisation explicite des champs propres a B.

6. Execution du constructeur de B.

Notez egalement qu’il est possible d’avoir plusieurs derivations successives :


D E F G

CB

A

4.3 Redefinition, surdefinition et heritage

4.3.1 Redefinition

La redefinition consiste a re-ecrire une methode definit dans la super-classe et a changer soncomportement. Le nombre et le type des arguments ainsi que la valeur de retour doivent etreexactement les memes.

public class Point

{

private int x,y;

...


{


}

}

public class PointCouleur

{


...


{

super.affiche();

System.out.println(" de couleur "+couleur);

}

}

Lorsque l’on utilise la methode affiche d’un objet de type PointCouleur, la methode definiedans la classe PointCouleur est appliquee, sinon pour un objet de type Point uniquement c’estla methode definie dans la classe Point.

Imaginons que nous ayons une hierarchie de classe avec plusieurs derivations successives. Dansla classe la plus “elevee” une methode f et definie et cette methode est redefinie dans certaines deses sous-classes.

4.4. LE POLYMORPHISME 75

F

CB

A

ED

définition de f

redéfinition de f

redéfinition de f

Voici la liste des methodes f qui seront appelees en fonction du type de l’objet considere :— pour A, la methodes f de A,— pour B, la methodes f de A,— pour C, la methodes f de C,— pour D, la methodes f de D,— pour E, la methodes f de A,— pour F, la methodes f de C.

Attention. Les droits d’acces des methodes redefinies ne doivent pas etre diminues : une methodepublique dans la super-classe ne peut pas etre redefinie privee dans la classe derivee, l’inverse estcependant possible.

4.3.2 La surchage

La surcharge ou surdefinition consiste a modifier le prototype d’une methode existante, enchangeant le nombre d’arguments et/ou le type des arguments. Nous avons deja vu cette notionauparavant, dans le cadre de l’heritage, la recherche d’une methode acceptable se fait en “remon-tant” les derivations successives.

4.3.3 En resume

— Si une methode possede la meme signature dans une classe derivee que dans une classeparente :— les types des valeurs de retour doivent etre exactement les memes,— les droits d’acces de la methode de la classe derivee ne doivent pas etre moins eleves

que dans la classe parente,— la clause throws de la methode derivee ne doit pas mentionner des exceptions non

indiquees dans la clause throws de la methode de la classe parente. (Nous verrons ceciplus tard).

Si ces 3 conditions sont reunies, nous avons une redefinition sinon il y a une erreur.— Si la signature de la methode (nombre/type des arguments) n’est pas la meme on a une

surcharge (ou surdefinition). On rappelle que le type de la valeur de retour n’est pas prisen compte dans le cas d’une surcharge.

Notez qu’il est possible de dupliquer des champs lors d’un processus d’heritage, dans ce cas seulle champ de la classe derivee n’est visible de “l’exterieur”. Ceci est a eviter.

4.4 Le polymorphisme

Le polymorphisme permet de manipuler des objets sans connaıtre tout a fait leur type. C’estun principe extremement puissant en programmation orientee objet, qui complete l’heritage.

Exemple de base :

public class Point

{


private int x,y;

public Point(int x,int y){ ... }

public Point(){ ... }

public void affiche(){ ... }

...

}

public class PointCouleur

{


public PointCouleur(int x,int y,byte couleur){ ... }

public PointCouleur(){ ... }

public void affiche(){ ... }

...

}

Tout element de type PointCouleur est egalement de type Point, il est possible d’utiliser cettecaracteristique commune.

Point p;

p = new Point(3,5);

...

p = new PointCouleur(4,8,(byte) 2); y

x48

couleur2

y

x35(Point) p

(Point) p

Objet de type PointCouleur

Objet de type Point

Autre exemple.

Point p = new Point(3,5);

p.affiche(); //methode affiche de la classe Point

p = new PointCouleur(4,8,(byte)2);

p.affiche(); //methode affiche de la classe PointCouleur

Le choix de la methode a appliquer se fait automatiquement en fonction du type effectif del’objet et non pas en fonction du type de la variable qui reference l’objet. Ce choix porte le nomde liaison dynamique ou ligature dynamique.

Le polymorphisme se traduit par :— la compatibilite par affectation entre un type de classe et un type ascendant,— la liaison dynamique des methodes : comportement adapte a chaque objet.

4.4. LE POLYMORPHISME 77

4.4.1 Tableaux heterogenes d’objets

Exemple :

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 resultat suivant :



de couleur 2


de couleur 4


Cette situation s’adapte egalement a une hierarchie de classe plus complexe.

D E F G

CB

A

Autre exemple : cette fois on redefinit pas de methode affiche dans la classe PointCouleur

public class Point

{

private int x,y;


{

this.x = x;

this.y = y;

}


{

identifie();

System.out.println(" de coordonnees "+x+" "+y);

}


public void identifie()

{

System.out.print("Je suis un point");

}

...

}


{


public PointCouleur(int x,int y,byte couleur)

{

super(x,y);


}

public void identifie()

{

System.out.print("Je suis un point couleur de couleur "+couleur+", ");

}

}

Si on reprend le code utilise sur les tableaux on obtient le resultat suivant :


Je suis un point couleur de couleur 2, de coordonnees 1 5

Je suis un point couleur de couleur 4, de coordonnees 2 3


4.4.2 Regles du polymorphisme en Java

Compatibilite. Il existe une conversion implicite d’une reference a un objet de classe T a unobjet d’une classe parente de T.

Liaison dynamique. Lors d’un appel d’une methode a.f() ou a est suppose etre de type d’uneclasse T, le choix de f est determine :

— A la compilation : on determine dans la classe T ou ses ascendants la signature de lameilleure methode f() convenant a l’appel, ce qui defini du meme coup le type de la valeurde retour.

— A l’execution : on cherche la methode f de syntaxe et de type de retour voulu a partir de laclasse correspondante au type effectif de l’objet reference par a (de type T ou ascendant).Si cette classe ne comporte pas de methode appropriee on remonte le plus possible jusqu’ace qu’on en trouve une.

4.5 La super-classe Object

En Java, toute classe definie herite de la classe Object. Une variable de type Object peut etreutilisee pour referencer un objet de type quelconque.

Exemple


Object o;

4.5. LA SUPER-CLASSE OBJECT 79

o = p;

((Point)o).affiche();

Point p1 = (Point) o;

p1.affiche();

Attention. L’instruction o.affiche(); provoque une erreur car il n’y a pas de methode affichedefinie dans la classe Object. Il faut alors faire une conversion (cast) explicite comme le montrel’exemple ci-dessus.

La classe Object possede quelques methodes, dont notamment :

— la methode public String toString() qui renvoie, par defaut, une chaıne de caracterescontenant le nom de la classe et l’adresse memoire de l’objet (adresse precedee de @).Point a = new Point(1,2);

System.out.println(a.toString()); //affiche Point@fc1aedf

System.out.println(a); //equivalent

La methode toString definie par defaut le chaıne a afficher lorsque l’on veut afficher unobjet. Plutot que de definir une methode d’affichage on redefinie la methode toString dansla classe souhaitee puis on affiche directement l’objet.public class Point

{

private int x,y;

public Point(...){...}

...

public String toString()

{


}

}

...


...

System.out.println(p);

— La methode public boolean equals(Object o) se content de comparer les adresses memoiredes objets references.Object o1 = new Point(1,2);

Object o2 = new Point(1,2);

o1.equals(o2); //renvoie false comme reponse

o1.equals(o1); //renvoie true comme reponse

Il est egalement possible de redefinir/surcharger la methode equals dans ses propres classes :public class Point

{

private int x,y;

public Point(...){...}

...

public boolean equals(Point p)

{

return ((p.getX()==x) && (p.getY()==y));

}

}


4.6 Acces par membres proteges : protected

En plus des droits d’acces public et private et du droit par defaut lie a la notion de paquetage,il existe un autre droit d’acces : protected.

Un membre protected est accessible a des classes du meme package ainsi qu’a leur classederivees. En pratique, ce droit d’acces est assez peu utilise.

4.7 Methodes et classes finales

Une methode declaree final ne peut pas etre redefinie dans une classe derivee.

Une classe declaree final ne peut plus etre derivee.

4.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 derivation.

Exemple

public abstract class A

{

public void f()

{

... // methode completement secifiee dans A

}

//methode abstraite pas definie dans A

public abstract void g(int n);

}

Une classe abstraite possede au moins une methode abstraite, utilisation du mot cle abstract.Il est possible de creer une reference de type A (A a;), mais on ne peut pas creer d’objet de typeA (A a = new A(); provoque une erreur).

En revanche, on cree une classe B qui derive de A en definissant g.

public class B extends A

{

public void g(int n)

{

...

}

}

Ensuite on peut creer des objets de type B (B b = new B();).Une classe derivee d’une classe abstraite n’est pas obligee de redefinir toutes les methodes

abstraites de sa classe de base. Dans ce cas c’est une classe abstraite elle aussi, il faut alors pensera utiliser le mot cle abstract dans sa definition.

Une methode abstraite est toujours publique.

Interet.— Permet de specifier toutes les fonctionnalites que l’on souhaite disposer dans les classes

derivees.— Permet d’exploiter le polymorphisme en etant sur que certaines methodes existes.

4.8. LES CLASSES ABSTRAITES 81

Exemple.

abstract class Affichable

{

abstract public void affiche();

}

class Entier extends Affichable

{

private int valeur;

public Entier(int n)

{ valeur = n; }


{

System.out.println("Je suis un entier de valeur "+valeur);

}

}

class Flottant extends Affichable

{

private float valeur;

public Flottant(float x)

{ valeur = x; }


{

System.out.println("Je suis un flottant de valeur "+valeur);

}

}

public class Test

{


{

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 execute le code contenu dans la methode main, on obtient le resultat suivant :

Je suis un entier de valeur 25

Je suis un flottant de valeur 1.25

Je suis un entier de valeur 42


4.9 Les interfaces

Une interface est une notion correspondant a une classe abstraite ou aucune methode n’estimplementee.

4.9.1 Definition et mise en œuvre

public interface I

{

void f(int n); //public et abstract sont facultatifs

void g();

}

public class A implements I

{

//A doit redefinir f et g

}

— Une meme classe peut implementer plusieurs interfaces.

public interface I2

{

int h();

}

class B implements I,I2

{

//redefinition de f et g de I et h de I2

}

— Les interfaces peuvent contenir des constantes de type static final. Ces constantes serontdonc accessibles en dehors d’une classe implementant l’interface.

— Les interfaces peuvent se deriver, mais les classes derivees obtenues sont aussi des interfaces.

interface I1

{

static final int MAXI = 20;

void f(int n);

}

interface I2 extends I1

{

void g();

}

class A implements I1

{

//redefinit f, on a acces a MAXI directement

//par exemple if(i < MAXI) ...

}

class B extends A implements I2

{

//redefinition de g

}

4.10. CONNAITRE LA CLASSE ET LES TYPES D’UN OBJET 83

On peut ainsi ecrire les choses suivante d’ou on veut :

I1 i = new A();

I1 i2 = new B();

I2 b = new B();

System.out.println("Constante "+I1.MAXI);

4.9.2 Interet des interfaces

— Une classe peut implementer plusieurs interfaces, alors qu’une classe ne peut deriver qued’une seule classe (eventuelle abstraite).

— La notion d’interface se superpose a la notion de derivation et ne s’y substitue pas.— On peut utiliser des variables de type d’interfaces.— Les interfaces peuvent se deriver.Les interfaces permettent notamment de fournir une solution au probleme de l’heritage mul-

tiple.

Graveur

graver()

GraveurCD

graver()

GraveurDVD

graver()

Combo

Probleme de l’heritage multiple : quelle methode graver s’execute sur le combo ?

En Java il n’y a pas d’heritage multiple : on ne peut heriter que d’une seule classe. On contournealors le probleme en utilisant des interfaces. Dans l’exemple du dessus, une solution pourrait etrede creer une classe Combo qui herite de Graveur et qui implemente l’interface GraveurCD possedantune methode graverCD et l’interface graverDVD possedant une methode graverDVD.

4.10 Connaıtre la classe et les types d’un objet

4.10.1 L’operateur instanceof

C’est un operateur booleen qui renvoie true lorsque qu’un objet peut etre converti en type definipar une classe. Cette classe peut correspondre a une classe (abstraite ou non) situee au dessus dela classe de la reference de l’objet dans la hierarchie d’heritage ou une interface implementee parl’une des classes meres ou la classe propre de l’objet.


Exemple d’utilisation

if(objetA instanceof classeB)

{

//renvoie true si objetA peut-etre converti dans

//le type classeB

}

Un autre exemple, dans le cas de redefinition de equals

public 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-a-dire dont une specificationest final) sont utilisees dans une application en cours d’execution dans une JVM pour representerles differentes classes ou interfaces utilisees par l’application. Il en va de meme des tableaux et destypes 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 refere par exemple a la classe Object la methode getClass permet d’acceder a laclasse (reference sur Class) associee et a partir d’une telle reference des informations relatives acette classe peuvent etre obtenues par l’intermediaire des methodes de cette classe. Parmi celles-cicitons :

— Class[ ] getClasses( ) : renvoie un tableau contenant toutes les classes publiques etinterfaces ;

— String getName( ) : renvoie sous forme de chaıne le nom de l’entite (classe, interface,tableau ou type primitif) correspondante ;

— Class getSuperclass( ) : renvoie une reference sur la sur-classe ;— boolean isInstance(Object obj) : renvoie true si la reference est compatible avec la

classe courante, ce qui est similaire a l’utilisation de l’operateur instanceof.

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];


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 resultat

classe de a : AAAA

classe de c : CCCC

classe de t : [I

classe de tabObj : [Ljava.lang.Object;

classe de tabB : [LBBBB;

D’autres utilisations de cette classe sont possibles, notamment pour la creation et l’utilisationde 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 a la derniere partie du dernier chapitre.

4.11 Exercices de Cours

4.11.1 Classes abstraites - classes concretes

L’idee de cet exercice est de trouver une application concrete a toute definition abstraite.Plusieurs classes sont listees dans la colonne du milieu. L’objectif est d’imaginer des applicationsdans lesquelles la classe listee pourrait etre abstraite et des applications ou elle pourrait etreconcrete. Quelques exemples sont fournis pour aider a demarrer. Par exemple, la classe arbreserait abstraite dans un programme pepiniere ou les differences entre un chene et un peuplier sontimportantes. Mais dans un programme de simulation de golf, la classe arbre peut etre concrete(par exemple une sous-classe d’obstacle), parce qu’il n’y a aucun besoin de differencier les arbres.


Concrete Classe Abstraitesimulation de parcours de golf Arbre application de pepiniere

Maison application d’architecte

application de photo satellite Ville

JoueurDeFootball application d’entraınement

Chaise

Client

Commande

Livre

Magasin

Fournisseur

ClubDeGolf

Carburateur

Four

4.11.2 Compilateur

Voici un bout de programme Java incomplet :

public class MonstreTest{


{

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{

// -- methode A --

}

class Vampire extends Monstre{

// -- methode B --

}

class Dragon extends Monstre{


boolean fairePeur(int degre){

System.out.println("Souffler du feu");

return true;

}

}

Si l’on suppose que le programme produit le resultat ci-dessous :

>java MonstreTest

mordre ?

souffler du feu

arrrgh

Quelles paires de methodes A et B peuvent etre utilisees dans les classes Monstre et Dragon

(respectivement) pour produire le resultat ci-dessus ?

1. A: boolean fairePeur(int d){

System.out.println("arrrgh");

return true;

}

B: boolean fairePeur(int x){

System.out.println("mordre ?");

return false;

}



return true;

}

B: int fairePeur(int f){


return 1;

}



return false;

}

B: boolean effrayer(int x){


return true;

}

4. A: boolean fairePeur(int z){


return true;

}

B: boolean fairePeur(byte b){


return true;

}

Reponse :

1. Cet ensemble fonctionne, false est une valeur de retour acceptable.

2. Cet ensemble ne compile pas. La methode fairePeur() de Vampire n’est ni une redefinitionlegale, ni une surcharge legale de la methode fairePeur() de Monstre. Une redefinitionde methode ne peut pas modifier les arguments ni le type de retour, et ne changer QUE letype ne suffit pas a rendre une surcharge valide.


3. Cet ensemble compile mais ne produit pas le bon resultat parce que la methode fairePeur()de la classe Monstre n’est pas redefinie dans la classe Vampire.

4. Cet ensemble compile mais ne produit pas le bon resultat parce que la methode fairePeur()de Vampire accepte un byte alors qu’il faut un int.

Les ensembles 3 et 4 produisent en fait le resultat suivant :


Associer a chaque ligne ci-dessous un ou plusieurs mots parmi : superclasse, sous-classe,tableau, ArrayList (cf section 8.3.2), objet, tableau polymorphe, argument polymorphe,interface, methode abstraite, classe abstraite.

— Je suis incapable de grandir :— Je dis quoi faire, pas comment le faire :— J’accepte le melange de chiens et de chats :— J’autorise les references heterogenes :— Je peux dire si je suis vide :— Ma vie est une existence plus specialisee :— Mon contenu est toujours homogene :— Je peux rester floue sur certains details :— Je peux recevoir des choses que je n’ai jamais vues :— Les autres me regardent avec respect :— Je profite du travail d’une autre :— Faites ce que je dis, pas ce que je fais :— Je peux avoir un aspect different pour differentes personnes :— J’ai oublie d’ou vous veniez :— Rien de nouveau :

4.11.4 Vrai ou Faux ?

Pour repondre a certaines affirmations, il peut etre utile de consulter les sections 8.1,8.2

1. Pour utiliser la classe Math il faut d’abord creer une instance.

2. On peut marquer un constructeur avec le mot cle static.

3. Les variables statiques n’ont pas acces a l’etat des variables d’instance de l’objet this.

4. C’est une bonne pratique d’appeler une methode statique avec une variable de reference.

5. Les variables statiques peuvent servir a compter les instances d’une classe.

6. Les constructeurs sont appeles avant que des variables statiques ne soient initialisees.

7. MAX SIZE serait un bon nom pour une variable statique finale.

8. Un bloc initialisateur statique s’execute avant un constructeur de la classe.

9. Si une classe est finale, toutes ses methodes doivent etre finales.

10. Une methode finale ne peut etre redefinie que si la classe est etendue.

11. Il n’y a pas de classe enveloppe pour les booleens.

12. On utilise une classe enveloppe pour traiter une valeur primitive comme un objet.

13. Les methodes parseXXX retournent toujours une chaıne de caracteres.

Chapitre 5

La gestion d’exceptions

5.1 Presentation

La gestion d’exceptions permet :— de detecter une anomalie et de la traiter independamment de sa detection,— de separer la gestion des anomalies du reste du code.Une anomalie peut etre due, par exemple, a des donnees incorrectes, a un fin de fichier

prematuree, a un evenement non prevu par le programmeur.

Exemple. On dispose d’une classe Point pour laquelle on ne veut pas gerer des donnees negatives.Nous lancons une exception lorsque les coordonnees sont negatives par l’instruction throw. Pourcommencer nous creons un objet donc le type sert a identifier l’exception concernee. Une classed’exception se definit en heritant de la classe Exception deja definie dans l’API java.

public 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 etre rencontrees dans les methodesde la classe Point. On ajoute alors throws ErreurCoordonnees dans la declaration des methodesqui 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;

}


{


89

90 CHAPITRE 5. LA GESTION D’EXCEPTIONS

}

}

Ensuite pour recuperer une exception lancee par une methode, on utilise les instructions try

et catch :

public class TestExcept

{

public static void main(String args[])

{

try{ //Instructions qui peuvent voir une exception se declencher


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);

}

}

}

Resultat.


Erreur de construction

Attention : le bloc catch doit suivre immediatement le bloc try.

5.2 Gestion de plusieurs exceptions et transmission d’infor-mations

Exemple.

class ErreurCoord extends Exception

{

public int abs,ord;

public ErreurCoord(int abs,int ord)

{

this.abs = abs;

this.ord = ord;

}

public int getAbs()

{

return abs;

}

public int getOrd()

{

return ord;

5.2. GESTION DE PLUSIEURS EXCEPTIONS ET TRANSMISSION D’INFORMATIONS 91

}

}

class ErreurCoord 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 ErreurCoordonnees

{

if(x<0 || y<0)

throw new ErreurCoordonnes(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;

}


{


}

}



{


{

try{ //Instructions qui peuvent voir une exception se declencher


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");

}

}

Resultat.


Erreur de deplacement -3 5

Transmission de messages On peut transmettre un message au gestionnaire d’exception enutilisant un constructeur sans argument et la methode getMessage heritee de la classe Exception.Par exemple, avec la classe Point :

public class ErreurCoord

{

public ErreurCoord(String msg)

{

super(msg);

}

}

public class Point

{

...


{

if(x<0 || y<0)

throw new ErreurCoord("Erreur dans le constructeur de Point avec

"+x+" "+y);

this.x=x;

this.y=y;

}

5.3. DERIVATION ET REDECLENCHEMENT D’EXCEPTIONS 93

...

}

public class TextExcept3

{


{

try{

...

}

catch (ErreurCoord e)

{

System.out.println(e.getMessage());

System.exit(-1);

}

...

}

}

5.3 Derivation et redeclenchement d’exceptions

Il est possible de deriver des classes d’exceptions.

class ErreurPoint extends Exception { ... }

class ErreurCoord extends Exception { ... }

class ErreurDepl extends Exception { ... }

Lorsque l’on souhaite recuperer les exceptions il faut le faire en ordre inverse par rapport al’ordre defini par la hierarchie.

try{

...

}


{

...

}

catch(ErreurDepl e)

{

...

}

catch(ErreurPoint e)

{

...

}

Redeclenchement d’exceptions. Il est possible de declencher une exception dans le traitementd’une autre exception.

try{

...

}

catch(MonException e)

{

throw new Except();


}

Il est possible de redeclencher une exception pour la transmettre a un niveau englobant.

try{

...

}

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);

}


{

System.err.println("ErreurCoord dans le catch de f");

throw new ErreurBidon();

}

}

}

public class Test

{


{

try{


a.f();

}


{

System.err.println("ErreurCoord dans le catch de main");

5.4. LE BLOC FINALLY 95

}

catch(ErreurBidon e)

{

System.err.println("ErreurBidon dans le catch de main");

}

System.err.println("Apres le bloc try-catch de main");

}

}

Resultat.

ErreurCoord dans le catch de f

ErreurBidon dans le catch de main

Apres le bloc try-catch de main

5.4 Le bloc finally

Il est possible, en Java, d’introduire a la suite d’un bloc try, un bloc particulier d’instructionsqui seront toujours executees :

— soit apres la fin normale du bloc try, si aucune exception n’a ete declenchee,— soit apres le gestionnaire d’exception (a condition que ce dernier n’est pas provoque l’arret

de l’execution).Ce bloc est introduit par le mot cle finally et doit obligatoirement etre place apres le dernier

gestionnaire.

try{

...

}

catch(Ex e)

{

...

}

finally{

...

}

Ici le meme resultat aurait pu etre obtenu en supprimant tout simplement le mot cle finally eten mettant les instructions de ce bloc a la suite du gestionnaire.Ce n’est pas la meme chose dans ce cas :

void f() throws MonException

{

try{

...

}

finally{

...

}

}

Si une exception se produit dans f, on executera d’abord les instructions du bloc finally avantde se brancher sur le gestionnaire d’exceptions.

De maniere generale, le bloc finally peut s’averer interessant dans le cadre de l’acquisitionde ressources, c’est-a-dire tout ce qui necessite une action pour la bonne bonne poursuite des


operations (fermer un fichier, creer un objet, enlever un verrou, ...).

Autre cas.

try{

...

if(...)

break;

...

}

finally{

...

}

//suite

...

Si la commande break est executee, on execute d’abord le bloc finally avant de passer a la suite.Autre exemple possible.

try{

...

return 0;

}

finally{

...

return -1;

}

Ici la methode semble devoir executer une instruction return 0;, mais il faut quand meme executerle bloc finally contenant a son tour return -1;. Dans ce cas c’est la derniere valeur qui serarenvoyee (-1).

5.5 Les exceptions standard

Java fournit de nombreuses classe predefinies derivees de la classe Exception qui sont utiliseespar certaines methodes standard. Par exemple : IOException et ses derivees sont utilisees par lesmethodes d’entree/sortie.

D’autres exceptions sont utilisees par la JVM lors de situation anormales comme un indice detableau hors limites, une taille de tableau negative, une operation de lecture a la fin d’un fichier,...

Il existe 2 categories d’exception :— les exceptions explicites (ou sous controle) correspondant a celles que nous venons d’etudier.

Elles doivent etre traitees dans une methode ou bien etre mentionnees par la clause throws.— les exceptions implicites (ou hors controle) n’ont pas a etre mentionnees dans une clause

throw et on n’est pas obliger de les traiter (mais il est quand meme possible de le faire).

Exemple de traitement.


{


{

try

{ //on ne fait pas de verification sur les arguments pour alleger le code

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 negative "+e.getMessage());

}

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 probleme a traiter.

5.6 Exercices de Cours

5.6.1 Vrai ou Faux ?

1. Un bloc try doit etre suivi d’un bloc catch et d’un bloc finally :

2. Si on ecrit une methode susceptible de declencher une exception verifiee par le compilateur,on doit envelopper le code dans un bloc try/catch :

3. Les blocs catch peuvent etre polymorphes : .

4. Seules les exceptions verifiees par le compilateur peuvent etre interceptees :

5. Si on definit un bloc try/catch, le bloc finally correspondant est optionnel :

6. Si on definit un bloc try, on peut l’apparier avec un bloc catch ou un bloc finally, ou lesdeux :

7. Si on ecrit une methode qui declare qu’elle peut lancer une exception verifiee par le compi-lateur, on doit envelopper le code dans un bloc try/catch :

8. La methode main dot gerer toutes les exceptions non gerees qui lui parviennent :

9. Un seul bloc try peut avoir plusieurs blocs catch differents :

10. Une methode ne peut lancer qu’un seul type d’exception :

11. Un bloc finally peut s’executer sans qu’une exception soit lancee :

12. Un bloc finally peut exister sans bloc try :

13. Un bloc try peut exister seul, sans catch ni finally :

14. Lorsqu’on gere une exception on dit parfois qu’on l’esquive :

15. L’ordre des blocs catch n’a jamais d’importance :

16. Une methode ayant un bloc try et un bloc finally peut eventuellement declarer l’exception :

17. Les exceptions susceptibles de survenir a l’execution doivent etre gerees ou declarees :


5.6.2 Mots croises

2423

2221

20

19

18

17

16151413

12

111098

7654

321

HORIZONTALEMENT

4 Donne une valeur (-)

6 Intercepte (-)

8 Arbre genealogique (-)

12 On en herite (-)

14 Recette de code (-)

18 Programme (-)

19 Le plus petit primitif (-)

20 Constante (-)

21 Lance (-)

22 Non abstraite (-)

23 Instances de classes (-)

24 Gestion ou ... telle est la loi (-)

VERTICALEMENT

1 A beaucoup de methodes statiques (-)

2 Declare une exception (-)

3 Otees de la pile (-)

5 Patron d’objet (-)

6 Programmer (-)

7 Avant le catch (-)

9 Faire du nouveau (-)

10 Transformerions en bytecode (-)

11 Objet (-)

13 Pas un comportement (-)

15 Posent des conditions (-)

16 Erreur ou probleme (-)

17 A des decimales (-)

Chapitre 6

Les chaınes de caracteres en Java

6.1 Le type String

6.1.1 Les chaınes de caracteres sont des objets

Voici plusieurs manieres de creer des chaınes :

String ch1 = new String();

String ch2 = new String("hello");

String ch3 = new String(ch2);

String ch4 = "hello";

hello

hello

hello

ch1

ch2

ch3

ch4

La derniere instruction est equivalente a la deuxieme.Les objets de type String ne sont pas modifiables

6.1.2 Affichage d’une chaıne

Pour afficher une chaıne sur la sortie standard on peut utiliser : System.out.println(ch2);Pour afficher une erreur, on peut utiliser : System.err.println("Attention Erreur");

6.1.3 Longueur d’une chaıne

String ch = "bonjour";

int l = ch.length();

Attention : pour les chaınes on utilise une methode pour obtenir la taille, d’ou l’usage desparentheses (dans le cas de tableaux il s’agissait d’un champ !).

6.1.4 acces aux caracteres

String ch = "bonjour";

char c1=ch.charAt(0); //caractere a la position 0 : le ’b’

char c2=ch.charAt(2); //caractere a la position 2 : le ’n’

Note : on peut integrer des caracteres speciaux

String salutation="\tBonjour\n\t\ta tous";

99

100 CHAPITRE 6. LES CHAINES DE CARACTERES EN JAVA

6.1.5 Concatenation : l’operateur +

String ch1 = "le langage";

String ch2 = " java";

String ch3 = ch1 + ch2;

javach2le langage ch1

ch3 le langage java

Lorsque l’operateur + est utilise avec au moins une chaıne, les autres operandes sont convertisautomatiquement en chaıne.

int n=24;

int y=2005;

String d=new String("Nous le somme le " + n + " octobre " + y);

L’operateur += est aussi utilisable :

String ch="bonjour ";

ch +=" monsieur";

Un nouvel objet contenant la chaıne bonjour monsieur est cree et l’ancienne chaıne bonjour de-vient candidate au ramasse-miettes.

Autre exemple : a la fin on affiche : chiffres= 0123456789

String ch="chiffres= ";

for(int i=0;i<10;i++)

ch+=i;

System.out.println(ch);

6.1.6 Recherche dans une chaıne : la methode indexOf

Elle cherche a partir du debut (ou la fin) d’une chaıne ou d’une position donnee :— soit la premiere position d’un caractere,— soit la premiere occurrence d’une chaıne.

Elle renvoie la position si une correspondance a ete trouvee, -1 sinon.

String mot="anticonstitutionnellement"; //mot de 25 lettres

int n;

n=mot.indexOf(’t’); //renvoie la position 2

n=mot.lastIndexOf(’t’); //renvoie la position 24 (derniere occurrence)

n=mot.lastindexOf("ti"); //renvoie la position 12

n=mot.indexOf("ti"); //renvoie la position 2

n=mot.indexOf(’x’); //renvoie la position -1

n=mot.indexOf("ti",6); // recherche a partir de la position 6, renvoie 8

n=mot.lastIndexOf(’t’,9); //recherche a partir de la position 9, renvoie 24

6.1.7 La comparaison de chaınes

Les chaınes etant des objets, les operateurs == et ! = testent les adresses des objets et non lecontenu. On ne peut pas les utiliser directement pour comparer des chaınes.

Tester l’egalite de deux chaınes

ch1.equals(ch2) renvoie true si le contenu de ch1 est le meme que le contenu de ch2 et falsesinon.

6.1. LE TYPE STRING 101

Comparer deux chaınes

ch1.compareTo(ch2) renvoie— un entier negatif si ch1 est situee avant ch2— un entier nul (0) si les 2 chaınes sont egales— un entier positif si ch1 est situee apres ch2

L’ordre utilise est l’ordre classique sur les caracteres defini par la table ascii (correspondant al’ordre alphabetique pour les lettres).

ch1 ch2 ch1.compareTo(ch2)

bonjour monsieur < 0bonj monsieur < 0

prix12 prix10 > 0Element element < 0Element element < 0element element > 0bonjour bonjour 0

monsieur bonjour > 0

6.1.8 Modification d’un caractere

String ch="bonjour";

String ch1=ch.replace(’o’,’a’);

Attention un nouvel objet est cree, reference par ch1, on aurait pu ecrire ch=ch.replace(’o’,’a’);

6.1.9 Extraction de sous-chaınes

String ch="bonjour";

String ch1=ch.substring(3); // ch1 contient "jour"

String ch2=ch.substring(2,4); // ch2 contient "njo"

Notez ici une exception sur le nom de la methode.

6.1.10 Passage en majuscules/minuscules

String ch1=ch.toLowerCase(); // passage en minuscule

String ch2=ch.toUpperCase(); // passage en majuscule

6.1.11 Conversion d’une chaıne vers un type primitif

Vous pouvez utiliser les methodes explicites suivantes :— Byte.parseByte(ch);

— Short.parseShort(ch);

— Integer.parseInt(ch);

— Long.parseLong(ch);

— Float.parseFloat(ch);

— Double.parseDouble(ch);

S’il y a un caractere qui pose probleme lors de la conversion une exception est levee (BuildException).

6.1.12 Conversion d’un type primitif vers une chaıne

On peut soit utiliser l’operateur +, soit la methode String.value()


float f=2.5f;

String ch0=""+f; // premiere possibilite

String ch1=String.value(f); //deuxieme possibilite

6.1.13 Chaınes et tableaux de caracteres

— Convertir un tableau de caracteres en chaınechar mot[]={’b’,’o’,’n’,’j’,’o’,’u’,’r’};

String ch=new String(mot);

— Convertir une chaıne en tableau de caracteresString ch="bonjour";

char mot[]=ch.toCharArray();

6.1.14 Tableau de chaınes

Le tableau args de la methode main, contenant les arguments du programme, est un tableaude chaıne.


{

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 difference entre args.length qui la longueur du tableau et args[i].length() qui estlongueur de la chaıne a la position i du tableau.

6.2 La classe StringBuffer

La classe StringBuffer fait partie du package java.lang et contrairement a la classe String,elle utilise un buffer de taille variable pour memoriser une chaıne de caracteres modifiables. Cetteclasse final maintient elle-meme l’allocation d’espace supplementaire pour memoriser l’ajout decaracteres. Elle permet donc de manipuler des chaınes modifiable. Voici la liste des methodes decette classe :

— public StringBuffer() : construit une chaıne vide— public StringBuffer(int length) : construit une chaıne de longueur length— public StringBuffer(String str) : construit une chaıne de type StringBuffer a partir

d’une chaıne de caracteres classique— int length() : renvoie la taille de la chaıne (comme dans String)— void setCharAt(int index, char c) : modifie le caractere a la position index en le rem-

placant par c— StringBuffer append(String str) : ajoute la chaıne str en fin (possibilite de mettre un

tableau de caracteres ou un objet au lieu d’une String)— StringBuffer insert(int offset, String str) : insere une chaıne a l’indice offset— String toString() convertit la chaıne au type String

Pour 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 decomposer une chaıne de caracteres en une suite de ”mots”

6.3. LA CLASSE STRINGTOKENIZER 103

separes par des ”delimiteurs”.

Voici les constructeurs :— StringTokenizer(String str, String delim, boolean returnDelims) : str est la chaıne

a analyser, delim est une chaıne contenant les delimiteurs reconnus, returnDelims indiquesi les delimiteurs doivent etre renvoyes comme parties de la chaıne.

— StringTokenizer(String str) : cree un objet StringTokenizer, str est la chaıne a ana-lyser ; les delimiteurs sont les caracteres espace, tabulation, retour chariot et changementde ligne.

— StringTokenizer(String str, String delim) : cree un objet StringTokenizer, str estla chaıne a analyser, delim est une chaıne contenant les delimiteurs reconnus. Par defaut,les delimiteurs ne sont pas renvoyes comme elements de la chaıne.

La liste des methodes :— int countTokens() : calcul le nombre de fois que la methode nextToken() peut etre

appelee avant la generation d’une exception.— boolean hasMoreElements() : retourne la meme valeur que la methode hasMoreTokens().— boolean hasMoreTokens() : verifie s’il n’y a plus de jetons disponibles a partir de l’objet

StringTokenizer.— Object nextElement() : retourne la meme valeur que la methode nextToken().— String nextToken() : retourne le prochain jeton a partir de l’objet StringTokenizer.— String nextToken(String delim) : retourne le prochain jeton par rapport au delimiteur

specifie.Exemple :

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’est

une

ligne

Autre exemple :

StringTokenizer st = new StringTokenizer("/home/toto/TP-JAVA","/-",false);

System.out.println("Il y a "+st.countTokens()+" elements dans la chaıne");

while (st.hasMoreTokens()) {

System.out.println(st.nextToken());

}

Ce bout de code provoque l’affichage de :

home

toto

TP

JAVA


Chapitre 7

Les entrees/sorties

7.1 Les fichiers, la classe File

L’objet File constitue une representation abstraite d’un chemin vers un fichier ou un repertoire.

Le separateur de chemin depend de la plateforme. Sous Unix la valeur de ce separateur est ’/’alors que sous Windows sa valeur est egale a ’\’.

7.1.1 Les champs

— static String pathSeparator : Ce champ represente le caractere de separation par defautdependant du systeme sous-jacent, sous la forme d’une chaıne de caracteres pour des raisonsde commodites.

— static char pathSeparatorChar : Ce champ represente le caractere de separation dechemin par defaut dependant du systeme sous-jacent.

— static String separator : Ce champ represente le caractere de separation par defautdependant du systeme sous-jacent, sous la forme d’une chaıne de caracteres pour des raisonsde commodites.

— static char separatorChar : Ce champ represente le caractere de separation par defautdependant du systeme sous-jacent.

7.1.2 Les constructeurs

— File(File parent, String child) cree un nouvel objet File a partir d’un autre cheminabstrait designant le parent et d’une chaıne de caracteres indiquant un chemin enfant.

— File(String pathname) cree un nouvel objet File a partir d’un chemin donne sous laforme d’une chaıne de caracteres.

— File(String parent, String child) cree un nouvel objet File a partir de deux chaınesde caracteres designant respectivement un chemin parent et un autre enfant.

— File(URI uri) cree un nouvel objet File en convertissant l’URI fourni en chemin abstrait.

7.1.3 Les methodes

— boolean canRead() teste si l’application peut lire le fichier designe par l’objet File.— boolean canWrite() teste si l’application peut modifier le fichier designe par le chemin

abstrait.— int compareTo(File pathname) compare lexicographiquement deux objets File.— int compareTo(Object o) compare l’objet File par rapport a un autre objet.— boolean createNewFile() cree atomiquement un nouveau fichier vide designe par le che-

min abstrait si et seulement si un fichier de meme nom n’existe pas encore.

105

106 CHAPITRE 7. LES ENTREES/SORTIES

— static File createTempFile(String prefix, String suffix) cree un nouvel objetFile vide dans le repertoire temporaire par defaut en utilisant le prefixe et le suffixe donnespour generer son nom.

— static File createTempFile(String prefix, String suffix, File directory) creeun nouvel objet File vide dans le repertoire specifie en utilisant le prefixe et le suffixe donnespour generer son nom.

— boolean delete() supprime le fichier ou le repertoire designe par l’objet File.— void deleteOnExit() demande que le fichier ou le repertoire designe par le chemin abstrait

soit supprime lorsque la Machine Virtuelle Java s’arrete.— boolean equals(Object obj) teste l’egalite de l’objet File par rapport a un autre objet.— boolean exists() teste si le fichier designe par le chemin abstrait existe.— File getAbsoluteFile() retourne la forme absolue du chemin abstrait.— String getAbsolutePath() retourne le chemin absolu sous la forme d’une chaıne de ca-

racteres de l’objet File.— String getName() retourne le nom du fichier ou du repertoire designe par le chemin abs-

trait.— String getParent() retourne le chemin parent, sous la forme d’une chaıne de caracteres,

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ıne de caracteres.

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 designe par le chemin abstrait est un repertoire.— boolean isFile() teste si le fichier designe par le chemin abstrait est un fichier normal.— boolean isHidden() teste si le fichier designe par le chemin abstrait est un fichier cache.— long lastModified() retourne le temps de la derniere modification du fichier donne par

le chemin abstrait.— long length() Renvoie la longueur du fichier designe par le chemin asbtrait.— String[] list() retourne un tableau de chaınes de caracteres indiquant les fichiers et

repertoires dans le repertoire specifie par le chemin abstrait.— boolean mkdir() cree le repertoire designe par le chemin abstrait.— boolean mkdirs() cree le repertoire et eventuellement ses repertoires parents designes par

le chemin abstrait.— boolean renameTo(File dest) renomme le fichier defini par le chemin abstrait.— boolean setLastModified(long time) fixe le temps de la derniere modification du fichier

ou du repertoire designe par le chemin abstrait.— boolean setReadOnly() marque le fichier ou le repertoire nomme par le chemin abstrait

de telle facon que des operations en lecture seule sont autorisees.

7.2 Les flux

L’ecriture et la lecture de fichiers impliquent l’utilisation de flux (streams). Ces derniersrepresentent des canaux de transmission de donnees a partir d’une source ou vers une destination.

Dans ces canaux, deux types d’informations peuvent transiter de l’application vers un fichierou inversement. Il s’agıt de flux de donnees binaires ou de caracteres. Cette distinction permet detraiter differemment les fichiers textes dont l’extension peut etre .txt, .ini, .log, .xml, etc., et lesfichiers binaires comme les images, videos, sons et autres...

Les flux sont egalement capables de faire transiter des informations provenant d’une entreestandard (System.in) telle que le clavier, ou allant vers une sortie standard (System.out) commel’ecran.

Ainsi, on distingue quatre familles de flux appeles egalement flots :— Les flots en lecture ou d’entree,

7.3. LECTURE/ECRITURE 107

— Les flots en ecriture ou de sortie,— Les flots binaires,— Les flots de caracteres.Les flots d’entree et de sortie peuvent etre utilises pour n’importe quel peripherique, a l’image

d’un ecran, d’une imprimante, d’un fichier disque ou du reseau (sortie du programme) et d’unclavier, d’une souris, d’un ordinateur distant ou d’un fichier disque (entree du programme).

Il est possible de combiner les flux ci-dessus, de cette facon :— Les flots binaires en lecture,— Les flots binaires en ecriture,— Les flots de caracteres en lecture,— Les flots de caracteres en ecriture.Les flux sont unidirectionnels, et possedent donc seulement une entree et une sortie. Ils ne

peuvent envoyer des informations que dans un seul et unique sens.Les classes appropriees pour l’utilisation des flux se trouvent dans le paquetage java.io.On distingue quatre classes principales dont toutes les autres heritent des representations et

comportements propre a chaque famille.— java.io.InputStream (flot binaire en lecture),— java.io.OutputStream (flot binaire en ecriture),— java.io.Reader (flot de caracteres en lecture),— java.io.Writer (flot de caracteres en ecriture).

7.3 Lecture/ecriture

Voici un exemple de classe effectuant une lecture/ecriture d’un fichier. Dans un premier temps,on lit le contenu d’un fichier nomme "poeme.txt" et on range chacune des lignes dans une structurede type StringBuffer (cf le chapitre precedent pour ce type). Dans un second temps, on ecritdans un fichier nomme "poeme copie.txt", on commence par y ecrire Ma chaine puis un saut deligne, ensuite on ecrit le contenu stocke dans un StringBuffer.

import 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("\r\n");

}

tamponLecture.close();

fluxLectureTexte.close();

}

catch(IOException e)

{

System.err.println("Erreur de lecture");

}

108 CHAPITRE 7. LES ENTREES/SORTIES

try{

//exemple d’ecriture

File cheminAbstraitSortie = new File("poeme_copie.txt");

FileWriter fluxEcritureTexte = new FileWriter(cheminAbstraitSortie);

BufferedWriter tamponEcriture = new BufferedWriter(fluxEcritureTexte);

tamponEcriture.write("Ma chaine\n");

tamponEcriture.flush();

tamponEcriture.write(contenu.toString());

tamponEcriture.flush();

tamponEcriture.close();

fluxEcritureTexte.close();

}

catch(IOException e)

{

System.err.println("Erreur d’ecriture");

}

}

}

On commence par creer une variable de type File. Ensuite, dans le cas d’une lecture de fichier,on cree une flux de type FileReader et ce flux est mis dans un tampon de type BufferedReader.La lecture dans le tampon se fait a l’aide de la methode readLine(). Pour l’ecriture, on creeun flux de type FileWriter, que l’on met dans un tampon BufferedWriter et l’ecriture se faita l’aide de la methode write. La methode flush sert a vider le contenu du tampon. A chaquefois, les differents flux doivent etre d’abord ouverts (instructions new), puis fermes (instructionsclose a la fin.

Note : pour limiter les acces au disque dur, java conserve les caracteres devant etre ecrits dansun fichier dans un tampon (buffer en anglais), puis ecrit le contenu du tampon dans le fichierlorsque le tampon est plein. Si l’on veut forcer l’ecriture du contenu du tampon dans le fichier onpeut utiliser la commande flush. Il faut toujours appliquer flush au moins une fois juste avantla fermeture du fichier.

Chapitre 8

Quelques elements de l’API

8.1 La classe Math

La classe Math possede 2 constantes Math.PI (le nombre pi) et Math.E (exponentielle e1). Ellepossede egalement plusieurs methodes statiques, en voici quelques-unes :

— 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 a l’entier le plus proche (renvoie un int pour

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 egalement disponibles.— Math.pow(nombre1,nombre2) : renvoie nombre1nombre2, retour de type double.— Math.log(nombreDouble) : renvoie le logarithme neperien d’un nombre, retour de type

double.— Math.sqrt(nombreDouble) : renvoie la racine carre d’un nombre, retour de type double.Il en existe quelques autres, a vous d’aller les consulter dans l’API.

8.2 Les classes enveloppes pour les valeurs primitives

Il est parfois necessaire de traiter des valeurs primitives comme des objets, par exemple pourles 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 ArrayList

puisque celui-ci ne peut contenir que des objets.Il existe une classe enveloppe (un wrapper) pour chaque type primitif. Elles trouvent dans le

package java.lang, vous n’avez donc pas besoin de les importer. Elles sont faciles a reconnaıtreparce que chacune d’elles est nommee d’apres le type primitif qu’elle enveloppe, mais la premierelettre 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 Character

aux char, et que les autres classes ont le meme nom que leur type associe.— Boolean

— Character

— Byte

— Short

— Integer

— Long

— Float

109

110 CHAPITRE 8. QUELQUES ELEMENTS DE L’API

— Double

Voici 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 meme maniere, Boolean a une methode booleanValue(),Character a une methode characterValue(), etc.

Ces classes ont egalement des methodes statiques tres utiles comme Integer.parseInt().De maniere generale, les methodes de transformation parseXXX() acceptent une valeur de typeString et retournent une valeur de type primitif.

String s = "2";

int x = Integer.parseInt(s);

double d = Double.parseDouble("420.24");

//Attention petite difference pour les booleens

//qui n’acceptent que des valeurs true/false

boolean b = new Boolean("true").booleanValue();

Notez que lorsqu’une chaıne de caractere ne peut etre convertie, une exception NumberFormatException

peut se produire. Elle se produit a l’execution, vous n’etes pas oblige de la gerer ou de la declarer.Nous pouvons egalement faire l’inverse : transformer un nombre en chaıne de caracteres. Il

existe 2 methodes principales :

double d = 42.5;

String doubleString1 = "" + d;

String doubleString2 = Double.toString(d);

8.3 Les collections

8.3.1 Definition

Les principales structures de donnees des classes utilitaires (java.util) sont regroupees sousune meme interface Collection. Cette interface est implemente par des ensembles, vecteurs dyna-miques, tables associatives que nous allons voir dans cette partie. Les elements de type collectionpossedent des methodes pour ajouter, supprimer, modifier des elements de type divers. Ellespeuvent etre parcourues a l’aide d’iterateur (autrefois ceux-ci portaient le nom d’enumeration).Nous verrons une illustration des differentes possibilites des collections lors des descriptions desclasses presentees ci-dessous implementant l’interface Collection (nous ne verrons cependant pasla classe LinkedList mais ses fonctionnalites sont proches de celles des autres classes).

Notez que lorsque que l’ordre des elements est important la methode compareTo (deja vue lorsde la partie sur la classe Object) est utilisee.

8.3.2 ArrayList

Il s’agit d’une sorte de tableau d’objets de taille variable, fonctionnant comme une sorte deliste. Il peut etre vu comme un vecteur.

8.3. LES COLLECTIONS 111

Construction

ArrayList v = new ArrayList(); //vecteur dynamique vide

Ajout d’un element

Object elem;

...

v.add(elem);

Taille de la liste On utilise la methode size() qui renvoie le nombre d’elements contenus dansla liste.

Suppression d’un element

Object o = v.remove(3); //supprime le 3eme element que l’on obtient dans o

//l’element renvoye est de type objet

//les elements suivants sont decales vers la gauche

v.removeRange(3,8); //supprime les elements de rang 3 a 8

Acces aux elements

ArrayList v = new ArrayList();

...

for(int i=0;i<v.size();i++)

{

System.out.println(v.get(i)+" ");

}

Syste.out.println();

Modifier un element a l’indice i

ArrayList v = new ArrayList();

Object o;

...

Object o1 = v.set(i,o);

La methode set renvoie la valeur de l’objet a l’indice i avant modification.

Parcours a l’aide d’un iterateur

ListIterator it = v.listIterator();

while(it.hasNext())

{

Object o = it.next();

...

}

Autes methodes— La methode boolean contains(Object o) renvoie true si l’objet est dans la liste et false

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 present


L’ancienne classe Vector

Dans ses versions anterieures, on y trouvait une classe Vector permettant comme ArrayList

de manipuler des vecteurs dynamiques. Cette classe est synchronisee, c’est-a-dire que 2 processusconcurrents (threads) peuvent acceder au meme vecteur.

Dans la version 5 de Java, la classe Vector a ete fortement remaniee et offre de nouvellespossibilites (a la fois en facilite d’ecriture et en fonctionnalites). A vous de decouvrir cette nouvelleclasse Vector.

8.3.3 Les ensembles

Deux classes implementent la notion d’ensemble : HashSet et TreeSet. Un ensemble est unecollection non ordonnee d’elements, un element ne pouvant apparaıtre qu’au plus une fois. Nousnous focaliserons plutot ici sur la notion de HashSet.

Construction et parcours

HashSet e1 = new HashSet(); // ensemble vide

Hashset e2 = new HashSet(c); // ensemble contenant tous les elements d’une collection c

Un parcours d’un ensemble se fait a l’aide d’un iterateur.

HashSet e;

...

Iterator it = e.iterator();

while(it.hasNext())

{

Object o = it.next();

....

}

Ajout d’un element

HashSet e;

Object elem;

...

boolean existe = e.add(elem);

if(existe) Sytem.out.println(elem+" existe deja");

else Sytem.out.println(elem+" a ete ajoute");

Suppression

HashSet 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 possibilite.

HashSet e;

...

Iterator it = e.iterator();

it.next(); it.next();

it.remove();


Operations ensemblistes— e1.addAll(e2) place dans e1 tous les elements de e2.— e1.retain(e2) garde dans e1 tout ce qui appartient a e2.— e1.removeAll(e2) supprime de e1 tout ce qui appartient a e2.

Notion de Hachage Un ensemble HashSet est implemente par une table de hachage, c’est-a-dire que ses elements sont stockes selon une position donnee. Cette position est definie selon un codecalcule par la methode int hashCode() utilisant la valeur effective des objets. Les classes Stringet File par exemple implementent deja cette methode. Par contre les autres classes utilisent pardefaut une methode derivee de Object qui se content d’utiliser comme valeur la simple adressedes objets (dans ces conditions 2 objets de meme valeur auront toujours des codes de hachagedifferents). Si l’on souhaite definir une egalite des elements bases sur leur valeur effective, il fautredefinir la methode hashCode dans la classe correspondante.

Voici une exemple avec la classe Point. La redefinition de la methode equals sert a definirl’egalite entre les objets de maniere a n’avoir qu’un seul element dans un ensemble (pour rappeldans un HashSet les elements ne peuvent apparaitre qu’une seule fois).

import java.util.*;

class Point

{

private int x,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()));

}


{

return "["+x+" "+"] ";

}

public int getX() { return x; }

public int getY() { return y; }

}

public class EnsPt

{


{

Point p1 = new Point(1,3);





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);

}


}

}

Resultat.

le point [1 3] a ete ajoute

ensemble = [1 3]


ensemble = [2 2] [1 3]

le point [1 3] est deja present

ensemble = [2 2] [1 3]


ensemble = [4 5] [2 2] [1 3]


ensemble = [1 8] [4 5] [2 2] [1 3]

le point [4 5] est deja present

ensemble = [1 8] [4 5] [2 2] [1 3]

Remarque la fonction de hachage est dictee par la simplicite, des points de coordonnees differentespeuvent avoir la valeur de hashCode. Il faudrait trouver une fonction qui renvoie une valeur uniquepour chaque point.

8.3.4 Les algorithmes

Recherche de maximum ou minimum

import java.util.*;


/*la methode compareTo est definie dans l’interface Comparable

class Point implements Comparable

{

private int x,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;

}


{

return "["+x+" "+y+"]";

}

public int getX() {return x;}

public int getY() {return y;}

}

public class MaxMin

{


{





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);

}

}

Resultat.

Max suivant compareTo = [4 5]

Algorithme de tris et melanges

Exemple complet. L’ordre utilise est celui definit par la methode compareTo ;

import java.util.*;


public class Tri

{


{

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 elements de t

System.out.println("t trie = "+t);

Collections.shuffle(t); //melange des elements de t

System.out.println("t melange = "+t);

Collections.sort(t,Collections.reverseOrder()); //tri des elements de t en ordre inverse

System.out.println("t trie inverse= "+t);

}

}

Resultat.

t 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 nommees cle et valeur. Elle est principalement destinee a retrouver la valeur associee a unecle donnee. Les exemples les plus caracteristiques de telles tables sont :

— le dictionnaire : a un mot (cle) on associe une valeur qui est sa definition,— l’annuaire usuel : a un nom (cle) on associe une valeur comportant le numero de telephone

et eventuellement une adresse,— l’annuaire inverse : a un numero de telephone (qui devient la cle) on associe une valeur

comportant le nom et eventuellement une adresse.

Ces tables sont tres utilisees lorsque l’on souhaite manipuler des donnees provenant de basesde donnees : on peut associer a un enregistrement un ensemble de valeurs.

Ajout d’information

HashMap m = new HashMap(); //table vide

...

m.put("p",new Integer(3)); //ajoute a la table m un nouvel element

//associant la cle "p" (String) a la valeur 3 (Integer)

Si la cle fournie a put existe deja, la valeur associee remplacera l’ancienne (une cle donnee nepouvant figurer qu’une seule fois dans la table). put fourni en retour soit l’ancienne valeur si lacle existait deja soit null.

Les cles et les valeurs doivent obligatoirement etre des objets. Il n’est pas necessaire que lescles soient de meme type, pas plus que les elements, ce sera cependant souvent le cas pour desraisons evidentes de facilite d’exploitation de la table.


Recherche d’information

Object o = m.get("x");

if(o==null) System.out.println("Aucune valeur associee a la cle");

if(m.containsKey("p"))

Integer n = (Integer) m.get("p");

Suppression d’information

Object cle = "x";

Object val = m.remove(cle); //supprime cle+valeur de cle x

if(val!=null)

System.out.println("On a supprime l’element de cle "+cle+" et de valeur"+val);

else System.out.println("la cle "+cle+" n’existe pas");

Parcours d’une table : la notion de vue

HashMap m;

....

Set entrees = m.entrySet(); //entrees est un ensemble de paires

Iterator 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 renvoye par entrySet n’est pas une copie de la table, c’est une vue.

Autre vues— L’ensemble des cles :

HashMap m;

...

Set cles = m.keySet();

— La collection des valeurs :Collection valeurs = m.values();

Exemple complet

import java.util.*;

public class Map1

{


{

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 associee a la cle "f"

String ch = (String) m.get("f");


System.out.println("Valeur associee a f "+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);

}

}

Resultat.

map initial : {c=10, x=40, p=50, k=30, g=60, f=20}

valeur associee a f : 20

liste 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 : 40

map 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 f

map 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’ancetre de la classe HashMap.

8.4. DIVERS 119

8.4 Divers

8.4.1 Elements disponibles a partir de Java 1.5

Il existe plusieurs instructions et structures qui ont ete ajoutees a partir de la version 1.5. Nousindiquons deux principales ici, a vous de decouvrir les autres si vous souhaitez aller plus loin.

Boucle for amelioree

Une nouvelle boucle for a ete ajoutee au language dans le but d’alleger l’ecriture de deuxsortes de boucles frequemment utilisees : le parcours d’un tableau et le parcours d’une collection.

— Si un tableau contient des elements d’un certain type TypeElement (qui peut-etre un typeprimitif, un tableau ou une classe), la bouclefor(int i=0;i<tableau.length;i++)

{

lancerMethode(tableau[i]);

}

peut etre ecrite plus simplement :for(TypeElement elt : tableau)

lancerMethode(elt);

— si liste est une structure de donnee capable d’etre parcourue par un iterateur (c’est-a-direun objet de type Collection) et contenant toujours des elements de type TypeElement, labouclefor(Iterateur it=liste.iterator() ; it.hasNext() ; )

lancerMethode( (TypeElement) it.next());

peut etre ecrite plus simplement :for(TypeElement elt: liste)

lancerMethode(elt);

8.4.2 Genericite

Si on souhaite definir une collection (vector, arraylist, ...) contenant un ensemble d’objets desorte que tous ces objets soient de type TypeObjet, on peut definir des collections ne contenant quece type d’objet en declarant : List<TypeElement>. Ceci permet de verifier que l’ajout d’elementsa la liste sont bien de type TypeElement et que lors d’acces a des elements de la liste on a lacertitude qu’ils sont bien de type TypeElement.

Un petit exemple.

Vector<TypeElement> v=new Vector<TypeElement>(); //declaration

...

//on peut ajouter uniquement des objets de TypeElement

//ici monobjet doit etre obligatoirement de ce type

v.add(monobjet);

...

//on peut recuperer directement des objets TypeElement

for(int i=0;i<v.size();i++)

{

TypeElement e=v.get(i);

lancerMethode(e);

}

8.4.3 Reflection et Manipulation des types

Note : cette section sort du cadre de ce cours et est la uniquement a titre d’information. Le


contenu de cette section est tire du polycopie Java d’Henri Garreta.

La classe java.lang.Class et les classes du paquet java.lang.reflect (aux noms evocateurs,comme Field, Method, Constructor, Array, etc.) offrent la possibilite de pratiquer une cer-taine introspection : un objet peut inspecter une classe, eventuellement la sienne propre, accedera la liste de ses membres, appeler une methode dont le nom n’est connu qu’a l’execution, etc. Uneinstance de la classe java.lang.Class represente un type (c’est-a-dire un type primitif ou uneclasse). Supposons que nous ayons une variable declaree ainsi : Class uneClasse;

Nous avons plusieurs manieres de lui donner une valeur :— une classe-enveloppe d’un type primitif (Integer, Double, etc.) possede une constante de

classe TYPE qui represente le type primitif en question ; de plus, l’expression type.class

a le meme effet. Ainsi, les deux expressions suivantes affectent le type int a la variableuneClasse :uneClasse = Integer.TYPE;

uneClasse = int.class;

— si uneClasse est l’identificateur d’une classe, alors l’expression uneClasse.class a pourvaleur la classe en question. L’exemple suivant affecte le type java.math.BigInteger a lavariable uneClasse :uneClasse = java.math.BigInteger.class;

Notez la difference entre TYPE et class pour les classes-enveloppes des types primitifs :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, a partir de son nom completementspecifie. C’est un procede plus onereux que les precedents, ou la plupart du travail de char-gement (dont a la detection d’eventuelles erreurs dans les noms des classes) etait fait durantla compilation alors que, dans le cas present, il sera fait pendant l’excution. L’exemple sui-vant affecte encore le type java.math.BigInteger a la variable uneClasse :uneClasse = Class.forName("java.math.BigInteger");

— enfin, le moyen le plus naturel est de demander a un objet quelle est sa classe. L’exemplesuivant affecte encore le type java.math.BigInteger a la variable uneClasse :Object unObjet = new

BigInteger("92233720368547758079223372036854775807");

...

uneClasse = unObjet.getClass();

Pour survoler cette question assez pointue, voici un exemple qui illustre quelques unes despossibilites de e la classe Class et du paquet reflect. La methode demoReflexion ci-dessous,purement demonstrative, prend deux objets quelconques a et b et appelle successivement toutesles methodes qui peuvent etre appelees sur a avec b pour argument, c’est-a-dire les methodesd’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 121

import 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 precedent affiche la sortie suivante :

1001.compareTo(1003) = -1

1001.min(1003) = 1001

1001.add(1003) = 2004

...

1001.gcd(1003) = 1

1001.mod(1003) = 1001

1001.modInverse(1003) = 501

8.5 Les autres elements de l’API

A vous de consulter regulierement l’API pour trouver les classes dont vous pouvez avoir besoin.Sachez, par exemple, qu’il existe des classes pour traiter des dates, du son, . . .

Documents

Programmation Orientée Objets Le Langage JAVA