Polycope java enseignant

Version enseignant

Module IP1
Programmation Orient´e Objets
e
Le Langage JAVA

Amaury Habrard
Universit´ de Provence Aix-Marseille I
e
amaury.habrard@lif.univ-mrs.fr

Table des mati`res
e

1 Avant propos 7

2 Introduction : le langage JAVA 9
2.1 Pr´sentation . . . . . . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 9
2.2 Historique du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Quelques mots cl´s . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 10
2.3 Java et la programmation orienté objet . . . . . . . . . .
e . . . . . . . . . . . . . . 10
2.3.1 Le concept d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.2 Ind´pendance vis ` vis de la plateforme . . . . . .
e a . . . . . . . . . . . . . . 11
2.4 Structure d’un programme JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.1 Que contient un fichier source ? . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.2 Execution d’un programme Java . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.3 La machine virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.4 La m´thode main . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 12
2.4.5 Utilisation d’arguments dans la fonction main . . . . . . . . . . . . . . . . . 13
2.5 Installation et utilisation de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6 Types, expressions et structures de contrˆle fondamentales
o . . . . . . . . . . . . . . 15
2.6.1 les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
La notion de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
le type entier (int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Les flottants/réls (float ou double) . . . . . . . .
e . . . . . . . . . . . . . . 16
Le type caract`re (char) . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 16
Le type boolén (boolean) . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 16
Initialisations et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6.2 Op´rateurs et expressions . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 17
Op´rateurs arithm´tiques . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . 17
Op´rateurs de comparaison . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 17
Op´rateurs logiques . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 18
Op´rateurs d’affectation . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 18
Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Op´rateur conditionnel . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 19
Priorit´ des op´rateurs . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . 19
2.6.3 Les structures de contrˆle . . . . . . . . . . . . . .
o . . . . . . . . . . . . . . 20
if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Les instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . 24
2.6.4 Les ´l´ments spćifiques au langage JAVA . . . . .
ee e . . . . . . . . . . . . . . 25
2.7 Une premi`re introduction au type String . . . . . . . . .
e . . . . . . . . . . . . . . 25
2.8 R`gles d’ćriture d’un programme JAVA . . . . . . . . .
e e . . . . . . . . . . . . . . 26

3

4 `
TABLE DES MATIERES

2.8.1 Les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8.2 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.8.3 Mots cl´s r´serv´s . . . . . . . . . . . . . . . . .
e e e . . . . . . . . . . . . . . . 27
2.8.4 Remarques globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.8.5 Commentaires sur le rendu d’un programme Java . . . . . . . . . . . . . . . 27
2.8.6 Liens sur la programmation JAVA . . . . . . . . . . . . . . . . . . . . . . . 28
2.8.7 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9.2 Mots crois´s . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . 31

3 La notion d’objets : d´finition et utilisation
e 33
3.1 Introduction au d´veloppement objets . . . . . . . . . . .
e . . . . . . . . . . . . . . 33
3.2 La notion de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.1 Exemple de classe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.2 Crátion d’un objet ` l’aide d’une classe . . . . . .
e a . . . . . . . . . . . . . . 36
3.2.3 Exemple d’utilisation dans un programme complet . . . . . . . . . . . . . . 37
3.3 La notion de constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.4 Affectation et comparaison d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4.1 La r´f´rence null . . . . . . . . . . . . . . . . . . .
ee . . . . . . . . . . . . . . 40
3.5 Le ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.6 L’encapsulation de donnés . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 41
3.7 Champs et m´thodes statiques . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 43
3.7.1 Variables statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.7.2 Les m´thodes statiques . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 45
3.8 Surd´finition/surcharge de m´thodes . . . . . . . . . . . .
e e . . . . . . . . . . . . . . 46
3.8.1 Surd´finition de constructeurs . . . . . . . . . . . .
e . . . . . . . . . . . . . . 47
3.9 La copie d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.10 Autor´f´rencement : le mot cl´ this . . . . . . . . . . . .
ee e . . . . . . . . . . . . . . 49
3.11 Remarques sur la d´finition de m´thodes . . . . . . . . . .
e e . . . . . . . . . . . . . . 51
3.11.1 M´thodes de type proc´dures et fonctions . . . . .
e e . . . . . . . . . . . . . . 51
3.11.2 Les arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.11.3 Les variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.11.4 La rćursivit´ . . . . . . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . 53
3.12 Les paquetages (packages) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.12.1 Attribution d’une classe ` un paquetage . . . . . .
a . . . . . . . . . . . . . . 53
3.12.2 Utilisation d’une classe situé dans une paquetage
e . . . . . . . . . . . . . . 54
3.12.3 Droits d’acc`s . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 55
3.13 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.13.1 Dćlaration et crátion . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . 55
3.13.2 Tableau en argument ou en retour . . . . . . . . . . . . . . . . . . . . . . . 58
3.13.3 Les tableaux ` plusieurs indices . . . . . . . . . . .
a . . . . . . . . . . . . . . 59
3.14 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.14.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.14.2 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.14.3 Compilateur 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.14.4 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.14.5 Compilateur 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.14.6 Mots crois´s . . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 68
3.14.7 Mots crois´s . . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . 69

`
TABLE DES MATIERES 5

4 Les concepts d’H´ritage et de Polymorphisme
e 71
4.1 Pr´sentation et d´finition . . . . . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . . 71
4.2 Construction et initialisation des objets d´riv´s
e e . . . . . . . . . . . . . . . . . . . . 74
4.3 Red´finition, surd´finition et h´ritage . . . . . .
e e e . . . . . . . . . . . . . . . . . . . . 76
4.3.1 Red´finition . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . 76
4.3.2 La surchage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.3.3 En r´sum´ . . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . . 77
4.4 Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.4.1 Tableaux h´t´rog`nes d’objets . . . . . .
ee e . . . . . . . . . . . . . . . . . . . . 79
4.4.2 R`gles du polymorphisme en Java . . .
e . . . . . . . . . . . . . . . . . . . . 80
4.5 La super-classe Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
4.6 Acc`s par membres prot´g´s : protected . . .
e e e . . . . . . . . . . . . . . . . . . . . 82
4.7 M´thodes et classes finales . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . 82
4.8 Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.9 Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
4.9.1 D´finition et mise en œuvre . . . . . . .
e . . . . . . . . . . . . . . . . . . . . 84
4.9.2 Int´rˆt des interfaces . . . . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . . 85
4.10 Connaˆ la classe et les types d’un objet . . .
ıtre . . . . . . . . . . . . . . . . . . . . 85
4.10.1 L’op´rateur instanceof . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . . 85
4.10.2 La class Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.11.1 Classes abstraites - classes concr`tes . .
e . . . . . . . . . . . . . . . . . . . . 87
4.11.2 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.11.3 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.11.4 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

5 La gestion d’exceptions 91
5.1 Pr´sentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . 91
5.2 Gestion de plusieurs exceptions et transmission d’informations . . . . . . . . . . . 92
5.3 D´rivation et redćlenchement d’exceptions . . . . . . . . . . .
e e . . . . . . . . . . . 95
5.4 Le bloc finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.5 Les exceptions standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.6 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.6.1 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.6.2 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . 101

6 Les chaˆınes de caract`res en Java
e 103
6.1 Le type String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.1.1 Les chaˆ ınes de caract`res sont des objets . . . . .
e . . . . . . . . . . . . . . . 103
6.1.2 Affichage d’une chaˆ . . . . . . . . . . . . . . .
ıne . . . . . . . . . . . . . . . 103
6.1.3 Longueur d’une chaˆ . . . . . . . . . . . . . . .
ıne . . . . . . . . . . . . . . . 103
6.1.4 acc`s aux caract`res . . . . . . . . . . . . . . . .
e e . . . . . . . . . . . . . . . 103
6.1.5 Concatńation : l’op´rateur + . . . . . . . . . . .
e e . . . . . . . . . . . . . . . 104
6.1.6 Recherche dans une chaˆ : la m´thode indexOf
ıne e . . . . . . . . . . . . . . . 104
6.1.7 La comparaison de chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Tester l’´galit´ de deux chaˆ
e e ınes . . . . . . . . . . . . . . . . . . . . . . . . . 104
Comparer deux chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.1.8 Modification d’un caract`re . . . . . . . . . . . .
e . . . . . . . . . . . . . . . 105
6.1.9 Extraction de sous-chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.1.10 Passage en majuscules/minuscules . . . . . . . . . . . . . . . . . . . . . . . 105
6.1.11 Conversion d’une chaˆ vers un type primitif . .
ıne . . . . . . . . . . . . . . . 105
6.1.12 Conversion d’un type primitif vers une chaˆ . . ıne . . . . . . . . . . . . . . . 105
6.1.13 Chaˆınes et tableaux de caract`res . . . . . . . . .
e . . . . . . . . . . . . . . . 106
6.1.14 Tableau de chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

6 `
TABLE DES MATIERES

6.2 La classe StringBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.3 La classe StringTokenizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

7 Les entrés/sorties
e 109
7.1 Les fichiers, la classe File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.1.1 Les champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.1.2 Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.1.3 Les m´thodes . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.2 Les flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
7.3 Lecture/ćriture . . . . .
e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

8 Quelques ´l´ments de l’API
ee 113
8.1 La classe Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.2 Les classes enveloppes pour les valeurs primitives . . . . . . . . . . . . . . . . . . . 113
8.3 Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
8.3.1 D´finition . . . . . . . . . . . . . . . . . .
e . . . . . . . . . . . . . . . . . . . 114
8.3.2 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
L’ancienne classe Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.3.3 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.3.4 Les algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Recherche de maximum ou minimum . . . . . . . . . . . . . . . . . . . . . . 118
Algorithme de tris et m´langes . . . . . .
e . . . . . . . . . . . . . . . . . . . 119
8.3.5 Les tables associatives (HashMap) . . . . . . . . . . . . . . . . . . . . . . . . 120
8.4 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.4.1 El´ments disponibles a partir de Java 1.5
e ` . . . . . . . . . . . . . . . . . . . 123
Boucle for am´lioré . . . . . . . . . . . .
e e . . . . . . . . . . . . . . . . . . . 123
8.4.2 Gń´ricit´ . . . . . . . . . . . . . . . . . .
e e e . . . . . . . . . . . . . . . . . . . 123
8.4.3 R´flection et Manipulation des types . . .
e . . . . . . . . . . . . . . . . . . . 123
8.5 Les autres ´l´ments de l’API . . . . . . . . . . .
ee . . . . . . . . . . . . . . . . . . . 125

Chapitre 1

Avant propos

Ce polycopi´ de cours a pour objectif d’introduire les concepts fondamentaux de la program-
e
mation objet ` l’aide du langage java. Il est compos´ de 4 chapitres de cours et de 3 chapitre
a e
pr´sentant des ´l´ments de la biblioth`que du langage. A l’issue de chaque chapitre de cours, un
e ee e
ensemble d’exercices originaux sont propos´s. Ces exercices sont compl´mentaires au exercices de
e e
travaux dirig´s et au travaux pratiques. Ils ont pour objectif de faire travailler les notions vues en
e
cours sous une forme diff´rente et d’insister sur le vocabulaire spćifique ` java ou ` la program-
e e a a
mation objets, il est donc fortement conseill´ de chercher s´rieusement ces exercices. Voici un bref
e e
descriptif des diff´rents chapitres :
e
– Chapitre 2 : chapitre d’introduction pr´sentant le langage dans sa globalit´, son historique
e e
et les principes de bases pour ćrire un premier programme. On y d´taille tous les types
e e
primitifs, les structures de contrˆles et quelques structures fondamentales du langage. On
o
pr´sente ´galement les conventions ` suivre lorsque l’on programme en Java.
e e a
– Chapitre 3 : ce chapitre pr´sente la philosophie du langage : l’objet. On d´taille les diff´rentes
e e e
structures permettant de dćlarer et de crér les objets ainsi que les implications de chacune
e e
d’elles.
– Chapitre 4 : on y introduit des concepts fondamentaux de la programmation objet l’h´ritagee
et le polymorphisme. Ils font la force de ce type de programmation en permettant notam-
ment une meilleure lisibilit´ des programmes et une plus grande facilit´ de rútilisation de
e e e
l’existant.
– Chapitre 5 : dans ce chapitre la gestion d’erreurs via la notion d’exception est pr´senté. Ce
e e
type de gestion est propre au langage java.
– Chapitre 6 : premier chapitre pr´sentant une partie de la biblioth`que. On parle de l’acc`s `
e e e a
des fonctions math´matiques, de l’utilisation de listes ou de tables associatives et quelques
e
algorithmes utilisables.
– Chapitre 7 : pr´sentation des ´l´ments permettant de lire des flux et notamment de lire et
e ee
d’ćrire dans des fichiers.
e
– Chapitre 8 : d´tail de toutes les classes de la biblioth`que permettant de g´rer des chaˆ
e e e ınes
de caract`res, type fondamental et traiter de mani`re spćifique en Java.
e e e

Ce document en est ` sa deuxi`me version, il existe de mani`re certaine des coquilles, des
a e e
fautes de frappes, des oublis de mot, des erreurs de code involontaire, des copier/coller non perti-
nents, . . . Dans le but d’am´liorer ce document, merci de signaler toutes ces erreurs. Si vous avez
e
quelques suggestions pour am´liorer certaines parties, corriger certaines affirmations, elles sont les
e
bienvenues.

Bonne lecture et bon travail !

7

Chapitre 2

Introduction : le langage JAVA

2.1 Pr´sentation
e
Java est une technologie composé d’un langage de programmation orient´ objet et d’un en-
e e
vironnement d’exćution. Prálablement nomm´ Oak, il a ´t´ cr´´ par James Gosling et Patrick
e e e e e ee
Naughton chez Sun Microsystems avec le soutien de Bill Joy.
Le langage Java fut officiellement pr´sent´ le 23 mai 1995 au SunWorld.
e e
Java est ` la fois un langage de programmation et une plateforme d’exćution. Le langage Java
a e
a la particularit´ principale d’ˆtre portable sur plusieurs syst`mes d’exploitation tels que Windows,
e e e
MacOS ou Linux. C’est la plateforme qui garantit la portabilit´ des applications d´veloppés en
e e e
Java.
Le langage reprend en grande partie la syntaxe du langage C++, tr`s utilis´ par les infor-
e e
maticiens. Nánmoins, Java a ´t´ ´pur´ des concepts les plus subtils du C++ et ` la fois les
e ee e e a
plus d´routants, tels que les pointeurs. Les concepteurs ont privil´gi´ l’approche orienté objet de
e e e e
sorte qu’en Java, tout est objet ` l’exception des primitives (nombres entiers, nombres ` virgule
a a
flottante, etc.).
Java permet de d´velopper des applications autonomes mais aussi, et surtout, des applications
e
client-serveur. Cˆt´ client, les applets sont ` l’origine de la notori´t´ du langage. C’est surtout cˆt´
o e a ee o e
serveur que Java s’est impos´ dans le milieu de l’entreprise grˆce aux servlets, le pendant serveur
e a
des applets, et plus rćemment les JSP (Java Server Pages) qui peuvent se substituer ` PHP et
e a
ASP.
Les applications Java peuvent ˆtre exćutés sur tous les syst`mes d’exploitation pour lesquels a
e e e e
´t´ d´veloppé une plateforme Java, dont le nom technique est JRE (Java Runtime Environment -
ee e e
Environnement d’exćution Java). Cette derni`re est constitué d’une JVM (Java Virtual Machine
e e e
- Machine Virtuelle Java), le programme qui interpr`te le code Java et le convertit en code natif.
e
Mais le JRE est surtout constitu´ d’une biblioth`que standard ` partir de laquelle doivent ˆtre
e e a e
d´velopp´s tous les programmes en Java. C’est la garantie de portabilit´ qui a fait la rússite de
e e e e
Java dans les architectures client-serveur en facilitant la migration entre serveurs, tr`s difficile
e
pour les gros syst`mes.
e
Dans le cadre de ce cours notre objectif sera d’´tudier les concepts fondamentaux de la pro-
e
grammation objet ` l’aide du langage java. Le but est d’acqu´rir les bases permettant ensuite de
a e
d´velopper des applications plus consistantes.
e

2.2 Historique du langage
– Naissance ≡ 1991 : conception d’un langage applicable ` de petits appareils ´lectriques (on
a e
parle de code embarqu´) par la soci´t´ Sun Microsystem. La syntaxe est proche du C++,
e ee
utilisant le concept de machine virtuelle. Le code source est traduit dans un langage universel
disposant de fonctionnalit´s communes ` toutes les machines. Ce code interm´diaire est dit
e a e

9

10 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA

form´ de byte code et est compact et portable sur n’importe quelle machine : il suffit qu’elle
e
dispose d’un programme permettant d’interpr´ter le langage, on parle de machine virtuelle.
e
Ce projet s’appelait Oak.
– Et´ 1992 : premi`re pr´sentation interne des possibilit´s de Oak. Un appareil appel´ ”Star
e e e e e
Seven” permet de visualiser une animation montrant Duke, l’actuelle mascotte de Java.
– 1994 : d´veloppement de HotJava, un navigateur internet enti`rement ćrit en Java capable
e e e
d’exćuter des applets ćrites en byte code.
e e
– 1995 : lancement officiel de Java 1.0
– 1996 : lancement du JDK 1.0 et des versions 1.01 et 1.02 du langage JAVA (250 classes dans
la biblioth`que).
e
– 1998 : version 1.1 du JDK (500 classes).
– 1999 : version 1.2 JDK que l’on appelle Java2 (1500 classes)
– 2000 : version de J2SE (Java 2 Standard Edition) 1.3 (1800 classes)
– 2002 : version de J2SE (Java 2 Standard Edition) 1.4 (2700 classes), applications web et
entreprises.
– 2003 : version de J2EE (Java 2 Entreprise Edition) 1.4.
– 2004 : version du J2SE 1.5 ´galement appel´ J2SE 5.0 ou Java 5 (3500) classes
e e
– 2006 : version du J2SE 1.6 ´galement appel´ J2SE 6.0 ou Java 6 (3500) classes
e e

2.2.1 Quelques mots cl´s
e
– JRE : Java Runtime Environnement logiciel permettant d’exćuter des applications java.
e
– JDK : Java Development Kit logiciel permettant de concevoir et d’exćuter des applications
e
java.
– J2SDK : Java 2 Software Development Kit mˆme chose que prć´demment.
e e e
– API : Application Programming Interface (interface de programmation) qui d´finit la mani`re
e e
dont un composant informatique peut communiquer avec un autre. Dans le cas de Java,
ce terme d´signe une biblioth`que de classes et de fonctionnalit´s mises ` disposition du
e e e a
programmeur.
– J2EE : Java 2 Platform, Enterprise Edition Java 2 Platform, Enterprise Edition est une
spćification pour le langage de programmation Java de Sun plus particuli`rement des-
e e
tiné aux applications d’entreprise. Dans ce but, toute impl´mentation de cette spćification
e e e
contient un ensemble d’extension au cadre d’applications Java standard (J2SE, Java 2
standard edition) afin de faciliter la crátion d’applications r´parties. Voici quelques API
e e
pr´sentes dans cette extension : Servlets, JSP, JDBC, JAXB, RMI, . . .
e
– javac programme contenu dans le JDK pour compiler des programmes java.
– java nom du langage programme contenu dans le JDK ou JRE pour lancer des programmes
java.
– javadoc programme contenu dans le JDK pour crér automatiquement une documentation
e
HTML ` partir de sources java.
a
– jar programme contenu dans le JDK pour compresser un (ou des programmes java) dans un
seul fichier.

2.3 Java et la programmation orienté objet
e

La programmation orienté objets se caract´rise par 3 points importants :
e e
– une programmation structuré, e
– fiabilit´ des logiciels accrue,
e
– facilite la rútilisation du code existant.
e

2.4. STRUCTURE D’UN PROGRAMME JAVA 11

2.3.1 Le concept d’objets
En programmation imp´rative (par exemple le langage C), un programme est form´ de diff´rentes
e e e
proc´dures et structures de donnés gń´ralement ind´pendantes des proc´dures.
e e e e e e
En programmation orienté objets, on met en œuvre diff´rents objets. Chaque objet associe
e e
des donnés et des m´thodes agissant exclusivement sur les donnés de l’objet.
e e e
– On parle de m´thodes plutˆt que de proc´dures.
e o e
– On utilise indiff´remment le mot champ, donné ou encore attribut pour les variables as-
e e
sociés ` l’objet.
e a

L’encapsulation de donnés : il n’est pas possible d’agir directement sur les donnés d’un objet,
e e
il est nćessaire de passer par des m´thodes associés ` l’objet. Ces m´thodes jouent le rˆle d’in-
e e e a e o
terface obligatoire. L’appel d’une m´thode peut ˆtre vu comme l’envoi d’un message ` un objet.
e e a
Vu de l’ext´rieur, un objet se caract´rise uniquement par ses spćification (donnés attributs) et
e e e e
ses m´thodes.
e

La notion de classe :
– elle gń´ralise la notion de type de donné,
e e e
– elle permet de dćrire un ensemble d’objets ayant une structure de donnés commune et
e e
disposant de mˆmes m´thodes.
e e
– Les objets apparaissent comme des variables d’un type de classe donné, on parle d’instances
e
de classe.

La notion d’h´ritage. Elle permet de d´finir une nouvelle classe ` partir d’une autre. On rútilise
e e a e
cette derni`re en bloc et on lui ajoute de nouvelles fonctionnalit´s. La conception d’une nouvelle
e e
classe, qui h´rite (rćup`re) toutes les propri´t´s et aptitudes de l’ancienne. Il est ainsi possible
e e e ee
de s’appuyer sur des rálisations ant´rieures parfaitement au point et les spćifier ` volont´. Ceci
e e e a e
facilite donc la rútilisation de code ou de logiciel d´j` existant.
e ea

La programmation objet facilite ńorm´ment la rálisation d’interfaces graphiques. Chaque
e e e
´l´ment de l’interface est vu comme un objet, par exemple un objet fenˆtre, plusieurs objets bou-
ee e
tons, un objet ascenseur, etc.

2.3.2 Ind´pendance vis ` vis de la plateforme
e a
La portabilit´ du code. Un programme est portable si un mˆme code source peut ˆtre exploit´
e e e e
dans des environnements diff´rents moyennant une nouvelle compilation. En Java, il existe la
e
notion de machine virtuelle java - la JVM (pour Java Virtual Machine) - qui peut exćuter le
e
mˆme code sur n’importe quelle plateforme en utilisant un code source sous forme de bytecode : un
e
langage machine spćifique ` la plateforme Java. La crátion d’un programme Java s’effectue en
e a e
2 temps : une phase de compilation qui transforme le code source en bytecode. Le code est ensuite
interpr´t´ sur une machine virtuelle Java
ee

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 d´finition de classe. La d´finition d’une
e e
classe est d´finie par 2 accolades.
e

public class Chien{

//code de la classe JAVA


}

Une classe contient une ou plusieurs m´thodes. Par exemple dans la classe Chien, la m´thode
e e
aboyer() va contenir des instructions spćifiant la fa¸on dont un chien aboie. Les m´thodes sont
e c e
obligatoirement dćlarés dans une classe.
e e

public class Chien{

void aboyer()
{
// code de la methode aboyer o` l’on indique comment
u
// la m´thode doit ^tre exćuté
e e e e
}

}

