Le langage Java

Langages > Langage Java > Cours 1.1.0.1 – 07/05/2010
1 / 59
LE LANGAGE JAVA
1.1.0.1 – 07/05/2010
peignotc(at)arqendra(dot)net / peignotc(at)gmail(dot)com
Toute reproduction partielle ou intégrale autorisée selon les termes de la licence Creative Commons (CC) BY-NC-SA : Contrat
Paternité-Pas d'Utilisation Commerciale-Partage des Conditions Initiales à l'Identique 2.0 France, disponible en ligne
http://creativecommons.org/licenses/by-nc-sa/2.0/fr/ ou par courrier postal à Creative Commons, 171 Second Street, Suite 300,
San Francisco, California 94105, USA. Merci de citer et prévenir l’auteur.
TODO :
-chapitre 3.1 : visibilité des attributs et méthodes
-chapitre 6.4 : exclusion mutuelle et synchronisation des threads
-chapitre 6.4 : déprécation des méthodes stop(), suspend(), resume() et procédés alternatifs
-chapitre 8 (jdbc) : à faire
-autres chapitres (rmi, jni, jsp, servlet, …) : à faire
-classes internes (+visibilité) ?
-XML ?

Langages > Langage Java > Cours 1.1.0.1 – 07/05/2010
2 / 59
TABLE DES MATIÈRES
0 PROLOGUE............................................................................................................ 5
1INTRODUCTION AU LANGAGE JAVA ............................................................ 6
2NOTIONS DE BASE.............................................................................................. 7
2.1 RAPPELS SUR LA PROGRAMMATION OBJET ................................................................................ 7
2.1.1 Généralités sur l’objet......................................................................................................................7
2.1.2 Principes...........................................................................................................................................7
2.1.2.1 L’encapsulation ......................................................................................................................................... 7
2.1.2.2 L’héritage de classe................................................................................................................................... 8
2.1.2.3 Le polymorphisme..................................................................................................................................... 8
2.2 DÉVELOPPEMENT JAVA ............................................................................................................. 9
2.2.1 Environnement de développement ....................................................................................................9
2.2.2 Structure d’un fichier source............................................................................................................9
2.2.3 Les bibliothèques de classes Java ..................................................................................................11
2.3 LES VARIABLES .......................................................................................................................11
2.3.1 Les types de variables prédéfinis....................................................................................................11
2.3.2 Les constantes.................................................................................................................................11
2.3.3 Les chaînes de caractères...............................................................................................................11
2.3.4 Les tableaux....................................................................................................................................12
2.4 LES STRUCTURES DE CONTRÔLE .............................................................................................. 12
2.4.1 Les opérateurs d’évaluation d’expression......................................................................................12
2.4.2 Les tests ..........................................................................................................................................13
2.4.2.1 Test simple « si… sinon… » ................................................................................................................... 13
2.4.2.2 Test multiple « au cas où… faire… »...................................................................................................... 13
2.4.3 L’opérateur ternaire.......................................................................................................................13
2.4.4 Les boucles .....................................................................................................................................13
2.4.4.1 Boucle « tant que… faire… ».................................................................................................................. 13
2.4.4.2 Boucle « répéter… tant que… ».............................................................................................................. 13
2.4.4.3 Boucle « pour… faire… »....................................................................................................................... 14
2.5 GESTION DES ÉVÉNEMENTS .....................................................................................................14
2.6 LES EXCEPTIONS......................................................................................................................15
2.7 LES DIFFÉRENTS TYPES D’APPLICATIONS JAVA .......................................................................16
2.7.1 Les applications « console »...........................................................................................................16
2.7.2 Les applications graphiques...........................................................................................................17
2.7.3 Les applets......................................................................................................................................18
3L’HÉRITAGE ....................................................................................................... 20
3.1 L’HÉRITAGE SIMPLE ................................................................................................................20
3.1.1 Principes.........................................................................................................................................20
3.1.2 Hiérarchie de classes......................................................................................................................20
3.1.3 Accès aux attributs et méthodes dans une relation d’héritage .......................................................21
3.2 LES INTERFACES......................................................................................................................22
3.2.1 Introduction : méthode et classe abstraite......................................................................................22
3.2.2 Définition d’une interface...............................................................................................................24
3.2.3 Implémentation ...............................................................................................................................24
3.2.4 Exemple d’utilisation d’une interface.............................................................................................26