2.4.2 Execution d’un programme Java

Source Compilation Execution
On compile le(s) fichier(s)
source(s) avec le programme L’exćution est lancé en uti-
e e
javac, par exemple javac lisant le programme java
On cré un document source
e
Toto.java. Si la compilation avec le nom du fichier princi-
avec une extension .java, par
a rússi, un fichier .class
e pal du programme sans l’ex-
exemple Toto.java
Toto.class est cr´´, ce fi-
ee tension .class. Par exemple
chier est constitu´ de byte
e java Toto.
code

2.4.3 La machine virtuelle
Un programme s’exćute en lan¸ant la JVM sur le fichier principal (Toto.class). Ce fichier
e c
contient du byte code et la JVM traduit ce byte code en code machine compr´hensible par la
e
plateforme sous-jacente et exćute le programme.
e
Lorsque la JVM d´marre elle cherche la classe spćifié ` l’exćution, puis elle recherche une
e e e a e
m´thode spćiale – la m´thode main – qui ressemble exactement ` ceci :
e e e a

public static void main(String [] args)
{
//le code de la methode main
}

La JVM exćute ensuite tout ce qui se trouve entre les accolades{ } de la m´thode main.
e e

2.4.4 La m´thode main
e
Toute application java a au moins une m´thode main. Attention, pas une par classe, mais au
e
moins une par application. La m´thode main correspond ` l’endroit o` le programme commence
e a u
a
` s’exćuter.
e
Voici un exemple de programme complet :

public class PremiereAppli{

2.4. STRUCTURE D’UN PROGRAMME JAVA 13

{
System.out.println("Bonjour ` tous");
a
System.out.println("Je m’appelle toto");
}
}

1. Enregistrement dans le fichier PremiereAppli.java
2. Compilation javac PremiereAppli.java
3. Lancement du programme java PremiereAppli
4. Le r´sultat du programme consiste ` afficher les 2 lignes suivantes :
e a
Bonjour a tous
`
Je m’appelle toto

2.4.5 Utilisation d’arguments dans la fonction main
Les arguments de la m´thode main sont plac´s dans le tableau args, qui est un tableau constitu´
e e e
de chaˆınes.
Lors du lancement d’un programme, les arguments se placent a la suite de l’identificateur de
`
classe du programme lanc´ et sont s´par´s par un espace. Exemple :
e e e
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’exćution, ce programme affiche le r´sultat suivant :
e e
args[0] : Le
args[1] : langage
args[2] : Java
N.B. Les arguments sont pass´s sous la forme de chaˆnes de caract`res, si nous voulons des
e ı e
nombres 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.55957;

float somme = 0, resultat;

somme=Float.parseFloat(args[0]);
resultat = somme / taux;

System.out.println("Le resultat de la convertion de "+somme+"
francs est "+resultat+" euros.");
}
}

2.5 Installation et utilisation de Java
Pour installer un outil de d´veloppement java, il suffit de rćup´rer un outil de d´veloppement
e e e e
(JDK ou SDK) sur http://java.sun.com/javase/downloads/index.jsp, puis de lancer le pro-
gramme d’installation. Sous linux vous pouvez l’installer dans /usr/local pour le rendre accessible
a
` tout le monde, ou sous votre compte.
Ensuite nous allons principalement utiliser les programmes situ´s dans le r´pertoire bin -
e e
/usr/local/jdk1.6.0 06/bin par exemple si vous avez rćup´r´ la version 06 du jdk 1.5 - javac,
e e e
java, javadoc, jar, . . .). Pour faciliter leur utilisation vous pouvez mettre le r´pertoire bin dans
e
votre variable d’environnement PARH (cf le cours syst`me).
e
Pour ćrire nos programmes nous aurons seulement besoin d’un ´diteur (par exemple emacs
e e
sous linux, ou tout un autre ´diteur si vous le souhaitez) et d’un terminal (xterm).
e
Vous pourrez ´ventuellement avoir de besoin de configurer une variable d’environnement CLASSPATH
e
qui indique les r´pertoires o` sont situ´s les programmes java. Ce n’est pas obligatoire, par d´faut
e u e e
les programmes sont cherch´s dans le r´pertoire courant et il est possible d’indiquer des r´pertoires
e e e
en spćifiant des options aux diff´rents programmes disponibles dans le jdk (voire la documentation
e e
officielle indiqué dans les liens ci-dessous).
e
Quand vous serez plus exp´riment´ (par exemple ` partir du 4`me TP), vous pourrez essay´
e e a e e
d’autres ´diteurs facilitant le d´veloppement de programmes java tels qu’eclipse ou NetBeans. A
e e
vous de les essayer et ´ventuellement d’en adopter un. Nánmoins, il est d’abord conseill´ d’utiliser
e e e
un ´diteur non spćifique pour commencer, puis de passer ` un ´diteur spćialis´ une fois que l’on
e e a e e e
maˆ ıtrise les bases du langage.