Langages > Langage Java > Cours 1.1.0.1 – 07/05/2010
3 / 59
4LES FLUX D’ENTRÉES/SORTIES .................................................................... 28
4.1 INTRODUCTION........................................................................................................................28
4.1.1 Notion de flux .................................................................................................................................28
4.1.2 Définitions ......................................................................................................................................28
4.1.3 Principe de mise en œuvre des flux ................................................................................................28
4.2 LES FLUX STANDARD............................................................................................................... 29
4.3 GESTION DES FLUX..................................................................................................................29
4.3.1 Les flux d’octets..............................................................................................................................29
4.3.2 Les flux de caractères.....................................................................................................................30
4.4 GESTION DES FLUX SUR FICHIER TEXTE................................................................................... 30
4.4.1 Enregistrement des données ...........................................................................................................30
4.4.2 Lecture des données........................................................................................................................31
4.4.3 Cas pratique ...................................................................................................................................32
4.5 GESTION DES FLUX D’OBJETS ..................................................................................................33
4.5.1 La sérialisation...............................................................................................................................33
4.5.2 Persistance .....................................................................................................................................34
5LES APPLETS...................................................................................................... 37
5.1 GÉNÉRALITÉS..........................................................................................................................37
5.1.1 Définition........................................................................................................................................37
5.1.2 Fonctionnement ..............................................................................................................................37
5.2 CYCLE DE VIE..........................................................................................................................37
5.3 EXÉCUTION D’UNE APPLET......................................................................................................38
5.3.1 Principes.........................................................................................................................................38
5.3.2 La balise HTML <applet> .............................................................................................................39
5.3.3 Exemple récapitulatif......................................................................................................................39
5.4 EMPAQUETAGE DES APPLETS...................................................................................................40
5.5 APPLETS ET SÉCURITÉ .............................................................................................................41
6LE MULTITHREADING..................................................................................... 42
6.1 INTRODUCTION........................................................................................................................42
6.2 DÉFINITIONS............................................................................................................................43
6.3 IMPLÉMENTATION ...................................................................................................................44
6.3.1 La classe Thread.............................................................................................................................44
6.3.2 L’interface Runnable......................................................................................................................45
6.4 GESTION DES THREADS............................................................................................................46
6.4.1 Cycle de vie.....................................................................................................................................46
6.4.2 Autres outils de gestion...................................................................................................................47
7LES SOCKETS ..................................................................................................... 48
7.1 INTRODUCTION........................................................................................................................48
7.2 IMPLÉMENTATION.................................................................................................................... 49
7.2.1 La classe Socket..............................................................................................................................49
7.2.2 Serveur socket.................................................................................................................................49
7.2.3 Client socket ...................................................................................................................................50
7.3 CAS PRATIQUE......................................................................................................................... 51

Langages > Langage Java > Cours 1.1.0.1 – 07/05/2010
4 / 59
7.4 DÉTAILS SUR LA COMMUNICATION CLIENT-SERVEUR..............................................................52
TABLE DES ANNEXES
AMOTS-CLEFS DU LANGAGE JAVA................................................................ 54
A.1 O
RDRE ALPHABÉTIQUE............................................................................................................54
A.2 CATÉGORIES............................................................................................................................54
A.2.1 Paquetages, classes, membres et interfaces ...................................................................................54
A.2.2 Types primitifs ................................................................................................................................55
A.2.3 Structures de contrôle.....................................................................................................................55
A.2.4 Modificateurs de visibilité ..............................................................................................................55
A.2.5 Autres modificateurs.......................................................................................................................55
A.2.6 Gestion des exceptions....................................................................................................................56
A.2.7 Autres..............................................................................................................................................56
BRÉFÉRENCE DU LANGAGE............................................................................. 57
B.1 BIBLIOTHÈQUES DES CLASSES JAVA ........................................................................................57
B.2 ÉDITIONS DE LA PLATE-FORME JAVA....................................................................................... 57
B.3 VERSIONS DE LA PLATE-FORME JAVA...................................................................................... 58
C BIBLIOGRAPHIE ................................................................................................ 59
TABLE DES ILLUSTRATIONS
Figure 2.1 : exemple d’un objet (classe, attributs, méthodes) _____________________________________________________________________7
Figure 2.2 : exemple de respect de l’encapsulation grâce aux accesseurs____________________________________________________________8
Figure 2.3 : exemple d’un héritage de classe__________________________________________________________________________________8
Figure 2.4 : exploitation du code source Java_________________________________________________________________________________9
Figure 2.5 : envoi de message entre deux objets lors d’un événement______________________________________________________________14
Figure 3.1 : héritage entre deux classes ____________________________________________________________________________________20
Figure 3.2 : hiérarchie des classes Java ____________________________________________________________________________________20
Figure 3.3 : exemple d’utilisation d’une méthode abstraite______________________________________________________________________23
Figure 3.4 : implémentation d’une interface _________________________________________________________________________________25
Figure 3.5 : exemple d’utilisation d’une interface _____________________________________________________________________________26
Figure 4.1 : exemples de flux de lecture et d’écriture __________________________________________________________________________28
Figure 4.2 : classes de gestion de flux d’octets _______________________________________________________________________________30
Figure 4.3 : classes de gestion de flux de caractères___________________________________________________________________________30
Figure 4.4 : flux de sortie sur fichier _______________________________________________________________________________________30
Figure 4.5 : flux d’entrée sur fichier _______________________________________________________________________________________31
Figure 4.6 : buffer de flux d’entrée/sortie sur fichier texte ______________________________________________________________________32
Figure 4.7 : exemple de sérialisation sur fichier ______________________________________________________________________________34
Figure 5.1 : cycle de vie d’une applet ______________________________________________________________________________________38
Figure 6.1 : comparaison de l’exécution de deux processus en monotâche et multitâches ______________________________________________42
Figure 6.2 : comparaison entre multitâches et multithreading ___________________________________________________________________43
Figure 6.3 : cycle de vie d’un thread _______________________________________________________________________________________47
Figure 7.1 : communication client/serveur par socket__________________________________________________________________________48

Langages > Langage Java > Cours 1.1.0.1 – 07/05/2010
5 / 59
0PROLOGUE
Le contenu du présent document se focalise principalement sur les aspects de Programmation Orientée Objet
appliqués au langage Java et tient pour acquis un certain nombre de concepts et d’éléments de base de la
programmation et communs à différents langages, tels que le langage C, C++, C#, etc. (nda : voir le cours Le langage
Cou Le langage C++ du même auteur).
La maîtrise de notions telles que les principes de « mot-clef », d’« instruction », et de « variable », les structures de
contrôle, les tableaux, les fonctions, les pointeurs et les types de variables complexes – principalement les structures –
est impérative pour appréhender les nouveaux éléments amenés.