Pour ceux qui souhaitent essayer leurs programmes sous windows, la proc´dure d’installation est
e
la mˆme. Il peut cependant ˆtre nćessaire de crér une variable d’environnement suppl´mentaire.
e e e e e
Voici la proc´dure ` suivre.
e a
– V´rifier que la variable d’environnement JAVA HOME est spćifié.
e e e

ˆ
2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 15

– Si ce n’est pas le cas allez dans Menu D´marrer → Settings → Control Panel → System →
e
Advanced, menu variables d’environnement. Entrez le nom de JAVA HOME puis sa valeur (par
exemple C :2sdk1.6.0 06/).
– Pour v´rifier tapez echo %JAVA HOME dans une console MS-DOS.
e
Vous pouvez utiliser la mˆme m´thode pour modifier le contenu de la variable PATH ou confi-
e e
gurer CLASSPATH. En guise de terminal vous utiliserez alors une console MS-DOS.

2.6 Types, expressions et structures de contrˆle fondamen-
o
tales
Cette partie a pour objectif de pr´senter rapidement l’utilisation des types, des expressions
e
et des instructions de contrˆle en JAVA. Les ´l´ments abord´s ne sont pas forc´ment toujours
o ee e e
caract´ristiques du langage JAVA mais sont nćessaires pour l’utilisation de n’importe quel lan-
e e
gage de programmation. Lorsque certaines situations sont spćifiques au langage JAVA, nous le
e
prćisons.
e

2.6.1 les types primitifs
Ils servent ` d´finir les champs (attributs) de toutes les classes que vous pourrez d´finir, ainsi
a e e
que les variables que vous pourrez utiliser dans les diff´rentes m´thodes. Attention, les types
e e
primitifs ne sont pas des classes.

La notion de type
La m´moire centrale est un ensemble de ” positions binaires ” appelés. Ces bits sont regroup´s
e e e
en octets, un octet correspondant ` 8 bits. Les ordinateurs (actuels) ne savent repr´senter et traiter
a e
que des informations repr´sentés sous forme binaire. Il est donc nćessaire de savoir comment une
e e e
information a ´t´ codé pour pouvoir attribuer une signification ` une suite de bits d’un emplace-
ee e a
ment de la m´moire.
e

Il existe 4 cat´gories de type primitif en JAVA :
e
– nombres entiers
– nombres flottants
– caract`res
e
– booléns
e

le type entier (int)
Il sert ` repr´senter les nombres entiers relatifs. Il existe quatre sortes d’entier permettant de
a e
repr´senter des valeurs diff´rentes. Le tableau suivant dćrit chacun de ces types avec le nom du
e e e
type, la taille occupé en m´moire en octets, la valeur minimale et la valeur maximale possible
e e
avec la constante correspondante dans le langage.

Nom Taille Valeur minimale Valeur maximale
byte 1 -128 127
Byte.MIN VALUE Byte.MAX VALUE
short 2 -32768 32767
Short.MIN VALUE Short.MAX VALUE
int 4 -2,147,483,648 2,147,483,647
Integer.MIN VALUE Integer.MAX VALUE
long 8 -9,223,372,036,854,775,808 9,223,372,036,854,775,807
Long.MIN VALUE Long.MAX VALUE


Les constantes peuvent s’ćrire sous forme dćimale (548, -78, +5), ou sous forme hexadćimale
e e e
en prćisant la valeur de 0x ou 0x (0x1A 0X12), ou octale en faisant prć´der la valeur de 0 (032,
e e e
05).
Une constante enti`re est forc´ment de l’un des types int ou long. On peut forcer une constante
e e
` ˆtre du type long en faisant suivre sa valeur de la lettre l ou L, exemple 25L. Le compilateur
ae
rejettera toute constante ayant une valeur sup´rieure la capacit´ du type long.
e e

Les flottants/réls (float ou double)
e
Il en existe deux sortes. Le tableau suivant dćrit chacun d’eux avec leur nom, la taille occupé
e e
en m´moire en octets, la prćision correspondant au nombre de chiffres significatifs pris en compte
e e
dans la partie dćimale, la valeur minimale et la valeur maximale possible avec la constante
e
correspondante dans le langage.

Nom Taille Prćision
e Valeur absolue minimale Valeur absolue maximale
float 4 7 −1.40239046 × 10−45 3, 40282347 × 1038
Float.MIN VALUE Float.MAX VALUE
double 8 15 4.9506564584124654 × 10− 324 1, 797693134862316 × 10308
Double.MIN VALUE Double.MAX VALUE

Pour les constantes, il existe deux notations :
– la notation dćimale : 12.43 -0.38 -.38 4. .27
e
– la notation exponentielle : 4.25E4 ou 4.25e+4 pour 4.25 × 104
54.2e-32 pour 54.2 × 10−32
48e13 pour 48 × 1013
Par d´faut toutes les constantes cr´és sont de type double, pour forcer ` avoir un type float
e ee a
on fait suivre la valeur de la lettre f, exemple : 12.5f

Le type caract`re (char)
e
Les caract`res, d´sign´s par le type char, sont cod´s sur 2 octets, notation d’une constante
e e e e
caract`re : ’a’, ’B’, ’´’, ’+’. Exemple
e e
char lettre=’a’ ;
Certains caract`res avec notation spćiale :
e e
– ’b’ pour le retour arri`re (backspace)
e
– ’t’ pour une tabulation
– ’n’ pour un saut de ligne
– ’f’ pour un saut de page
– ’r’ pour un retour chariot
– ’"’ pour un guillemet
– ’’’ pour une apostrophe
– ’’ pour .

Le type boolén (boolean)
e
Il sert ` repr´senter une valeur logique de type vrai ou faux, il existe deux valeurs possibles pour
a e
un boolén en java : true et false (pour vrai et faux). Exemple boolean est ordonne=false ;.
e
Attention, en JAVA, les valeurs logiques ne sont pas repr´sentés par des valeurs mais par un
e e
type spćifique : le type boolean, toute utilisation de valeur num´rique dans des tests provoquera
e e
une erreur !

Initialisations et constantes
Variables Exemples : int n=15 ; ´galement ´quivalent ` int n ; n=15 ;.
e e a

ˆ

En JAVA, les dćlarations peuvent apparaˆ ` n’importe quel endroit du programme. D’un
e ıtre a
point de vue m´thodologique, il est souvent conseill´ d’effectuer la dćlaration de toutes les
e e e
variables (importantes) ensembles au d´but puis de les initialiser avant de les utiliser.
e
N.B. Les variables n’ayant pas re¸u de valeur ne peuvent pas ˆtre utilisés sous peine d’aboutir
c e e
a une erreur de compilation. Il est donc important de penser a initialiser les variables d`s leur
` ` e
crátion.
e

Constantes : le mot cl´ final Pour indiquer qu’une variable ne peut pas ˆtre modifié pendant
e e e
l’exćution d’un programme, on peut utiliser le mot cl´ final :
e e
final int nombre de mois=12 ;
Toute modification de la variable nombre de mois, de valeur initiale 12, sera rejeté par le compi-
e
lateur.

2.6.2 Op´rateurs et expressions
e
Op´rateurs arithm´tiques
e e
Il existe cinq op´rateurs principaux :
e
– + : addition a+b
– - : soustraction a-b
– / : division a/b
– * : multiplication a*b
– % : modulo, a % b calcule le reste de la division de a par b.
Le probl`me de la conversion de type :
e
float x ; float res ;
int n ; int p ;
res=n*x+p ;
La variable n ´tant de type int, x de type float, le compilateur va convertir n en float puis faire le
e
calcul. Le r´sultat final sera de type float, comme le montre la Figure 2.1.
e

n * x + p

int float long

float
*

float + float

float

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

La hi´rarchie de conversion permettant de ne pas dńaturer la valeur initiale : int → long
e e
→ float → double.
Note : par d´faut, pour les types byte, char, short, si un de ces types apparaˆ dans une expression,
e ıt
la valeur est d’abord convertie en int. Exemple :
short p1=1, p2=1 ,p3=1 ;
float x=2 ;
L’´valuation de p1*p2+p3*x est faite comme le montre la Figure 2.2.
e

Op´rateurs de comparaison
e
Ils servent ` faire des comparaisons relatives et sont principalement utilis´s dans les tests
a e
conditionnels.


p1 * p2 + p3 * x

int int int

* float * float

int float
float +

float

Fig. 2.2 – Evaluation de p1*p2+p3*x

– < : inf´rieur strictement `
e a
– <= : inf´rieur ou ´gal `
e e a
– > : sup´rieur `
e a
– >= : sup´rieur ou ´gal `
e e a
– == : ´gal `
e a
– ! = : diff´rent de.
e
Ces op´rateurs peuvent s’utiliser avec des expressions : 2 ∗ a > b + 5, x + y < (a + 2) ∗ 5, . . .
e
Note : ordre sur les caract`res 0 < 1 < . . . < 9 < A < B < . . . < Z < a < . . . < z .
e

Op´rateurs logiques
e
Ces op´rateurs permettent de manipuler des valeurs logiques.
e
– ! : n´gation
e
– & : ”ET”
– ∧ : ”OU” exclusif
– | : ”OU” inclusif
– && : ”ET” avec court-circuit
– || : ”OU” inclusif avec court-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) dans
le cas contraire.
– (a < b) || (c < d), (a < b) | (c < d) : prend la valeur true si l’une au moins des deux
conditions a < b ou c < d est vraie, la valeur false dans le cas contraire.
– (a < b) ∧ (c < d) prend la valeur true si une et une seule des deux conditions a < b et
c < d est vraie, la valeur false dans le cas contraire.
– !(a < b) prend la valeur true si la condition a < b est fausse, la valeur false dans le cas
contraire. Cette expression poss`de en fait la mˆme valeur que a >= b.
e e
– Les deux op´rateurs && et || poss`dent une propri´t´ int´ressante : leur second op´rande
e e ee e e
(celui qui figure ` droite de l’op´rateur) n’est ´valu´ que si la connaissance de sa valeur est
a e e e
indispensable pour dćider si l’expression est vraie ou fausse. Par exemple, si on a l’expression
e
(a < b)&&(c < d), on commence par ´valuer (a < b), si le r´sultat est faux on n’´value pas
e e e
c < d puisque le r´sultat est d´j` connu. Les op´rateurs ∧ et | ´valuent toujours les deux
e ea e e
op´randes, il est donc plutˆt conseill´ d’utiliser les op´rateurs && et ||.
e o e e

Op´rateurs d’affectation
e
– = : exemples c=b+3 ; c=i ;. L’op´rateur poss`de une associativit´ de gauche ` droite, ainsi
e e e a
dans l’expression i = j = 5 ; on ´value j=5 d’abord, puis i=j, i et j ont ` la fin la mˆme
e a e
valeur 5.
Attention aux probl`mes de conversion, supposons que nous ayons une variable de type int n
e
et une variable de type float x, l’expression n=x+5 ; est rejeté par le compilateur. Il faut en
e

ˆ

fait ćrire n=(int) x + 5 ;. Il est nćessaire de faire une conversion explicite. Les conversions
e e
pour lesquelles il n’y a pas besoin de faire une conversion explicite sont les suivantes :
– byte → short → int → long → float → double

– char → int → long → float → double
– L’incr´mentation et la dćr´mentation. Ces op´rations consistent respectivement ` augmen-
e e e e a
ter une variable (en gń´ral enti`re) 1 et ` diminuer une variable de 1 (i = i-1 ; n = n+1 ;).
e e e a
Ces op´rations sont d´finies par les op´rateurs ++ et -- : i-- ; n++ ; ou --i ; ++n ;. Il existe
e e e
cependant un diff´rence suivant o` est plac´ l’op´rateur lors de l’´valuation d’une expression,
e u e e e
s’il est plac´ avant(on parle d’op´rateur pr´fix´) la variable l’op´ration est effectué avant
e e e e e e
l’´valuation de l’expression, s’il est plac´ apr`s (on parle d’op´rateur postfix´) l’op´ration est
e e e e e e
effectué apr`s.
e e
– n= ++i -5 ; : on affecte d’abord la valeur 6 ` i puis la valeur 1 ` n.
a a
– n= i++ - 5 ; : on affecte d’abord la valeur 0 ` n puis la valeur 6 ` i.
a a
– Affectation ´largie, les instructions suivantes sont ´quivalentes :
e e
– i = i + k ; et i+=k ;
Il existe la mˆme chose avec les op´rateurs *, / et -.
e e

Conversion de types

Lorsque l’on d´sire convertir un type vers autre qui a une taille de repr´sentation inf´rieure,
e e e
les r`gles suivantes s’appliquent :
e
– entier vers entier (long vers int, short vert byte, . . .) les octets les moins significatifs sont
conserv´s.
e
– double vers float : arrondi au plus proche.
– flottant vers entier : il y a d’abord un arrondi au plus proche dans le type long ou int, puis
on effectue la conversion en conservant les octets les moins significatifs.

Op´rateur conditionnel
e

condition ? etape1 : etape2 ; : si condition est vraie alors etape1 sinon etape 2. Exemple :
max = a<b ? a :b ;
Si a < b, alors la variable max re¸oit la valeur de la variable a, sinon elle re¸oit la valeur de la
c c
variable b.

Priorit´ des op´rateurs
e e

Op´rateurs
e associativit´
e
() [] . ++(postfix´) –(postfix´)
e e g`d
a
+(unaire) -(unaire) ++(pr´fix´) –(pr´fix´) (unaire) ! cast new
e e e e d`g
a
/% g`d
a
+- g`d
a
<< >> >>> g`d
a
< <= > >= instanceof g`d
a
== != g`d
a
& g`d
a
∧ g`d
a
— g`d
a
&& g`d
a
— g`d
a
?: g`d
a
= += -= *= /= %= <<= >>= >>>= & = | = ∧ = d`g
a


2.6.3 Les structures de contrˆle
o
Dans cette partie, les crochets [] signifient que ce qu’ils renferment est facultatif. Il servent soit
a
` exprimer le fait que pour lier plusieurs instructions ` une structure de contrˆle il est nćessaire
a o e
de mettre ces instructions dans un bloc entre accolades ({}) (si on n’a besoin que d’une seule
instruction on n’a pas besoin de bloc) ; soit ` indiquer qu’une instruction facultative.
a
Le terme condition correspond ` une expression qui peut ˆtre ´valué sous forme logique (vrai
a e e e
ou 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 plusieurs
valeurs d’une expression. L’expression peut ˆtre de type byte, short, char ou int.
e
Syntaxe :
switch(expression)
{
case constante_1: [suite d’instructions1]
case constante_2: [suite d’instructions2]

case constante_n: [suite d’instructionsn]
[default: suite d’instructions]
}
Exemple :
public class ExSwitch{
{
int n;

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

switch(n)
{
case 0: System.out.println("zero");
break;

case 1: System.out.println("un");
break;

case 3: System.out.println("trois");

default: System.out.println("Rien");
System.out.println("Fin");
}
System.out.println("Fin du programme");
}
}

while
Il s’agit d’une boucle tant que qui ex´cute un ensemble d’instructions tant qu’une condition
e
est 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("Apr`s la boucle");
e
}
}

do-while
Il s’agit d’une boucle faire-tant que similaire ` la boucle while sauf que la condition est ´valué
a e e
apr`s chaque parcours de boucle. La boucle do-while est exćuté au moins une fois, alors que la
e e e
boucle while peut ne jamais ˆtre exćuté.
e e e
Syntaxe :
do [{]
instruction_1
[instruction_2
...
instruction_n }] while(condition);
N.B. Il y a un point virgule a la fin de l’instruction !
`
Exemple :
public class Boucle2{
public static void main (String [] args){
int x=1;
System.out.println("Avant la boucle");
do{
System.out.println("Dans la boule, la valeur de x est "+x);
x=x+1;
}while(x<4);

System.out.println("Apr`s la boucle");
e
}
}

for
L’instruction for est une boucle (pour) dont la syntaxe est divisé en trois expressions.
e
Syntaxe :
for([initialisation] ; [condition] ; [incr´mentation])
e
[{]
instruction_1
[instruction_2
...
instruction_n
}]

ˆ

– initialisation est une dćlaration ou une suite d’expressions quelconques s´parés par des
e e e
virgules, cette partie est ´valué une seule fois avant d’entrer dans la boucle.
e e
– condition est une expression boolénne (logique) quelconque, cette partie conditionne la
e
poursuite de la boucle et est ´valué avant chaque parcours.
e e
– incr´mentation est une suite d’expressions quelconques s´parés par des virgules, cette
e e e
partie est ´valué ` la fin de chaque parcours.
e e a
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 prć´dent est ´quivalent `
e e e 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 ´galement ˆtre ćrit de la mani`re suivante :
e e e e

public class ExFor4


{
public static void main(String args [])
{
for(int i=1, j=3;i<=5; i++, j+=i)
{
System.out.println("i= " +i+ "j= " +j);
}
}
}

Les instructions break et continue
Ces instructions s’emploient principalement au sein de boucles.
L’instruction break (casser) sert ` interrompre le d´roulement d’une boucle en passant `
a e a
l’instruction situé apr`s la boucle. L’exćution de cette instruction est conditionné par un choix.
e e e e
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 r´sultat du programme prć´dent est le suivant :
e e e
debut tour 1
bonjour
fin tour 1
debut tour
bonjour
fin tour 2
debut tour 3
bonjour
apres la boucle
En cas de boucles imbriqués, l’instruction break fait sortir de la boucle la plus interne.
e
L’instruction continue permet de passer directement au tour de boucle suivant. Exemple.
public class ExContinue
{
public static void main (String args[])
{
int i;
for(i=1; i<=5; i++)

`
2.7. UNE PREMIERE INTRODUCTION AU TYPE STRING 25

{
System.out.println("debut tour"+i);
if (i<4) continue;
System.out.println("fin tour"+i);
}
System.out.println("apres la boucle");
}
}

Exemple d’exćution :
e

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 ´l´ments spćifiques au langage JAVA
ee e
Parmi les points abord´s ci-dessus, quatre sont plutˆt spćifiques au langage JAVA.
e o e
– Le mot cl´ final qui permet de dćlarer des constantes ` l’aide de variables.
e e a
– Le type byte qui permet de repr´senter des entiers entre -128 et 127.
e
– Le type boolean pour repr´senter les valeurs true (vrai) et false (faux). Tous les tests
e
conditionnels doivent ˆtre compatibles avec le type boolean. Mettre une valeur enti`re dans
e e
un test provoque une erreur de compilation en JAVA (par exemple if(1)... est interdit en
JAVA).
– Les conversions de type doivent ˆtre explicites en JAVA chaque que l’on veut convertir un
e
type gń´ral vers une repr´sentation plus petite. Exemple :
e e e
int n=2;
float x=1.0;
...
n=(int) x;
Un autre ´l´ment est trait´ de mani`re spćifique en JAVA : le type chaˆ de caract`res
ee e e e ıne e
(String). Une introduction est proposé dans la section suivante.
e

2.7 Une premi`re introduction au type String
e
En JAVA, les chaˆınes de caract`res sont d´finies par un type spćifique : le type String. Nous
e e e
pr´sentons ici une courte introduction, nous reviendrons sur ce type plus tard.
e

Dćlaration
e

String chaineSalutation = "bonjour";

Une chaˆ de caract`re constante se dćlare toujours entre guillemets "... ".
ıne e e

Connaˆ
ıtre la longueur d’une chaˆ
ıne

int l = chaineSalutation.length();


Acc`s ` un caract`re
e a e

char cara1 = chaineSalutation.charAt(0);
char cara1 = chaineSalutation.charAt(2);

La variable cara1 contient le caract`re b, la variable cara2 contient le caract`re n.
e e

Concatńation : l’op´rateur +
e e

String ch1 = "Bonjour";
String ch2 = " ` tous";
a
String ch = ch1 + ch2;

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

Impression d’une chaˆ de caract`res
ıne e

System.out.println(chaineSalutation);
System.out.println(ch1+ch2);
System.out.println(ch);

Comparaison de chaˆ ınes La m´thode equals qui teste l’´galit´ de deux chaˆ
e e e ınes de caract`res :
e
ch1.equals(ch2) ou ch1.equals("Bonjour").
La m´thode compareTo pour comparer deux chaˆ
e ınes de caract`res dans l’ordre lexicographique
e
(alphab´tique) : ch1.compareTo(ch2)
e
– renvoie un entier strictement n´gatif si ch1 est situé avant ch2 dans l’ordre lexicographique
e e
– renvoie un entier strictement positif si ch1 est situé apr`s ch2 dans l’ordre lexicographique
e e
– 0 si ch1 contient la mˆme chaˆ que ch2.
e ıne

2.8 R`gles d’ćriture d’un programme JAVA
e e
Ce document a pour objectif de synth´tiser les r`gles d’ćriture gń´ralement utilisés pour le
e e e e e e
d´veloppement d’applications en JAVA.
e

2.8.1 Les identificateurs
Les identificateurs sont des suites de caract`res servant ` d´signer les entit´s manipulés par
e a e e e
un programme (variables, m´thodes, classes, objets, . . .). En JAVA, un identificateur est form´ de
e e
lettres et de chiffres ou du caract`re . Le premier caract`re est forc´ment une lettre A-Z, a-z ou
e e e
´ventuellement . Il n’existe aucune limitation sur le nombre de caract`res. Exemples :
e e
ligne, valeur 5, total, 56, ma variable 1, i, MaClasse, ...
Attention, on distingue les minuscules des majuscules (ligne = Ligne).

Certaines conventions sont traditionnellement utilisés :
e
– Les noms de variables et de m´thodes sont ćrits en minuscule sauf s’ils sont form´s de la
e e e
juxtaposition de plusieurs mots, auquel cas chaque sous-mot, sauf le premier, comporte une
majuscule ` la premi`re lettre. Exemples : valeur, nombreValeur, tauxEmprunt,
a e
calculNombreReponsesExactes, getX2, ...
– Les noms de classe suivent la mˆme r`gle, mais leur premi`re lettre est ćrite en majuscule.
e e e e
Exemples : PremierProgramme, Clavier,
CalculMoyenne, ...
Remarque : cette convention permet de distinguer le fait que System est une classe et que
out n’en est pas une (System.out.println).

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

– Des identificateurs successifs doivent ˆtre s´par´s par un espace ou un saut de ligne quand
e e e
il n’y a pas de s´parateur ou de syntaxe particuli`re. Exemple : x = a + 5 ; y += 4 ; Une
e e
virgule est utilisé pour faire plusieurs dćlarations d’un mˆme type. Exemple :
e e e
int x, y ;
float n, compteur, total, valeur ;

2.8.2 Commentaires
Il existe trois types de commentaires en JAVA.
– les commentaires commen¸ant par /∗ et se terminant par ∗/, exemple : /* Ceci est un
c
commentaire usuel*/
– les commentaires de fin de ligne //, exemple :
int valeur ; // valeur avec commentaire de fin de ligne
– les commentaires de documentation commen¸ant par / ∗ ∗ et finissant par ∗/. C’est un cas
c
particulier des commentaires usuels puisqu’ils commencent de mani`re l´g`rement diff´rente
e e e e
par rapport ` ces derniers. Leur int´rˆt est de pouvoir ˆtre extrait automatiquement pour
a e e e
faire de la documentation avec, par exemple, le programme javadoc.

2.8.3 Mots cl´s r´serv´s
e e e
Les mots suivant sont des mots cl´s r´serv´s pour le langage et ne peuvent ˆtre utilis´s
e e e e e

abstract boolean break byte case
catch char class const continue
default do double else extends
final finally float for goto
if implements import instanceof int
interface long native new package
private protected public return short
static super switch synchronized this
throw throws transient try void
volatile while

2.8.4 Remarques globales
– Les instructions se terminent par un point virgule ;.
– Les blocs de code sont d´finis entre accolades {}.
e
– On dćlare une variable avec un nom et un type : int x;.
e
– Un op´rateur d’affectation est avec un seul signe : =.
e
– Un op´rateur d’´galit´ est avec deux signes : ==.
e e e
– Lorsque l’on ćrit du code, il est imp´ratif de respecter les r`gles d’indentation : les instruc-
e e e
tions ` l’int´rieur d’un bloc doivent ˆtre dćalés ` droite, c’est ´galement lorsque l’on utilise
a e e e e a e
une structure de contrˆle. La d´finition de m´thodes et d’attributs de classes doivent ˆtre
o e e e
indent´s par rapport ` la d´finition de la classe elle-mˆme.
e a e e
– Pensez ` commenter votre code et ` bien dćrire ce que font vos fonctions et ` quoi servent
a a e a
vos classe !
– ...

2.8.5 Commentaires sur le rendu d’un programme Java
Pour rendre un projet vous devez construire une archive (zip, tar.gz) contenant les diff´rents
e
´l´ments de votre projet. Une archive correctement constitué devrait contenir :
ee e
– une bonne documentation comprenant

Polycope java enseignant

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

En vedette

En vedette (20)

Similaire à Polycope java enseignant

Similaire à Polycope java enseignant (20)

Dernier

Dernier (20)

Polycope java enseignant