Java Cours

Langages > Langage Java > Cours
1.1.0.1 07/05/2010
LE LANGAGE JAVA
TODO :
-
chapitre 3.1 : visibilit des attributs et mthodes

chapitre 6.4 : exclusion mutuelle et synchronisation des threads
chapitre 6.4 : dprcation des mthodes stop(), suspend(), resume() et procds alternatifs
chapitre 8 (jdbc) : faire
autres chapitres (rmi, jni, jsp, servlet, ) : faire
classes internes (+visibilit) ?
XML ?
1.1.0.1 07/05/2010
peignotc(at)arqendra(dot)net / peignotc(at)gmail(dot)com
Toute reproduction partielle ou intgrale autorise 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 prvenir lauteur.
1 / 59
1.1.0.1 07/05/2010
TABLE DES MATIRES

0
PROLOGUE............................................................................................................ 5
INTRODUCTION AU LANGAGE JAVA ............................................................ 6
NOTIONS DE BASE.............................................................................................. 7
2.1
RAPPELS SUR LA PROGRAMMATION OBJET ................................................................................ 7
2.1.1
2.1.2
2.1.2.1
2.1.2.2
2.1.2.3
2.2
2.4.2.1
2.4.2.2
2.4.3
2.4.4
2.4.4.1
2.4.4.2
2.4.4.3
Les oprateurs dvaluation dexpression......................................................................................12

Les tests ..........................................................................................................................................13
Test simple si sinon ................................................................................................................... 13
Test multiple au cas o faire ...................................................................................................... 13
Loprateur ternaire.......................................................................................................................13
Les boucles .....................................................................................................................................13
Boucle tant que faire .................................................................................................................. 13
Boucle rpter tant que .............................................................................................................. 13
Boucle pour faire ....................................................................................................................... 14
GESTION DES VNEMENTS ..................................................................................................... 14

LES EXCEPTIONS...................................................................................................................... 15
LES DIFFRENTS TYPES DAPPLICATIONS JAVA ....................................................................... 16
2.7.1
2.7.2
2.7.3
Les types de variables prdfinis....................................................................................................11

Les constantes.................................................................................................................................11
Les chanes de caractres...............................................................................................................11
Les tableaux....................................................................................................................................12
LES STRUCTURES DE CONTRLE .............................................................................................. 12
2.4.1
2.4.2
2.5
2.6
2.7
Environnement de dveloppement ....................................................................................................9

Structure dun fichier source............................................................................................................9
Les bibliothques de classes Java ..................................................................................................11
LES VARIABLES ....................................................................................................................... 11
2.3.1
2.3.2
2.3.3
2.3.4
2.4
Lencapsulation ......................................................................................................................................... 7
Lhritage de classe ................................................................................................................................... 8
Le polymorphisme..................................................................................................................................... 8
DVELOPPEMENT JAVA ............................................................................................................. 9
2.2.1
2.2.2
2.2.3
2.3
Gnralits sur lobjet ......................................................................................................................7

Principes...........................................................................................................................................7
Les applications console ...........................................................................................................16

Les applications graphiques...........................................................................................................17
Les applets ......................................................................................................................................18
LHRITAGE ....................................................................................................... 20
3.1
LHRITAGE SIMPLE ................................................................................................................ 20
3.1.1
3.1.2
3.1.3
3.2
Principes.........................................................................................................................................20
Hirarchie de classes......................................................................................................................20
Accs aux attributs et mthodes dans une relation dhritage .......................................................21
LES INTERFACES ...................................................................................................................... 22
3.2.1
3.2.2
3.2.3
3.2.4
Introduction : mthode et classe abstraite......................................................................................22

Dfinition dune interface...............................................................................................................24
Implmentation ...............................................................................................................................24
Exemple dutilisation dune interface.............................................................................................26
2 / 59
LES FLUX DENTRES/SORTIES .................................................................... 28

4.1
INTRODUCTION ........................................................................................................................ 28
4.1.1
4.1.2
4.1.3
4.2
4.3
4.4
La srialisation...............................................................................................................................33
Persistance .....................................................................................................................................34
LES APPLETS ...................................................................................................... 37

5.1
GNRALITS .......................................................................................................................... 37
5.1.1
5.1.2
5.2
5.3
5.4
5.5
Dfinition........................................................................................................................................37
Fonctionnement ..............................................................................................................................37
CYCLE DE VIE .......................................................................................................................... 37

EXCUTION DUNE APPLET ...................................................................................................... 38
5.3.1
5.3.2
5.3.3
Principes.........................................................................................................................................38
La balise HTML <applet> .............................................................................................................39
Exemple rcapitulatif......................................................................................................................39
EMPAQUETAGE DES APPLETS ................................................................................................... 40

APPLETS ET SCURIT ............................................................................................................. 41
LE MULTITHREADING ..................................................................................... 42
6.1
6.2
6.3
INTRODUCTION ........................................................................................................................ 42
DFINITIONS............................................................................................................................ 43
IMPLMENTATION ................................................................................................................... 44
6.3.1
6.3.2
6.4
La classe Thread.............................................................................................................................44
Linterface Runnable ......................................................................................................................45
GESTION DES THREADS............................................................................................................ 46
6.4.1
6.4.2
Enregistrement des donnes ...........................................................................................................30

Lecture des donnes........................................................................................................................31
Cas pratique ...................................................................................................................................32
GESTION DES FLUX DOBJETS .................................................................................................. 33
4.5.1
4.5.2
Les flux doctets..............................................................................................................................29

Les flux de caractres .....................................................................................................................30
GESTION DES FLUX SUR FICHIER TEXTE ................................................................................... 30
4.4.1
4.4.2
4.4.3
4.5
Notion de flux .................................................................................................................................28

Dfinitions ......................................................................................................................................28
Principe de mise en uvre des flux ................................................................................................28
LES FLUX STANDARD............................................................................................................... 29

GESTION DES FLUX .................................................................................................................. 29
4.3.1
4.3.2
1.1.0.1 07/05/2010
Cycle de vie.....................................................................................................................................46
Autres outils de gestion...................................................................................................................47
LES SOCKETS ..................................................................................................... 48

7.1
7.2
INTRODUCTION ........................................................................................................................ 48
IMPLMENTATION.................................................................................................................... 49
7.2.1
7.2.2
7.2.3
7.3
La classe Socket..............................................................................................................................49
Serveur socket.................................................................................................................................49
Client socket ...................................................................................................................................50
CAS PRATIQUE ......................................................................................................................... 51

3 / 59
7.4
1.1.0.1 07/05/2010
DTAILS SUR LA COMMUNICATION CLIENT-SERVEUR .............................................................. 52
TABLE DES ANNEXES

A MOTS-CLEFS DU LANGAGE JAVA ................................................................ 54
A.1 ORDRE ALPHABTIQUE............................................................................................................ 54
A.2 CATGORIES............................................................................................................................ 54
A.2.1
A.2.2
A.2.3
A.2.4
A.2.5
A.2.6
A.2.7
Paquetages, classes, membres et interfaces ...................................................................................54

Types primitifs ................................................................................................................................55
Structures de contrle.....................................................................................................................55
Modificateurs de visibilit ..............................................................................................................55
Autres modificateurs.......................................................................................................................55
Gestion des exceptions....................................................................................................................56
Autres..............................................................................................................................................56
B RFRENCE DU LANGAGE............................................................................. 57
B.1 BIBLIOTHQUES 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 dun objet (classe, attributs, mthodes) _____________________________________________________________________7
Figure 2.2 : exemple de respect de lencapsulation grce aux accesseurs____________________________________________________________8
Figure 2.3 : exemple dun hritage de classe__________________________________________________________________________________8
Figure 2.4 : exploitation du code source Java _________________________________________________________________________________9
Figure 2.5 : envoi de message entre deux objets lors dun vnement______________________________________________________________14
Figure 3.1 : hritage entre deux classes ____________________________________________________________________________________20
Figure 3.2 : hirarchie des classes Java ____________________________________________________________________________________20
Figure 3.3 : exemple dutilisation dune mthode abstraite______________________________________________________________________23
Figure 3.4 : implmentation dune interface _________________________________________________________________________________25
Figure 3.5 : exemple dutilisation dune interface _____________________________________________________________________________26
Figure 4.1 : exemples de flux de lecture et dcriture __________________________________________________________________________28
Figure 4.2 : classes de gestion de flux doctets _______________________________________________________________________________30
Figure 4.3 : classes de gestion de flux de caractres ___________________________________________________________________________30
Figure 4.4 : flux de sortie sur fichier _______________________________________________________________________________________30
Figure 4.5 : flux dentre sur fichier _______________________________________________________________________________________31
Figure 4.6 : buffer de flux dentre/sortie sur fichier texte ______________________________________________________________________32
Figure 4.7 : exemple de srialisation sur fichier ______________________________________________________________________________34
Figure 5.1 : cycle de vie dune applet ______________________________________________________________________________________38
Figure 6.1 : comparaison de lexcution de deux processus en monotche et multitches ______________________________________________42
Figure 6.2 : comparaison entre multitches et multithreading ___________________________________________________________________43
Figure 6.3 : cycle de vie dun thread _______________________________________________________________________________________47
Figure 7.1 : communication client/serveur par socket __________________________________________________________________________48
4 / 59
1.1.0.1 07/05/2010
0 PROLOGUE
Le contenu du prsent document se focalise principalement sur les aspects de Programmation Oriente Objet
appliqus au langage Java et tient pour acquis un certain nombre de concepts et dlments de base de la
programmation et communs diffrents langages, tels que le langage C, C++, C#, etc. (nda : voir le cours Le langage
C ou Le langage C++ du mme auteur).
La matrise de notions telles que les principes de mot-clef , d instruction , et de variable , les structures de
contrle, les tableaux, les fonctions, les pointeurs et les types de variables complexes principalement les structures
est imprative pour apprhender les nouveaux lments amens.
5 / 59
1.1.0.1 07/05/2010
1 INTRODUCTION AU LANGAGE JAVA

Java est un langage de programmation orient objet qui a t invent au dbut des annes 90 et dont les droits sont
dtenus par la socit Sun Microsystems 1. La cration du langage provient des rsultats obtenus avec le C++ dans
llaboration de programmes de domotique qui furent jugs insatisfaisants.
Trs vite, pendant sa conception, il sest avr que Java convenait aussi parfaitement la programmation
multimdia, et au monde de linternet qui commenait clore et se faire connatre du grand public.
Depuis sa cration, le langage a subi de nombreuses volutions et corrections. Les mises--jour rgulires 2 ont
permis au fur et mesure dinclure de nombreuses bibliothques, permettant de dvelopper plus facilement des
applications complexes.
La manire dexploiter un code source Java est singulire : le code source est dabord compil en utilisant un
compilateur Java ; le rsultat de cette compilation est ensuite interprt par la machine cible, au moyen dun
interprteur Java.
Ce concept dexploitation 3 dcoule de la volont de produire un langage le plus indpendant possible des
spcificits du hardware, tout en conservant les avantages dun langage comme le C++ ; sont ainsi conjugus les
avantages dun langage compil ainsi que ceux dun langage interprt.
Pour excuter un programme Java, il est donc ncessaire et suffisant dinstaller sur la machine cible un interprteur
Java, plus communment appel machine virtuelle Java ou JVM 4, qui a en charge linterfaage entre les rquisitions
de lapplication Java et les spcificits hardware et/ou software de la plate-forme dexcution 5.
Une fois installe, celle-ci permet alors lexcution de toute application dveloppe en Java, quil sagisse
dapplications de type console (simple texte) ou dapplications graphiques ; elle peut aussi tre intgre au
navigateur et permettre alors lexcution dapplets 6.
La machine virtuelle Java est gnralement intgre et disponible sous la forme dun environnement dexcution
complet 7 comprenant la JVM et un ensemble de bibliothques Java.
Les avantages du langage Java sont :
Y langage tout objet ( lexception des types primitifs) ;
Y grande robustesse (langage fortement typ, gestion automatique de la mmoire, gestion des erreurs, etc.) ;
Y portabilit (aucune recompilation ncessaire : une fois le code Java compil, son excution sans erreurs ne
dpend que de la JVM 8) ;
Y gestion de la scurit ;
Y forte capacit dintgration aux environnements web ;
Y facilit dcriture dinterfaces graphiques professionnelles.
Les inconvnients du langage Java sont :
Y vitesse dexcution gnralement infrieure un langage compil en natif (tel que C++) ;
Y difficults daccs aux ressources matrielles.
1
2
3
4
5
6
7
Les concepteurs du langage Java sont James Gosling et Patrick Naughton, employs de Sun Microsystems.
La version actuelle (juillet 2009) est la 6 update 13 .
Concept repris par le langage C# et le framework .Net.
JVM : Java Virtual Machine (eng) [ Machine Virtuelle Java (fr).
Un mme code source Java, une fois compil, peut donc tre excut sous Windows, Linux, MacOS, Solaris, etc.
Applet : application graphique pouvant sexcuter dans une page web.
Appel JRE (Java Runtime Environment (eng) [ environnement dexcution Java (fr)), parfois abrg en JSE ou J2SE (Java Standard Edition /
Java2 Standard Edition (eng) [ dition Standard de Java / dition Standard de Java2 (fr)). Pour les devloppeurs, il faut se tourner vers le JDK
(Java Development Kit (eng) [ Kit de Dveloppement Java (fr)) qui comprend le JRE et lenvironnement de dveloppement.
Write once, run everywhere (eng) [ crire une fois, sexcuter partout (fr).
6 / 59
1.1.0.1 07/05/2010
2 NOTIONS DE BASE
2.1 LA PROGRAMMATION ORIENTE OBJET
Java est un langage de programmation tout objet, la syntaxe proche du C++. On ne manipule donc que des objets.
2.1.1
Gnralits sur lobjet
Le terme objet dsigne une entit informatique spcifique, qui est une reprsentation abstraite simplifie dun objet
concret et abstrait du monde rel ou virtuel. Un objet appartient une famille dobjets et possde des variables
associes et des fonctions associes ; en terminologie objet, on parle respectivement de classe (famille dobjets),
attributs 1 (variables) et mthodes (fonctions).
Lorsque lon fait rfrence une classe, le terme de membres dsigne les attributs et les mthodes de cette classe.
Ex. : Soit la classe Vehicule reprsentant la notion de vhicule du monde rel.
Vehicule
- couleur : int
- vitesse : int
+ Vehicule()
+ arreter() : void
+ demarrer() : void
Figure 2.1 : exemple dun objet (classe, attributs et mthodes, visibilit des membres)
La programmation oriente objet (POO) peut tre dfinie par les trois grands principes suivants :
Y lencapsulation ;
Y lhritage de classe ;
Y le polymorphisme.
2.1.2
2.1.2.1
Principes
Lencapsulation
Lencapsulation consiste prserver la valeur des attributs de lobjet ; ceux-ci ne sont accessibles de lextrieur de
la classe que par lintermdiaire des mthodes de la classe. Les attributs sont dits alors privs (accs direct restreint
la classe seulement) ou protgs (accs direct restreint la classe et aux ventuelles sous-classes), alors que les
mthodes sont gnralement publiques 2 (accs possible lintrieur et lextrieur de la classe).
Ex. : Seules les mthodes demarrer() et arreter() peuvent modifier lattribut vitesse.
Pour tout attribut qui doit tre accessible de lextrieur de la classe, on crit en gnral 2 mthodes spcifiques
appeles accesseurs ; on distingue les accesseurs en lecture, permettant de connatre la valeur dun attribut (prototype
usuel : type_attribut getAttribut()) et les accesseurs en criture permettant daffecter une valeur un attribut
(prototype usuel : void setAttribut(type_attribut newvaleur)).
Lattribut peut alors tre considr comme tant public, mais la diffrence par rapport une relle dfinition
publique est que les accesseurs peuvent contrler la lecture ou lcriture de lattribut (notamment viter une valeur
dcriture errone, ou bien transmettre une valeur de lecture mise lchelle, etc.)
1
2
Parfois appeles aussi proprits dans certains langages.

Une mthode peut cependant tre prive si elle est destine tre appele uniquement par dautres mthodes de la classe.
7 / 59
1.1.0.1 07/05/2010
Ex. : Les attributs de la classe Vehicule sont protgs grce la visibilit prive (), alors que les mthodes sont
publiques (+). Nanmoins, pour permettre une collaboration avec lextrieur de la classe, on associe lattribut
couleur un accesseur en lecture (int getCouleur()) et un accesseur en criture (void setCouleur(int cc)).
Vehicule
- couleur : int
- vitesse : int
+
+
+
+
+
Vehicule()
arreter() : void
demarrer() : void
getCouleur() : int
setCouleur(int) : void
Figure 2.2 : exemple de respect de lencapsulation grce aux accesseurs
2.1.2.2
Lhritage de classe
Lhritage de classe permet de crer une nouvelle classe partir dune classe dj existante. Cela permet ainsi de
prciser, ou mettre jour une classe. Du fait de lhritage, la nouvelle classe possde automatiquement les mmes
membres que la classe dj existante 1, lesquels peuvent tre complts par de nouveaux attributs et nouvelles
mthodes. Dans le cadre de cet hritage, la classe dj existante est appele la super-classe, et la nouvelle classe est
appele la sous-classe.
Ex. : Soit une classe qui reprsente un vhicule, et deux autres reprsentant une voiture et un vlo. Une voiture est
une sorte de vhicule ; un vlo est aussi une sorte de de vhicule. Dans les relations Vehicule/Voiture et
Vehicule/Velo, Vehicule est donc la super-classe ; Voiture et Velo sont donc les sous-classes.
Voiture
Vehicule
#
#
#
-
couleur : int
marque : char*
modele : char*
type : char*
+
+
+
+
+
accelerer() : void
arreter() : void
demarrer() : void
Vehicule()
~Vehicule()
- puissance : int
+ fairePlein(int) : void
+ Voiture()
+ ~Voiture()
Velo
- nbVitesses : int
+ changerPneu() : void
+ Velo()
+ ~Velo()
Figure 2.3 : exemple dun hritage de classe
2.1.2.3
Le polymorphisme
Le polymorphisme 2 est caractris par la dfinition de plusieurs mthodes homonymes, mais dont le comportement
et/ou la signature 3 diffrent, ou bien qui sappliquent des types dobjets distincts.
Il existe plusieurs types de polymorphismes :
Y polymorphisme ad hoc : 2 classes diffrentes possdent chacune une mthode homonyme (nom et signature
identiques) mais dont le comportement est diffrent (adapt chaque classe) ; aussi appel surcharge 4 ;
Ex. : Les classes Vehicule et Ordinateur possdent toutes les deux une mthode demarrer() ; mais les
actions de cette mthode sont diffrentes pour chacune des 2 classes (par exemple demarrer() pour
Vehicule inclut
insererClef(), etc. alors que demarrer() pour Ordinateur inclut
allumerEcran(), etc.).
Y polymorphisme dhritage : 1 sous-classe hrite dune mthode
de la super-classe (nom et signature de la

mthode identiques), mais dont le comportement est diffrent (adapt la sous-classe par redfinition de la
mthode) ; aussi appel spcialisation 6 ;
1
2
3
4
5
6
Uniquement si ceux-ci ont t dclars publics ou protgs.

Mot dtymologie grecque signifiant peut prendre plusieurs formes .
La signature dune mthode correspond au nombre et au type darguments (paramtres dentre) de la mthode.
Surcharge (fr) [ overloading (eng).
Parmi un ensemble dautres membres.
Spcialisation (fr) [ overriding (eng).
8 / 59
1.1.0.1 07/05/2010
Ex. : La classe Velo hrite de la mthode demarrer() de la classe Vehicule ; mais celle-ci est redfinie
pour tre adapte la classe Velo (par exemple demarrer() pour la sous-classe Velo inclut pedaler(),
etc., alors que demarrer() pour la super-classe Vehicule inclut insererClef(), etc.).
Y polymorphisme paramtrique : 1 classe possde plusieurs dfinitions dune mthode homonyme mais dont la
signature est diffrente ; aussi appel gnricit 1.
Ex. : La classe Voiture possde plusieurs dfinitions de la mthode fairePlein() : void

fairePlein(int nbLitres), void fairePlein(int nbLitres, String typeCarburant), void
fairePlein(float pourXEuros).
2.2 DVELOPPEMENT JAVA

2.2.1
Environnement de dveloppement
Pour dvelopper en Java, un diteur de texte associ un compilateur Java peut suffire. Mais on peut aussi utiliser
des outils de dveloppement, comme des AGL 2 (NetBeans, Eclipse, JBuilder, etc.) qui incluent les outils de base
ncessaires (diteur de texte et compilateur) et proposent un certain nombre de fonctionnalits qui simplifient la
construction dapplications (dbogueur, outils graphiques RAD, etc.).
Le code source Java (fichier .java) est compil dans un premier temps ; le rsultat de cette compilation est un fichier
(.class) et constitue ce quon appelle alors le bytecode 3. Ce bytecode est alors interprt par la machine cible, au
moyen de la machine virtuelle Java, propre la plate-forme en cours dutilisation sur cette machine.
Dans son exploitation gnrale, Java est donc un langage compil et interprt ; mais on peut aussi dvelopper de
manire classique pour une plate-forme spcifique, en effectuant une compilation native 4.
La cration dun fichier exploitable partir dun fichier source Java suit les tapes suivantes :
package monPackage;
public class MaClass
{
MaClasse() { ...
fichier
source Java
(.java)
101100101100100011
110110110100110
compilation
Ordinateur
interprtation
fichier
bytecode
(.class)
compilation native
Systme dexploitation
Machine
Virtuelle Java
101100101100100011
110110110100110
fichier
excutable
(.exe)
excution
Figure 2.4 : exploitation du code source Java
2.2.2
Structure dun fichier source
La syntaxe Java est drive de la syntaxe C++ ; nanmoins, on note les diffrences suivantes :
Y Un fichier source Java porte lextension .java ;
5
Y Un fichier source ne contient quune seule classe et il porte le nom de la classe (NomClasse.java) ; dans un
projet Java, on a donc autant de fichiers que de classes ;

Y Les mthodes sont implmentes lintrieur de la classe ;
Y La relation de type objet est marque par le caractre . (point), la notation pointe (->) nexiste pas ;
Y Toutes les instanciations dobjet se font implicitement de manire dynamique ; de fait, en tant que langage
tout objet, il ne reste plus que les variables de type primitif 6 qui ne sont pas instancis ;
7
Y La destruction des objets est ralise de manire automatique ds lors que ceux-ci ne sont plus rfrencs ;
1
2
3
4
5
6
7
Gnricit (fr) [ template (eng).

Atelier de Gnie Logiciel.
Appel aussi p-code, pour pseudo-language.
Cependant on perd alors lune des grandes spcificits du langage Java par rapport ces concurrents : la portabilit.
Une seule classe publique, laquelle peut contenir des classes prives (utilisables uniquement par la classe publique).
int, long, float, double, char, etc.
Cest un mcanisme appel ramasse-miettes (fr) [ garbage collector (eng), inclus dans la JVM, qui soccupe de cette tche.
9 / 59
1.1.0.1 07/05/2010
Y Pas de prprocesseur (#include, etc.), pas de macros, pas de variables globales, pas dhritage multiple, pas
de surcharge doprateurs 1.
La structure dun fichier source Java est donc la suivante :

package nom_paquetage; // nom du paquetage (projet) auquel appartient la classe
import chemin.bibliotheque;
// importation d'une bibliothque/paquetage
public class NomClasse

{
// attributs
type_attribut attribut1;
...
// mthodes
NomClasse() { ... }
// constructeur
type_mthode nomMethode1(arguments) { ... }
...
// mthode main() permet d'excuter la classe (1 seule par projet en gnral)
public static void main(String[] args) { ... }
} // pas de ';' final
Ex. :
UneClasse.java
package MonPackage;
public class UneClasse
{
private int i;
public UneClasse(int ii) // constructeur avec 1 argument de type int
{
this.i = ii; // initialisation de l'attribut i l'aide de l'argument
}
public void uneMethode()

{
System.out.println(i);
}
MonApplication.java
package MonPackage;
public class MonApplication
{
private int x;
private int tab[];
private UneClasse unObjet;
public MonApplication() {}
public static void main(String[] args)
{
this.x = 5; // utilisation de this car x est attribut, pas variable
tab = new int[4]; // instanciation du tableau (un tableau est un objet)
unObjet = new UneClasse(x); // instanciation d'un objet de UneClasse
unObjet.uneMethode(); // appel d'une mthode de UneClasse
System.out.println(tab.length); // affichage de la longueur du tableau
}
}
1
lexception de la surcharge de loprateur + pour la classe String, qui permet de concatner des chanes.
10 / 59
2.2.3
1.1.0.1 07/05/2010
Les bibliothques de classes Java
Les classes sont regroupes en bibliothques de classes, appeles paquetages 1 ; lesquelles permettent dutiliser les
diverses ressources de la machine (capacits graphiques, rseau, base de donnes, etc.). Elles reprsentent ce quon
appelle lAPI 2 de Java. Ainsi, lorsque le langage Java subit un changement de version, cest principalement lAPI qui
est modifi, avec la mise jour et/ou le rajout de classes.
Chaque paquetage se rapporte un domaine prcis : composants graphiques, composants rseaux, etc.
LAPI de Java est hirarchis :
Y java.lang, java.util : classes de base et utilitaires du langage (importes par dfaut) ;
Y java.io : entres/sorties ;
Y java.net : rseau ;
Y java.awt, java.swing : graphique ;
Y etc.
Pour utiliser une classe, ou bien tout ou partie dun paquetage dj existant, il faut importer la/les classe(s) grce au
mot-clef import suivant la syntaxe import chemin.bibliotheque;.
Ex. : import java.awt.Button;
import java.awt.font.*;
import java.awt.*;
// importation de la classe Button

// importation d'une partie du paquetage java.awt
// importation du paquetage complet java.awt
Toute classe appartient un paquetage. Si on nen spcifie pas un explicitement, un paquetage par dfaut est
attribu, qui correspond au nom du projet auquel appartient la classe.
On peut aussi dfinir ses propres paquetages et les utiliser par la suite dans ses propres programmes.
2.3 LES VARIABLES

2.3.1
Les types de variables prdfinis
Le langage Java utilise les types classiques suivants, dits aussi types primitifs car non-objets :
Y boolean : boolen (true/false) ;
Y byte, short, int, long : entier sur 8, 16, 32, 64 bits ;
Y float, double : rel sur 32, 64 bits (pour float, on suffixe les littraux avec f, ex : float x =
1.4f;) ;
3
Y char : caractre sur 16 bits au standard Unicode (ex. : char c = '\u0040'; ou char c = 'A';) ;
Y void : type vide , aucun type.
Mais il existe aussi des types prdfinis objet :
Y String : chane de caractres.
2.3.2
Les constantes
Java ne possde pas de macros 4. Pour dfinir une constante, on utilise le modificateur final 5 suivant la syntaxe
final type_variable nomVariable.
Ex. : final int NB = 5;
2.3.3
Les chanes de caractres
Le type String reprsente une chane de caractres. Ce type est en ralit un objet et doit donc tre instanci
dynamiquement.
1
2
3
4
5
Paquetage (fr) [ package (eng).

Application Programming Interface : Interface de programmation dapplication.
Le standard Unicode, cod sur 16 bits, permet de coder 65536 caractres diffrents, et comprend ainsi une partie des alphabets cyrillique,
hbreux, arabe, chinois, grec, etc., ainsi que les caractres accentus (non inclus dans le standard ASCII, cod sur 7 bits : 128 caractres).
#define en langage C/C++.
Le mot-clef final est un modificateur qui peut aussi tre appliqu une mthode, ou bien une classe, mais il a alors une autre signification.
11 / 59
1.1.0.1 07/05/2010
Ex. : String chn = new String();

Les chanes de caractres doivent tre encadres par le caractre " (guillemets).
Ex. : String chn = new String("ceci est une chane de caractres");
On peut concatner les chanes facilement avec loprateur + (plus).
Ex. : String chn, chn2;
chn = new String("ceci est une ");

chn2 = new String(chn + "chane de caractres");
Les caractres spciaux connus peuvent aussi tre utiliss : \r (retour chariot), \n (saut de ligne),
\t (tabulation), \b (retour arrire), \f (saut de page).
Le caractre \ est le caractre dchappement et permet par exemple dinsrer le caractre " (guillemet) dans une
chane.
En tant quobjet, le type String possde donc des attributs et des mthodes. On notera par exemple les mthodes
length() et equals().
2.3.4
Les tableaux
Les tableaux sont considrs comme des objets et doivent donc tre instancis dynamiquement.
Il existe deux types de dclarations possibles pour les tableaux :
Y type nom_tableau[] : classique, comme en C++ ;
Y type[] nom_tableau : le type type[] est considr comme un objet.
Ex. : int tab1[] = new int[10];
int[] tab2 = new int[10];
En tant quobjet, un tableau possde des attributs et des mthodes. On notera par exemple lattribut length, comme
les mthodes toString() et equals().
On peut videmment crer des tableaux plusieurs dimensions.
Ex. : double[][] nombres = new double[10][20];
Nb : Les objets String (objet de type String) et String[] (tableau dobjets de type String) sont deux objets
compltements diffrents ; ils nont donc pas les mmes attributs et les mmes mthodes.
2.4 LES STRUCTURES DE CONTRLE

Elles sont identiques au langage C++.
2.4.1
Les oprateurs dvaluation dexpression
Pour valuer une expression, on utilise un ou plusieurs oprateurs, parmi 2 types diffrents :
Y oprateurs de tests :
` == : gal ;
` != : diffrent ;
` > : strictement suprieur ;
` < : strictement infrieur ;
` >= : suprieur ou gal ;
` <= : infrieur ou gal.
Y oprateurs logiques :
` && : ET ;
` || : OU ;
` ! : NON.
Le rsultat obtenu est un boolen (true/false).
12 / 59
1.1.0.1 07/05/2010
La priorit des oprateurs est la suivante (du plus prioritaire au moins prioritaire) :
Y parenthses ;
Y incrmentation, dcrmentation ;
Y multiplication, division, modulo ;
Y addition, soustraction ;
Y comparaison ;
Y affectation.
2.4.2
2.4.2.1
Les tests
Test simple si sinon
Pour raliser un test simple si sinon , on utilise linstruction if () ventuellement associe avec
linstruction else, suivant la syntaxe :
if (expression) {
/* instructions excuter si expression vraie */
}
else {
/* instructions excuter si expression fausse */
}
2.4.2.2
Test multiple au cas o faire
Pour raliser un test multiple au cas o faire , on utilise les instructions switch () et case ventuellement
associes avec linstruction default, suivant la syntaxe :
switch (variable) {
case valeur1 : /* instructions si variable vaut valeur1 */
break;
case valeur2 : /* instructions si variable vaut valeur2 */
break;
...
default : /* instructions si variable ne vaut aucune des valeurs */
}
Nb : Seules des variables de type entier ou caractre peuvent tre utilises.
2.4.3
Loprateur ternaire
Loprateur ternaire peut tre utilis, la place dune structure de test base de if, pour affecter rapidement une
valeur une variable. La syntaxe est la suivante :
variable = (expression) ? valeur_si_expression_vraie : valeur_si_expression_fausse;
2.4.4
2.4.4.1
Les boucles
Boucle tant que faire
Pour raliser une rptition tant que faire avec aucune excution au minimum, on utilise linstruction
while (), suivant la syntaxe :
while (expression) {
/* instructions rpter si expression vraie */
}
2.4.4.2
Boucle rpter tant que
Pour raliser une rptition rpter tant que avec au moins 1 excution, on utilise les instructions do et
while (), suivant la syntaxe :
do {
}
while (expression);
13 / 59
2.4.4.3
1.1.0.1 07/05/2010
Boucle pour faire
Pour raliser une rptition contrle pour faire , on utilise linstruction for (), suivant la syntaxe :
for (initialisation ; expression ; modification) {
}
2.5 GESTION DES VNEMENTS

Java intgre la notion de gestion dvnements. Cest--dire que lon programme la raction de lapplication en
fonction des actions de lutilisateur sur tout objet graphique de lapplication ; ces actions sont appeles vnements.
En ralit, un vnement est un message quun objet envoie un autre objet en lui signalant loccurrence dun fait
remarquable (ex. : un clic de souris sur un bouton).
vnement
objet 1
objet 2
message
Figure 2.5 : envoi de message entre deux objets lors dun vnement
Dans un environnement graphique, il y a une grande quantit dvnements possibles, et un objet ne sera intress
que par une partie dentre eux. Par consquent il faut spcifier les vnements que chaque objet doit prendre en
considration ; on utilise pour cela un objet qui est appel un couteur 1.
Un mme objet peut tre intress par plusieurs vnements ; rciproquement, un mme type dvnements peut
intresser plusieurs objets diffrents.
La gestion dvnements revient donc dfinir une communication entre deux objets grce un couteur ; lun des
objets est donc metteur du message, alors que lautre est rcepteur.
Ex. : Soit un objet JButton auquel on dsire associer lvnement actionPerformed (clic sur le bouton).
public class Frame1 {
objet rcepteur du message
JButton jButton1 = new JButton();

jButton1.addActionListener(new java.awt.event.ActionListener() {
objet metteur
du message
association
dun nouvel
couteur
jButton1
public void actionPerformed(ActionEvent e) {

jButton1_actionPerformed(e);
vnement
gr
}
});
message
...
void jButton1_actionPerformed(ActionEvent e)
{
System.out.println("");
}
}
Il existe plusieurs types dcouteurs ; chacun dentre eux est spcialis et est dfini par une classe :
Y class ActionListener : gestion des vnements standard : clic sur un bouton, double-clic sur un
lment de liste, choix dun lment dun menu, validation dun champ texte ;
Mthode : actionPerformed().
couteur (fr) [ listener (eng) ; il faut comprendre couteur dvnements , cest--dire tre lcoute dun vnement .
14 / 59
1.1.0.1 07/05/2010
Y class MouseListener : gestion des clics de souris ;

mouseClicked(),
mousePressed(),
mouseReleased(),
mouseEntered(),
Mthodes :
mouseExited().
Y class MouseMotionListener : gestion des dplacements de souris ;
Mthodes : mouseDragged(), mouseMoved().
Y class KeyListener : gestion du clavier ;
Mthodes : keyTyped(), keyPressed(), keyReleased().
Y class WindowListener : gestion de la fentre ;
windowOpened(),
windowClosing(),
windowClosed(),
windowIconified(),
Mthodes :
windowDeiconified(), windowActivated(), windowDeactivated() ;
Y class FocusListener : gestion des vnements lorsquun composant devient actif ou passif (gain ou
perte de focus) ;
Mthodes : focusGained(), focusLost().
Y class TextListener : gestion dun composant de type texte ;
Y
2.6 LES EXCEPTIONS

Le langage Java offre un mcanisme pour palier la gestion des erreurs dexcution dun programme ; le but est de
prvoir une poursuite ou une sortie du programme de manire correcte lorsquune erreur survient.
On appelle exception le signal envoy par une mthode ayant dtect loccurrence dune erreur dexcution ou
dune situation anormale.
On dit que la mthode dclenche (throws) une exception, qui est intercepte (catch) par le code. Les appels de
mthodes susceptibles de dclencher une exception se font lintrieur dun bloc spcifique (try).
Cest dans le bloc catch quest dfini le traitement de lexception.
Enfin, le bloc optionnel finally permet de dfinir des traitements qui sont excuts quil y ait eu exception ou pas.
Ex. : public class Frame1 extends Frame
{
public Frame1()
{
try {
jbInit();
}
catch(Exception e) {
System.out.println("erreur");
}
finally {
...
}
}
jbInit() peut gnrer une erreur
dexcution, il faut donc en tenir compte

code excuter si le bloc try
associ (jbInit() donc)
dclenche une exception
code excuter une fois le
bloc try trait, quil y ait eu
exception ou pas
...
private void jbInit() throws Exception
{
JButton jButton1 = new JButton();
JTextField jTextField1 = new JTextField();
...
}
jbInit() (initialisation de
lIHM) est susceptible de
dclencher une exception
Le bloc catch () doit tre mentionn mme si aucun traitement particulier de lexception nest dfini
(catch (Exception e) {}).
Nb : Lors du traitement dune exception dans une mthode, on peut faire le choix suivant : soit traiter lexception l
o cela est ncessaire, en utilisant pour cela try / catch () ; soit ne pas traiter lexception directement, et laisser
alors la mthode appelante sen occuper, en le lui faisant savoir en utilisant la dclaration throws.
Ex. : Dans lexemple prcdent, il a t dcid que jbInit() ne traiterait pas lexception, et cette mthode a donc
t dclar ainsi : void jbInit() throws Exception {...}. Ainsi, cest la mthode appelant jbInit(), en
loccurrence Frame1(), de grer lexception, en utilisant try / catch ().
15 / 59
1.1.0.1 07/05/2010
Dans le cas dun bloc dinstructions ou bien dune mthode susceptible de gnrer plus dun seul type dexceptions
diffrentes, la gestion des exceptions peut se faire de 2 manires diffrentes :
Y On traite chaque exception indpendamment : on aura alors 1 bloc try {}, et autant de blocs catch () {}
spcialiss que dexceptions diffrentes grer.

Ex. :
try {
//
//
}
catch
//
//
}
catch
//
//
}
bloc d'instructions ou mthode susceptible de gnrer plusieurs

exceptions diffrentes (exemple avec NullPointerException et IOException)
(NullPointerException npe) {
instructions excuter si une exception du type
NullPointerException est dclenche
(IOException ioe) {
instructions excuter si une exception du type
IOException est dclenche
Y On traite toutes les exceptions de la mme manire : on aura alors 1 bloc try {}, et 1 seul bloc catch()
{} grant tout type dexception possible (tout type dexception hrite de la classe Exception (ex. : signature
de la classe IOException : public class IOException extends Exception {...})).
Ex. :
try {
//
//
}
catch
//
//
}
bloc d'instructions ou mthode susceptible de gnrer plusieurs

exceptions diffrentes
(Exception e) {
instructions excuter si n'importe quel type d'exception
(NullPointerException, IOException, etc.) est dclenche
2.7 LES DIFFRENTS TYPES DAPPLICATIONS JAVA

2.7.1
Les applications console
On appelle application console 1 une application qui ne met en jeu quune fentre de type texte et qui pourra nous
permettre dafficher diffrents rsultats.
La fentre texte est ce quon appelle la console, qui sera donc ici une console Java.
La structure gnrale du code Java pour une application console est donc la suivante :
UneClasse.java
package MonPackage;
{
// attributs
...
// mthodes
public UneClasse() // constructeur par dfaut (sans argument)
{
...
}
{
System.out.println("mthode uneMethode() de la classe UneClasse");
}
...
}
1
Dite aussi CUI : Console User Interface (eng) [ Interface Utilisateur Console (fr).
16 / 59
1.1.0.1 07/05/2010
MonApplication.java
package MonPackage;
public class MonApplication // classe principale
{
// attributs
...
// mthodes
public MonApplication() // constructeur par dfaut (sans argument)
{
...
}
{
MonApplication monApp; // dclaration d'un objet de la classe elle-mme
monApp = new MonApplication(); // instanciation d'un objet de la classe
System.out.println("bonjour\n"); // affichage console
UneClasse unObjet;
unObjet = new UneClasse(); // instanciation d'un objet de UneClasse
unObjet.uneMethode(); // appel d'une mthode de UneClasse
...
}
}
La machine virtuelle Java excute la mthode principale main(). Celle-ci doit absolument tre publique (public),
pour pouvoir tre appele (excute) de lextrieur de la classe ; elle doit aussi absolument tre statique (static) pour
pouvoir tre appele sans que lon dispose dune instance de la classe 1 ; enfin, la signature doit absolument faire
apparatre un tableau de chanes en tant quarguments dentre (String[] arguments). La dclaration complte de
la mthode main() est donc : public static void main(String[] args).
La mthode main() excute ensuite un code qui doit alors 2 instancier un objet de la classe, afin que les mthodes
non statiques de la classe principale puissent tre invoques.
Les affichages console se font en utilisant la classe System, qui possde des mthodes statiques ; celles-ci peuvent
donc tre appeles sans disposer dune instance de cette classe. Cette classe permet notamment de grer les flux
dentres/sorties standard :
Y entre standard : clavier (System.in.*) ;
Y sortie standard : cran (System.out.*) ;
Y erreur standard : cran (System.err.*).
2.7.2
Les applications graphiques
Une application graphique 3 est une application console laquelle on a rajout une interface graphique 4.
Lapplication possde alors 2 fentres :
Y fentre graphique (interface graphique) : application graphique ;
Y fentre texte (console java) : permet dafficher les messages dexceptions interceptes.
Par consquent, toute application java (graphique ou texte) comprend toujours une console, qui nest pas affiche
automatiquement dans le cas dune application graphique, mais qui est disponible si besoin est.
La partie application graphique drive 5 de la classe Frame (ou JFrame).
La structure gnrale du code Java pour une application graphique est donc la suivante :
1
2
3
4
5
Comme en Java les mthodes, et donc la mthode main(), sont dclares lintrieur de la classe, il est impossible davoir pu crer un objet
de la classe elle-mme au moment de la dfinition de la mthode main() ; celle-ci est donc dclare statique, et peut alors tre appele sans
que lon ait instanci un objet de la classe.
Entre autres.
Dite aussi GUI : Graphical User Interface (eng) [ Interface Utilisateur Graphique (fr).
Dite aussi IHM : Interface Homme-Machine.
Au sens objet.
17 / 59
1.1.0.1 07/05/2010
Cadre1.java
package MonPackage;
import java.awt.*; // importation de librairies graphique
import javax.swing.*; // importation de librairies graphique
public class Cadre1 extends Frame
{
// attributs
...
// mthodes
public Cadre1()
{
...
}
{
...
}
...
}
MonApplication.java
package MonPackage;
public class MonApplication // classe principale
{
// attributs
...
// mthodes
public MonApplication()
{
...
}
{
MonApplication monApp = new MonApplication();
Cadre1 monCadre = new Cadre1();
...
}
}
En gnral on tend respecter la sparation traitements / graphique 1, limage de la sparation fentre texte /
fentre graphique, et on utilise alors une classe (voire plusieurs), autre que linterface graphique, pour raliser les
traitements.
2.7.3
Les applets
On appelle applet une application graphique qui sexcute lintrieur de la fentre dun navigateur internet.
Pour crer une applet, il faut driver de la classe Applet.
La structure gnrale du code Java pour une applet est donc la suivante :
Modle MVC : Model View Controller (eng) [ Modle Vue Contrleur (fr), sparation des traitements et de lIHM.
18 / 59
1.1.0.1 07/05/2010
Applet1.java
package MonPackage;
import java.applet.*; // importation du paquetage applet
public class Applet1 extends Applet
{
// attributs
...
// mthodes
public void init()
{
...
}
...
}
Lorsque le navigateur charge une page HTML contenant une applet, il charge donc lapplet elle-mme, puis
instancie un objet de la classe principale (drive de la classe Applet). Cest la fentre du navigateur qui sert de
conteneur graphique lapplet.
Si on veut que lapplet puisse aussi tre excute en dehors dun navigateur web, comme une simple application
graphique, il suffit dcrire la mthode main() qui sera appele lors dune excution classique.
19 / 59
1.1.0.1 07/05/2010
3 LHRITAGE
3.1 LHRITAGE SIMPLE
3.1.1
Principes
En tant que langage objet, Java implmente le concept dhritage de classes. En revanche, contrairement au C++,
Java ne permet pas dhritage multiple, et on ne peut donc driver que dune seule classe 1.
Pour dfinir une sous-classe partir dune super-classe, on utilise le mot-clef extends, suivant la syntaxe
public class SousClasse extends SuperClasse {...}

SuperClasse
SousClasse
Figure 3.1 : hritage entre deux classes
La sous-classe hrite ainsi des attributs et des mthodes de la super-classe ; les mthodes peuvent bien videmment
tre redfinies par surcharge le cas chant.
3.1.2
Hirarchie de classes
En Java, toutes les classes drivent implicitement de la classe Object, qui est appele classe-mre. Cet hritage
peut tre direct, ou bien peut provenir de plusieurs relations dhritages successives.
Object
Component
Button
File
Container
Panel
Label
Number
Double
Integer
Window
Dialog
Frame
Figure 3.2 : hirarchie des classes Java
Lensemble des classes et des relations dhritage entre ces classes forment alors une arborescence (hirarchie) au
sommet de laquelle se situe la classe Object.
Cette hirarchie unique permet de dfinir des comportements communs pour toute classe Java.
Ainsi, une classe qui nhrite apparemment daucune autre, hrite en fait implicitement de la classe Object.
1
Ceci pourrait apparatre comme une faiblesse de Java par rapport au C++. En ralit cette particularit a le mrite dviter les difficults de
programmation lies lhritage multiple ; la notion dinterface (cf. 3.2) permet de palier en partie ceci.
20 / 59
public class UneClasse extends Object

{
...
}
1.1.0.1 07/05/2010

{
...
}
Une classe quelconque cre par lutilisateur hrite donc toujours, mme indirectement, de la classe Object.
La consquence est que les mthodes 1 de la classe Object se retrouvent alors dans toute classe Java. Par exemple,
la mthode toString() est drive dans toutes les classes Java ; cette mthode affiche le nom de la classe sous forme
de chane, sauf bien videmment pour les classes qui ont redfinies cette mthode 2.
Comme le constructeur dune classe fait un appel implicite au constructeur de la classe dont il drive, une autre
consquence est que lon fera donc toujours appel, au final, au constructeur de la classe Object en enchanant les
diffrents constructeurs des relations dhritage existantes entre la classe utilisateur et la classe Object.
3.1.3
Accs aux attributs et mthodes dans une relation dhritage
Pour tre accessible par une sous-classe, les attributs et les mthodes dune super-classe doivent tre dclares
protgs (protected : seules les sous-classes peuvent y accder), voire publics (public : tout le monde y a accs).
On peut faire appel un attribut ou bien une mthode de la super-classe en utilisant loprateur super qui
fonctionne lidentique de loprateur this.
Pour accder un attribut de la super-classe, on crit donc super.nomAttribut et pour une mthode
super.nomMethode().
Ex. :
SuperClasse.java
package MonPackage;
public class SuperClasse
{
protected int i;
public SuperClasse()
{
...
}
}
SousClasse.java
package MonPackage;
public class SousClasse extends SuperClasse // SousClasse drive de SuperClasse
{
private int i;
public SousClasse()
{
...
}
public uneMethode
{
i = 0;
this.i = 1;
super.i = 5;
}
}
1
2
La classe Object ne possde pas dattribut.

Cas des classes Double, Integer, etc. par exemple.
21 / 59
1.1.0.1 07/05/2010
La premire action ralise par le constructeur dune sous-classe est dexcuter le constructeur par dfaut de la
super-classe dont il dpend, et ce de manire automatique, sans que cela soit visible dans le code ; en revanche, si un
appel explicite lune des surcharges du constructeur de la super-classe est fait, alors il ny a plus besoin dinvoquer le
super -constructeur par dfaut.
Lorsque lon dsire faire appel au constructeur de la super-classe, on crit super(). Cette mthode publique est
surcharge autant de fois que le constructeur de la super-classe est lui-mme surcharg, en respectant alors les
diffrentes signatures existantes.
Ex. :
SuperClasse.java
package MonPackage;
public class SuperClasse
{
public SuperClasse()
{
...
}
public SuperClasse(int a)
{
...
}
public SuperClasse(double db, int b)
{
...
}
}
SousClasse.java
package MonPackage;
public class SousClasse extends SuperClasse
{
public SousClasse()
{
super(); // appel implicite, donc inutile
}
public SousClasse(int aa)
{
super(aa); // appel du constructeur surcharg sinon appel implicite super()
}
public SousClasse(double ddb, int bb)
{
super(ddb, bb); // appel du constructeur surcharg (sinon appel super())
}
}
Nb : On peut empcher la surcharge future dune mthode en utilisant le mot-clef final.
3.2 LES INTERFACES

3.2.1
Introduction : mthode et classe abstraite
On dit quune mthode dune classe est abstraite si seul son prototype est dfini, et quaucun code nest donn. Son
implmentation complte devra en fait tre crite par chaque sous-classe qui drivera de cette classe.
Une mthode abstraite dune classe doit donc obligatoirement tre surcharge dans chaque sous-classe drive.
22 / 59
1.1.0.1 07/05/2010
La super-mthode ne constitue alors que la dfinition dun concept, que chaque sous-classe sera libre
dimplmenter selon ses besoins.
Une mthode abstraite se dclare en utilisant le mot-clef abstract.
Ex. :
Cercle
FormeGeometrique
+ calculerAire() : double
+ Cercle()
Carre
+ calculerAire() : abstract double

+ FormeGeometrique()
+ Carre()
Figure 3.3 : exemple dutilisation dune mthode abstraite
FormeGeometrique.java
package Geometrie;
public abstract class FormeGeometrique
{
public FormeGeometrique()
{
...
}
public abstract double calculerAire(); // dfinition du prototype uniquement
}
Cercle.java
package Geometrie;
public class Cercle extends FormeGeometrique
{
private double rayon;
public Cercle(double r)
{
this.rayon = r;
}
public double calculerAire() // implmentation de la mthode abstraite
{
return (java.lang.Math.PI * this.rayon * this.rayon);
}
}
Carre.java
package Geometrie;
public class Carre extends FormeGeometrique
{
private double cote;
public Carre(double c)
{
this.cote = c;
}
23 / 59
1.1.0.1 07/05/2010
public double calculerAire() // implmentation de la mthode abstraite

{
return (this.cote * this.cote);
}
}
Si une classe comprend une mthode abstraite, alors la classe elle-mme doit tre dclare abstraite (public
abstract class MaClasse { ... }).
La consquence directe du caractre abstrait de la classe est quon ne peut pas instancier dobjets de cette
classe 1. La classe est donc pleinement destine demeurer une classe concept , cest--dire une classe qui constitue
un modle pour dautres classes.
Lors de la dfinition dune sous-classe partir dune super-classe abstraite, toute mthode abstraite doit
obligatoirement tre code ; sinon elle doit tre dclare abstraite, et de fait, la classe laquelle elle appartient doit
ltre aussi. La sous-classe constitue alors elle aussi un modle pour dautres classes 2.
3.2.2
Dfinition dune interface
En Java, on appelle interface une classe abstraite dont toutes les mthodes sont abstraites (abstract) et tous les
attributs sont constants (final).
On dclare une interface avec le mot-clef interface, qui vient en remplacement du mot-clef class.
public interface MonInterface {
// attributs
int i = 0; // initialisation obligatoire des attributs (doit tre constant)
...
// mthodes
void uneMethode(); // dfinition du prototype des mthodes
...
}
De par sa nature, une interface a implicitement et automatiquement des attributs publics (public), statiques
(static) et constants (final), ainsi que des mthodes publiques (public) et abstraites (abstract) ; il est donc
inutile de prciser ces diffrents modificateurs.
De la mme manire, une interface ne dfinit pas de constructeur.
En gnral, on assimile une interface une classe de services, cest--dire une classe qui est utilise par dautres
classes pour implmenter une fonctionnalit quelles doivent proposer ; ces fonctionnalits sont appeles services 3.
Ex. : Une classe qui utilise linterface Runnable doit implmenter la mthode run() qui autorise la
fonctionnalit excution en tant que thread (multi-tches).
En dautres termes, une interface ne fait que reprsenter, sans limplmenter, un comportement que doit suivre
certaines classes, laissant ainsi la libert chaque classe de limplmenter selon ses besoins.
3.2.3
Implmentation
Une fois le type de service dfini pour un groupe de classes travers une interface, on utilise cette dfinition de
service en drivant de linterface.
Plus spcifiquement, on dit quune classe implmente une interface si cette classe fournit les dfinitions de toutes
les mthodes dclares dans linterface.
Pour marquer ce principe dimplmentation ralis par la sous-classe, on utilise le mot-clef implements suivant la
syntaxe public class MaClasse implements MonInterface {...}.
1
2
3
Ce qui est logique tant donn quelle possde au moins une mthode dont le code nest pas donn (la mthode abstraite).
On peut ainsi imaginer une hirarchie de classes abstraites, servant de modles lors dune implmentation.
Usuellement, le nom dune interface possde un suffixe en ible ou able, marquant ainsi la capacit de service offerte (ex. Runnable).
24 / 59
<<interface>>
MonInterface
1.1.0.1 07/05/2010
MaClasse
Figure 3.4 : implmentation dune interface
MonInterface.java
package MonPackage;
public interface MonInterface
{
...
}
MaClasse.java
package MonPackage;
public class MaClasse implements MonInterface
{
...
}
Contrairement lhritage, une classe peut implmenter plusieurs interfaces 1.

Ex. :
public class MaClasse implements MonInterface, MonAutreInterface
{
...
}
Une interface peut hriter dune autre interface. Cependant la limitation lhritage simple est identique celles des
classes.
Ex. :
MonInterface.java
package MonPackage;
public interface MonInterface
{
...
}
MonAutreInterface.java
package MonPackage;
public interface MonAutreInterface extends MonInterface // hritage d'interface
{
...
}
La hirarchie des relations dhritage et celle des implmentations dinterfaces sont totalement indpendantes. Ainsi,
une classe peut hrite dune autre classe et elle peut aussi, en mme temps, implmenter une ou plusieurs interfaces.
Ex. :
public class MaClasse extends SuperClasse implements MonInterface
{
...
}
De fait, le concept dinterface est souvent vu comme la possibilit de raliser un hritage multiple en Java.
25 / 59
3.2.4
1.1.0.1 07/05/2010
Exemple dutilisation dune interface
Soit la dfinition de linterface FormeGeometrique suivante, et des classes Cercle et Carre qui implmentent
cette interface.
Cercle
<<interface>>
FormeGeometrique
+ Cercle()
+ dessiner() : void
Carre
+ dessiner() : void
+ Carre()
+ dessiner() : void
Figure 3.5 : exemple dutilisation dune interface
FormeGeometrique.java
package Geometrie;
public interface FormeGeometrique
{
public void dessiner();
public double calculerAire();
}
Cercle.java
package Geometrie;
public class Cercle implements FormeGeometrique // implmente l'interface
{
private int rayon;
public Cercle(int r)
{
this.rayon = r;
}
public void dessiner() // implmentation adapte au cercle
{
g.drawOval(0, 0, 2 * this.rayon,2 * this.rayon);
}
public double calculerAire() // implmentation adapte au cercle
{
return (java.lang.Math.PI * this.rayon * this.rayon);
}
}
Carre.java
package Geometrie;
public class Carre implements FormeGeometrique
{
private int cote;
public Carre (int c)
{
this.cote = c;
}
26 / 59
1.1.0.1 07/05/2010
public void dessiner() // implmentation adapte au carr

{
g.drawLine(0, 0, 0, cote);
g.drawLine(0, cote, cote, cote);
g.drawLine(cote, cote, cote, 0);
g.drawLine(cote, 0, 0, 0);
}
public double calculerAire() // implmentation adapte au carr
{
return (this.cote * this.cote);
}
}
On peut alors dfinir une liste de formes gomtriques diffrentes auxquelles on peut appliquer le mme traitement,
puisque toutes les formes implmentent linterface FormeGeometrique.
Ex. : Une classe Dessin, qui permet de grer un ensemble de formes gomtriques, de les dessiner, ainsi que de
calculer laire de chacune des formes.
Dessin.java
package Geometrie;
public class Dessin
{
private FormeGeometrique[] listeFormes; // dclaration d'un tableau de formes
public Dessin()
{
listeFormes = new FormeGeometrique[] { // initialisation du tableau
new Cercle(100), // Cercle est une sorte de FormeGeometrique
new Carre(300) // Carre est une sorte de FormeGeometrique
};
}
public void toutDessiner() // dessine toutes les formes
{
for(int i=0 ; i<listeFormes.length ; i++)
listeFormes[i].dessiner(); // appel de dessiner() adapte
}
public double[] toutCalculerAire() // calcule l'aire de toutes les formes
{
double[] aires = new double[listeFormes.length];
for(int i=0 ; i<listeFormes.length ; i++)
aire[i] = listeFormes[i].calculerAire();
return (aires);
}
}
listeFormes[0], bien qutant un objet dclar comme tant du type FormeGeometrique
(private FormeGeometrique[] listeFormes;), a t instanci laide du constructeur Cercle() (new
1
Cercle(100)), par consquent, il sagit bien l dune instance de la classe Cercle . Donc lorsque la mthode
dessiner() est appele pour cet objet (listeFormes[i].dessiner(); pour i = 0), on appelle bien la mthode
dessiner() de la classe Cercle(), donc celle adapte ce que reprsente lobjet.
Cest la mme chose pour i = 1, o on fait rfrence alors un objet dclar du type FormeGeometrique mais
instanci avec le constructeur Carre() ; bien videmment mmes remarques pour la mthode calculerAire().
Nb : Par souci de clart, le code des diffrentes classes donn ci-dessus a t simplifi ; par consquent il est
inexact, et ne peut pas aboutir une excution correcte.
On met ainsi en avant le fait quil est possible en POO, quun objet soit dun type X la dclaration, et dun type Y lexcution ; il suffit pour
cela que Y soit une sous-classe de X ; ex. : en Java, pour toute classe il est possible dcrire : Object monObjet = new MaClasse();.
27 / 59
1.1.0.1 07/05/2010
4 LES FLUX DENTRES/SORTIES

4.1 INTRODUCTION
4.1.1
Notion de flux
Une application peut avoir faire appel des entits informatiques externes 1 afin de lire ou dcrire des
informations ou des donnes.
La ralisation dune action de lecture ou dcriture constitue ce quon appelle un flux.
Ex. :
Y lorsquune application sauvegarde des donnes dans un fichier, elle utilise un flux dcriture ;
Y lorsquune application lit des informations partir dune base de donnes, elle utilise un flux de lecture.
4.1.2
Dfinitions
Un flux a pour but principal de transfrer des donnes ; il sagit dun outil de communication.
Il constitue un canal de transfert de donnes unidirectionnel et squentiel entre deux entits informatiques. Dans une
communication utilisant un flux, lune est donc lmetteur des donnes, et lautre le rcepteur.
Lorsquune communication de ce type est mise en uvre par une application Java, lune de ces entits est donc un
programme Java, alors que lautre pourra tre un fichier, une base de donnes, un socket, un priphrique,
Un programme effectue une lecture dans une base de donnes.
programme
flux
dcriture
fichier
Un programme effectue une criture dans un fichier.

bdd
flux de
lecture
programme
Figure 4.1 : exemples de flux de lecture et dcriture
Un flux peut transfrer les donnes de manire brute, soit donc octet par octet, ou bien de manire formate, en
transfrant par exemples des double, des int,
On considre que le programme Java est le point central des communications, et on peut alors parler de flux dentre
pour un flux en lecture et de flux de sortie pour un flux en criture.
4.1.3
Principe de mise en uvre des flux
La retranscription algorithmique de la mise en uvre des flux est la suivante :
Externes lapplication elle-mme, donc pouvant tre localises sur la mme machine, ou dautres dans un rseau informatique.
28 / 59
1.1.0.1 07/05/2010
Y flux dcriture :
Ouvrir le flux
Tant quil ya des donnes
crire les donnes
Fermer le flux
Y flux de lecture :
Ouvrir le flux
Tant quil ya des donnes
Lire les donnes
Fermer le flux
4.2 LES FLUX STANDARD

Linterfaage entre lapplication Java et le systme dexploitation, qui est une entit externe lapplication, met en
uvre des flux dentres/sorties.
Comme ces flux servent de manire rcurrente lors de lutilisation de la machine, on les appelle flux standard 1 ou
flux dentres/sorties standard. Ces flux sont grs par la classe java.lang.System :
Y entre standard : par dfaut le clavier, utilise un flux gr par lobjet System.in (stdin) ;
Y sortie standard : par dfaut la console (lcran), utilise un flux gr par lobjet System.out (stdout) ;
Y erreur standard : par dfaut est aussi la console, utilise un flux gr par lobjet System.err (stderr).
Lobjet System.in gre donc un flux dentre ; il sagit en fait dune instance de la classe abstraite InputStream.
Les objets System.out et System.err grent eux des flux de sortie ; il sagit en fait dinstances dune sous-classe
de la classe abstraite OutputStream.
4.3 GESTION DES FLUX

En Java, on peut distinguer 4 types de flux :
Y flux doctets : pour lire ou crire octet par octet ;
Y flux de donnes : pour lire ou crire des donnes de type primitif (entier, flottant, boolen, chane, etc.) ;
Y flux de caractres : pour lire ou crire des caractres, similaire au flux doctets en utilisant des caractres
Unicode (codage sur 2 octets (16 bits)) ;
Y flux dobjets : pour lire ou crire des objets.
Les classes permettant de grer ces diffrents flux dentres/sorties sont regroups dans le paquetage java.io 2.
4.3.1
Les flux doctets
Pour grer des flux doctets, on dispose dun ensemble de classes drivant des 2 classes abstraites suivantes :
Y classe InputStream : dfinition des principales mthodes de gestion de flux de lecture doctets ;
Y classe OutputStream : dfinition des principales mthodes de gestion de flux dcriture doctets.
Ces 2 classes tant abstraites, elles ne peuvent donc pas tre instancies. Elles permettent de prciser des
comportements gnraux pour les classes drives.
InputStream
FileInputStream
1
2
ObjectInputStream
ByteArrayInputStream
Les flux standards sont normment utiliss dans le monde Unix, au niveau du shell.
lexception des classes de gestion de flux sur sockets, qui font partie du paquetage java.net.
29 / 59
1.1.0.1 07/05/2010
OutputStream
FileOutputStream
ObjectOutputStream
ByteArrayOutputStream
Figure 4.2 : classes de gestion de flux doctets
Ces classes manipulent des octets, cest--dire des donnes non formates ; elles ne sont donc pas forcment des
plus pratiques utiliser dans tous les cas.
4.3.2
Les flux de caractres
Reposant sur les mmes principes que les classes InputStream et OutputStream, on dispose des classes Reader
et Writer qui ralisent des flux de caractres.
Ce sont aussi des classes abstraites qui servent donc de modles pour lensemble des classes de gestion de flux de
caractres.
Reader
InputStreamReader
StringReader
CharArrayReader
BufferedReader
CharArrayWriter
BufferedWriter
FileReader
Writer
OutputStreamWriter
StringWriter
FileWriter
Figure 4.3 : classes de gestion de flux de caractres
4.4 GESTION DES FLUX SUR FICHIER TEXTE

4.4.1
Enregistrement des donnes
Pour enregistrer des donnes, il faut dabord dterminer si lon doit manipuler des octets ou des caractres ; ce qui
revient choisir entre les classes OutputStream et Writer.
On utilise ensuite la classe hrite correspondante qui permet de grer des flux sur fichier : FileOutputStream ou
FileWriter.
FileOutputStream / FileWriter
programme
octets /
caractres
fichier
Figure 4.4 : flux de sortie sur fichier
30 / 59
1.1.0.1 07/05/2010
On cre alors le flux de sortie en instanciant un objet de la classe et en prcisant en paramtre le nom du fichier
destination du flux.
Ex. : FileWriter outFile = new FileWriter("fichier.txt");
On peut ensuite crire des donnes dans le flux grce la mthode write() de la classe utilise :
Y FileOutputStream : write(byte[]) ;
Y FileWriter : write(String).
Ex. : outFile.write("ceci est un test");
Une fois toutes les donnes dsires crites dans le flux (/enregistres dans le fichier), on referme le flux en utilisant
la mthode close(), prsente dans chacune des classes OutputStream et FileWriter.
Ex. : outFile.close();
Lors du travail avec des fichiers, de nombreuses erreurs peuvent survenir (fichier protg en criture, plus despace
disque, pas de droit dcriture dans le rpertoire, ) ; il est donc ncessaire dintercepter toute erreur ventuelle
dentres/sorties (IOException).
Ex. :
try {
FileWriter outFile = new FileWriter("fichier.txt"); // ouverture du flux
outFile.write("ceci est un test"); // criture dans le flux
outFile.close(); // fermeture du flux
}
catch (IOException e) { // traitement de l'exception du type IO
System.out.println("erreur criture fichier");
}
4.4.2
Lecture des donnes
Pour lire des donnes, il faut dabord savoir si lon doit manipuler des octets (InputStream) ou des caractres
(Reader). On utilise ensuite la classe hrite correspondante qui permet de grer des flux sur fichier :
FileInputStream ou FileReader.
FileInputStream / FileReader
fichier
octets /
caractres
programme
Figure 4.5 : flux dentre sur fichier
On cre alors le flux dentre en instanciant un objet de la classe et en prcisant en paramtre le nom du fichier
source du flux.
Ex. : FileReader inFile = new FileReader("fichier.txt");
On peut ensuite lire les donnes partir du flux grce la mthode read() de la classe utilise :
Y FileInputStream : read(byte[]) ;
Y FileReader : read(char[], int, int).
Ex. : char[] texte = new char[100];
int debut = 200;

inFile.read(texte, debut, texte.length);
Une fois toutes les donnes lues partir du flux, on referme le flux en utilisant la mthode close(), prsente dans
chacune des classes InputStream et FileReader.
Ex. : inFile.close();
31 / 59
1.1.0.1 07/05/2010
L encore, de nombreuses erreurs peuvent survenir (fichier illisible, protg en lecture, ) ; il est donc ncessaire
dintercepter toute erreur ventuelle dentres/sorties (IOException).
Ex. :
try {
char[] texte = new char[100]; // tableau pour stocker la lecture
int debut = 200; // indice de dbut de lecture
FileReader inFile = new FileReader("fichier.txt"); // ouverture du flux
inFile.read(texte, debut, texte.length); // lecture de 100 caractres
inFile.close(); // fermeture du flux
}
catch (IOException e) { // traitement de l'exception du type IO
System.out.println("erreur lecture fichier");
}
4.4.3
Cas pratique
Les classes FileOutputStream, FileWriter, FileInputStream et FileReader manipulent les donnes

individuellement ; ce qui a pour effet deffectuer dincessantes critures ou lectures sur le fichier. Il est donc plus
judicieux de regrouper les donnes puis deffectuer une criture dans le fichier en une seule fois, ou bien deffectuer
une lecture complte du fichier puis den extraire le contenu 1.
BufferedOutputStream,
BufferedWriter,
Pour
effectuer
cela,
on
dispose
des
classes
BufferedInputStream et BufferedReader qui permettent doprer des critures ou des lectures par lots,
notamment bases sur des lignes de texte complte.
Ces classes ne permettent pas de grer un flux directement et doivent en fait tre rattaches un flux sur fichier
prexistant 2.
BufferedOutputStream /
BufferedWriter
programme
buffer octets /
caractres
FileInputStream /
FileReader
fichier
octets /
caractres
FileOutputStream /
FileWriter
octets /
caractres
fichier
BufferedInputStream /
BufferedReader
buffer octets /
caractres
programme
Figure 4.6 : buffer de flux dentre/sortie sur fichier texte
Mthodes de la classe BufferedWriter :

Y BufferedWriter(Writer) : constructeur partir dun flux de sortie de caractres ;
Y write(String) : criture dune chane dans le flux ;
Y newLine() : criture du caractre fin de ligne ;
Y close() : fermeture du flux.
Mthodes de la classe BufferedReader :
Y BufferedReader(Reader) : constructeur partir dun flux dentre de caractres ;
Y String readLine() : lecture dune ligne complte (jusquau caractre fin de ligne) ;
Y close() : fermeture du flux.
En ralit, la lecture ou lcriture ne se fait pas quen une seule fois ; le buffer utilis pour lire ou crire dans le fichier a une taille prdfinie
(512 octets par dfaut) ; nanmoins lutilisation dun tel procd rduit considrablement le nombre daccs au fichier.
On dit quon ralise alors un chanage de flux.
32 / 59
1.1.0.1 07/05/2010
Ex. :
Ecriture.java
try {
FileWriter outFile = new FileWriter("fichier.txt"); // ouverture du flux
BufferedWriter out = new BufferedWriter(outFile); // chanage du flux
out.write("ligne 1"); // criture dans le flux
out.newLine(); // insertion d'un saut de ligne
out.write("ligne 2"); // criture dans le flux
out.close(); // fermeture du flux
}
catch (IOException e) {
System.out.println("erreur criture fichier");
}
Lecture.java
try {
String texte;
FileReader inFile = new FileReader("fichier.txt"); // ouverture du flux
BufferedReader in = new BufferedReader(inFile); // chanage du flux
while ((texte = in.readLine()) != null) // lecture ligne par ligne
System.out.println(texte);
in.close(); // fermeture du flux
}
System.out.println("erreur lecture fichier");
}
4.5 GESTION DES FLUX DOBJETS

4.5.1
La srialisation
On appelle srialisation la gestion de flux qui lit ou crit des objets 1. Un flux dobjets est aussi un flux de donnes
(soit donc format), mais adapt aux objets.
Les informations lues ou crites sont transfres comme des sries doctets, do les termes de srialisation (criture
dun objet) et dsrialisation (lecture dun objet).
Pour pouvoir (d)srialiser un objet, il faut que celui-ci implmente linterface Serializable (paquetage
java.io) ; cette interface ne dfinit par ailleurs aucune mthode, lobjet na donc pas tre modifi pour pouvoir tre
lu ou crit dans un flux.
Pour lire ou crire des objets, on utilise alors les classes ObjectInputStream et ObjectOutputStream qui
proposent respectivement les mthodes readObject() et writeObject().
Ex. : Lecture/criture dun objet dans un fichier ; soit lobjet Etudiant suivant :
Etudiant.java
class Etudiant implements java.io.Serializable // peut tre gre par un flux
{
String nom;
float moyenne;
public Etudiant(String sonnom, float samoyenne) // constructeur
{
this.nom = sonnom;
this.moyenne = samoyenne;
}
}
Au sens POO (Programmation Oriente Objet).

33 / 59
1.1.0.1 07/05/2010
ObjectOutputStream
FileOutputStream
objet
programme
FileInputStream
octets
ObjectInputStream
octets
fichier
fichier
objet
programme
Figure 4.7 : exemple de srialisation sur fichier
Serialisation.java
...
try {
FileOutputStream fos = new FileOutputStream("obj.dat"); // ouverture du flux
ObjectOutputStream oos = new ObjectOutputStream(fos); // chanage du flux
Etudiant etud1 = new Etudiant("Grard",12f); // instanciation de l'objet
oos.writeObject(etud1); // criture de l'objet dans le flux (sauvegarde)
oos.close(); // fermeture du flux
}
System.out.println("erreur criture objet");
}
...
Deserialisation.java
...
try {
FileInputStream fis = new FileInputStream("obj.dat"); // ouverture du flux
ObjectInputStream ois = new ObjectInputStream(fis); // chanage du flux
Etudiant e1 = (Etudiant)ois.readObject(); // relecture de l'objet (cast)
ois.close(); // fermeture du flux
}
System.out.println("erreur lecture objet");
}
catch (ClassNotFoundException cnfe) {
System.out.println("erreur transtypage");
}
...
4.5.2
Persistance
On dit quun objet est persistant si son tat est conserv entre deux instances dune mme application ou
dapplications diffrentes. Le principe consiste sauvegarder ltat de lobjet, gnralement dans un fichier, pour
pouvoir reconstruire ultrieurement un objet identique.
Le mcanisme de srialisation est parfaitement adapt la persistance dun objet. On peut ainsi sauvegarder dans un
fichier ltat dun objet en mmoire lors de la fermeture dune application ; cet tat est ensuite relu lors du lancement
de lapplication 1.
Ex. : Sauvegarde des paramtres de la fentre graphique.
Pensez la mise en veille prolonge propose par Windows

34 / 59
1.1.0.1 07/05/2010
ParametresIHM.java
import java.awt.*;
class ParametresIHM implements java.io.Serializable
{
Point position;
Dimension dimensions;
public ParametresIHM(Point pos, Dimension dims)
{
this.position = pos;
this.dimensions = dims;
}
}
Cadre.java
Import java.io.*;
class Cadre extends Jframe
{
ParametresIHM params;
// constructeur rcuprant les paramtres sauvegards
// si leur valeur ne peut tre rcupre, alors des valeurs par dfaut
// sont attribues
public Cadre()
{
// relecture des paramtres partir du fichier de sauvegarde
try {
FileInputStream fis = new FileInputStream("params.dat");
ObjectInputStream ois = new ObjectInputStream(fis);
params = (ParametresIHM)ois.readObject();
ois.close();
}
catch (IOException e) { // affectation de valeurs par dfaut en cas d'erreur
params = new ParametresIHM(new Point(0,0), new Dimension(50,50));
}
catch (ClassNotFoundException cnfe) {
System.out.println("Erreur: transtypage");
}
...
// utilisation des valeurs des paramtres rcupres
this.setLocation(params.position);
this.setSize(params.dimensions);
}
...
// sauvegarde de la valeur des paramtres de la fentre avant
// fermeture de l'application
void this_windowClosing(WindowEvent e)
{
// rcupration des valeurs courantes des paramtres
params.position = this.getLocation();
params.dimensions = this.getSize();
35 / 59
1.1.0.1 07/05/2010
// sauvegarde des paramtres dans le fichier de sauvegarde

try {
FileOutputStream fos = new FileOutputStream("params.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(params);
oos.close();
}
catch (IOException ioe) {
System.out.println("Erreur: cration fichier paramtres");
}
System.exit(0);
}
}
36 / 59
1.1.0.1 07/05/2010
5 LES APPLETS
5.1 GNRALITS
5.1.1
Dfinition
On appelle applet une application graphique qui sexcute lintrieur de la fentre dun navigateur internet.
Pour crer une applet, il faut driver de la classe Applet contenue dans le package java.applet :
package MonPackage;
import java.applet.*; // importation du paquetage applet
public class Applet1 extends Applet // nouvel applet
{
...
}
5.1.2
Fonctionnement
Lorsque le navigateur charge une page HTML contenant une applet, il charge lapplet elle-mme, puis instancie un
objet de la classe principale (celle drive de la classe Applet). Cest alors la fentre du navigateur qui sert de
conteneur graphique lapplet.
Une applet sexcute donc sous le contrle du navigateur, et non pas sous celui de la machine virtuelle Java 1.
Une applet tant une forme dapplication graphique (fentre graphique + console), la partie graphique saffiche dans
la fentre du navigateur alors que la partie texte saffiche dans la console 2.
5.2 CYCLE DE VIE

Une applet suit un cycle de vie, cest--dire que son excution suit une logique bien prcise, dcrite par le schma
suivant :
En ralit, tout navigateur capable dexcuter une applet fait appel une machine virtuelle Java, quelle soit intgre sous forme de plugin (et
souvent propritaire de fait, ex. : Internet Explorer), ou bien installe sur le systme comme une JVM classique (ex. : Opera).
Par dfaut, la console est gnralement invisible, mais elle peut tre affiche par simple paramtrage du navigateur.
37 / 59
1.1.0.1 07/05/2010
paint()
(re)dessiner
lapplet
start()
initialisation
de lapplet
(re)dmarrage
de lapplet
init()
stop()
start()
instanciation dun
objet Applet
constructeur()
applet mise
en pause
arrt de
lapplet
destroy()
Figure 5.1 : cycle de vie dune applet
Voici le dtail de ce cycle de vie :

Y constructeur() : appele par la machine virtuelle du navigateur au tout dbut (mthode induite
inaccessible au niveau du code) ;
Y init() : appele la cration de lapplet ;
Y start() : appele la suite de init(), et appele nouveau chaque fois que lapplet a t mise en pause
par stop() ;
Y stop() : appele lorsque le navigateur est iconifi, lorsquune autre page est charge dans le navigateur, ou
lorsque le navigateur passe en arrire-plan (du point de vue des fentres du systme dexploitation) ;
Y destroy() : appele lorsque lon ferme compltement la page ;
Y paint() : appele chaque fois quil faut (re)dessiner lapplet dans le navigateur (au tout dbut, et chaque
fois que la page du navigateur repasse au premier plan).
Ces mthodes sont hrites de la classe Applet, mais elles peuvent tre surcharges si besoin est.
Si on veut que lapplet puisse aussi tre excute en dehors dun navigateur web, comme une simple application
graphique, il suffit dcrire la mthode main() qui sera appele lors dune excution classique 1.
5.3 EXCUTION DUNE APPLET

5.3.1
Principes
Une fois lapplet mise au point, notamment en surchargeant les diverses mthodes hrites (init(), start(), etc.)
en fonction de ses besoins, il faut permettre de charger lapplet dans le navigateur pour quelle puisse tre excute.
Ceci ne peut pas tre fait directement, et lapplet ne peut tre charge dans le navigateur que via une page HTML. Il
faut insrer lapplet dans le code HTML, grce lutilisation de la balise <applet>.
Ex. :
Bonjour.java
package MonApplet;
import java.applet.*;
public class Bonjour extends Applet
{
public void paint(java.awt.Graphics g)
{
g.drawString("bonjour",100,100);
}
}
1
La mthode main() est utile aussi pour lcriture et la mise au point de lapplet elle-mme en phase de dveloppement.
38 / 59
1.1.0.1 07/05/2010
Applet.html
<html>
<head></head>
<body>
<applet code="MonApplet.bonjour.class" width=400 height=200>
</applet>
</body>
</html>
5.3.2
La balise HTML <applet>
La forme gnrale de lutilisation de la balise <applet> est la suivante :

<applet
code = nom_fichier_.class (incluant le nom du paquetage)
width = largeur_en_pixels
height = hauteur_en_pixels
>
message affich par les navigateurs incapables de grer la balise applet
</applet>
Le nom du fichier .class doit tre complet, et doit donc contenir le nom du package (avec son arborescence).
Les 3 attributs de balise code=, width= et height= sont obligatoires. Il existe par contre des attributs optionnels :
Y codebase = adresse_base_URL : prcise le chemin du fichier .class de lapplet (par dfaut cest le
chemin du document HTML qui est utilis) ;
Y alt = message : affiche un message pour les navigateurs comprenant la balise <applet> mais tant dans
limpossibilit dexcuter lapplet (problme de droits par exemple) ;
Y name = instance : prcise le nom de linstance dune autre applet de la page HTML qui peut alors tre
utilis pour tablir une communication entre les 2 applets ;
Y archive = nom_archive_jar : prcise le nom de larchive charger qui contient le fichier .class
mentionn par lattribut code= ;
Y align = left / right / top / bottom ;
Y hspace = espace_horizontal_en_pixels ;
Y vspace = espace_vertical_en_pixels.
Si on veut passer des paramtres lapplet, il faut utiliser pour cela la balise <param> suivant la syntaxe :
<param name = nom_parametre value = valeur_parametre> que lon insre entre les balises <applet>.
On rcupre alors la valeur valeur_parametre du paramtre nom_parametre dans le code de lapplet sous
forme de chane en utilisant la mthode getParameter() hrite de la classe Applet suivant la syntaxe :
String str = this.getParameter("nom_parametre");.
5.3.3
Exemple rcapitulatif
Soit une applet laquelle on va passer deux paramtres que lon va afficher lcran (en les dessinant ) :
Exemple1.java
package MonExempleApplet;
import java.awt.Graphics;
public class Exemple1 extends java.applet.Applet
{
String s1, s2;
public void init()
{
s1 = this.getParameter("chaine1");
s2 = this.getParameter("chaine2");
}
39 / 59
1.1.0.1 07/05/2010
public void paint(Graphics g)

{
g.drawString(s1 + "\n" + s2 + "\n",50,50);
}
}
Applet.html
<html>
<head>
<title>exemple Applet</title>
</head>
<body>
<h1>exemple Applet</h1>
<applet
code="MonExempleApplet.Exemple1.class"
width=200
height=100
alt="votre navigateur ne peut pas excuter cette applet"
align="top"
vspace=10
hspace=10
>
<param name="chaine1" value="Bonjour">
<param name="chaine2" value=" tous">
votre navigateur ne peut pas excuter d'applets Java
</applet>
</body>
</html>
5.4 EMPAQUETAGE DES APPLETS

Une applet est au dpart pleinement destine tre excute dans un cadre client/serveur et a pour porte principale
internet. Par consquent la question de la taille de lapplet est primordiale 1.
Pour rduire le temps de chargement, on peut empaqueter les fichiers .class ncessaires lexcution de lapplet en
les archivant dans un fichier de type .jar 2.
Il faut alors prciser le nom de larchive charger en utilisant lattribut archive= de la balise <applet>.
Ex. : <applet
code="MonApplet.bonjour.class"
width=200
height=100
archive="bonjour.jar"
>
</applet>
Larchivage sopre en ligne de commande o on utilise la commande jar, qui suit une syntaxe trs proche de la
commande darchivage tar 3. Cependant la commande jar fait plus quun simple archivage ; en effet elle rajoute un
fichier appel fichier manifest qui contient des informations sur larchive .jar cre.
Lors de larchivage sous forme darchive jar, il convient de respecter scrupuleusement larborescence mettant en
avant le nom du paquetage.
Ex. : Pour empaqueter tous les fichiers .class du sous-rpertoire MonApplet/ dans larchive bonjour.jar :
jar cfv bonjour.jar MonApplet/*.class
1
2
3
Comprendre : la taille en octets du fichier ou des fichiers .class constituant lapplet.

Jar : Java ARchive format de compression identique au format zip, mme si un fichier .jar et un fichier .zip restent diffrents.
La commande tar, issue du monde Unix, permet darchiver (pas de compresser) des fichiers.
40 / 59
1.1.0.1 07/05/2010
5.5 APPLETS ET SCURIT

Lexcution dune applet est une opration sensible puisquune machine cliente excute un programme provenant
dune autre machine (le serveur qui hberge lapplet). Lenvironnement dexcution est donc trs scuris afin de
protger la machine cliente des erreurs ou des malversations dexcution de lapplet.
En consquence, une applet naccde qu un nombre restreint de ressources de la machine cliente. La dfinition de
ces ressources accessibles constitue la politique de scurit de lexcution dapplets Java, laquelle est dfinie par le
navigateur, et peut donc ainsi tre paramtre par lutilisateur.
Cependant, certains lments de scurit sont gnralement communs ; parmi ceux-ci, on notera en gnral quune
applet ne peut pas :
Y charger une bibliothque ;
1
Y dfinir de mthode native ;
Y avoir accs au systme de fichiers dune quelconque manire ;
Y tablir une connexion autre quavec la machine hbergeant lapplet ;
Y excuter un programme ;
Y accder aux proprits du systme ;
Y fermer linterprteur Java ;
Y lancer une impression ;
Y etc.
Contrairement aux ides reues, lenvironnement dexcution des applets est donc extrmement scuris 2.
1
2
Mthode compile spcifiquement pour le type de processeur utilis et ntant donc pas excute par la JVM.
En comparaison, les composants ActiveX (dvelopps par Microsoft) sont nettement moins scuriss et sont susceptibles dtre gnrateur de
bugs, vecteur de trojans, etc. (voir http://www.microsoft.com/france/securite).
41 / 59
1.1.0.1 07/05/2010
6 LE MULTITHREADING
6.1 INTRODUCTION
Les ordinateurs actuels utilisent des systmes dexploitation dits multitches 1, cest--dire que lon peut excuter
plusieurs actions en mme temps : diter un fichier texte, crire des donnes sur le disque dur, effectuer des calculs
mathmatiques, etc.
Chacune de ces actions est mise en uvre par une application stocke en mmoire morte 2, et qui est charge en
mmoire vive 3 lors de son excution ; lexcution dun programme est appele tche ou processus.
En ralit, ces tches ne sont pas excutes en mme temps. En effet, un processeur ne peut grer quune seule tche
la fois un instant t. En revanche, chaque tche pouvant tre dcompose en une liste de traitements successifs, le
processeur peut sinterrompre entre deux traitements dune mme tche, et reprendre une autre tche au niveau du
traitement o il stait prcdemment interrompu 4.
Le processeur se partage ainsi entre ces diffrentes tches, en passant successivement dun traitement un autre
traitement, dune manire rpte et trs rapide : lutilisateur a ainsi limpression que plusieurs tches sexcutent en
mme temps 5 car les traitements dcomposant chacune des tches voluent en parallle ; on parle alors dexcution
pseudo-parallle 6.
monotche
temps
p1 sexcute jusquau bout
p2 sexcute jusquau bout
temps
mu ltitches
p1
p2
p1 en pause
reprise p1
reprise p2
p2 en pause
p1 en pause
reprise p2
Figure 6.1 : comparaison de lexcution de deux processus en monotche et multitches
1
2
3
4
5
6
Le premier OS multitches est UNIX, cr en 1969 par Ken Thompson ; chez Microsoft, a commence en 1993 avec Windows NT 3.1.
Par mmoire morte (=ROM), on entend tout support dinformations non volatile (disque dur, disquette, cdrom, cl usb, etc.).
Par mmoire vive, on entend tout support dinformations volatile (RAM, mmoire cache, etc.).
On parle l de multitches premptif, cest--dire que le partage du temps processeur entre les tches est gr par le systme dexploitation ;
cette notion soppose au multitches coopratif dans lequel ce sont les tches elle-mme qui se rpartissent le temps processeur.
On pourrait faire lanalogie avec le cinma, o une succession trs rapide de photos renvoie une impression de mouvement.
Pseudo-parallle, car les excutions ne se font pas rellement en parallle ; il faudrait en effet disposer de plusieurs processeurs pour cela.
42 / 59
1.1.0.1 07/05/2010
6.2 DFINITIONS
Dans le principe, le multithreading est identique au multitches 1, ceci prs que cest le processus lui-mme qui
est dcoup en sous-traitements parallles, appels threads 2, permettant ainsi au processeur de se partager entre ces
diffrents traitements.
Cependant, la diffrence du multitches, pour que le processeur gre diffrents threads, chaque application doit
avoir t dveloppe dans une optique multithreads.
Les threads dun mme processus sont internes ce processus et partagent ainsi un mme espace mmoire, un mme
code, ainsi que les mmes ressources.
multitches
processus 1
espace
mmoire p1
processus 2
ressources
p1
espace
mmoire p2
code p1
ressources
p2
code p2
processeur
multithreads
processus 1
thread 1a
espace
mmoire p1a
espace
mmoire p1
ressources
p1
code p1
ressources p1a
thread 1b
espace
mmoire p1b
ressources p1b
code p1a
code p1b
processeur
Figure 6.2 : comparaison entre multitches et multithreading
1
2
Un systme dexploitation multithreads est aussi multitches.

Ou processus lgers, ou fils dexcution (fil(s) dexcution).
43 / 59
1.1.0.1 07/05/2010
6.3 IMPLMENTATION
6.3.1
La classe Thread
Pour crer un thread, il faut crire une classe qui drive de la classe Thread, contenue dans le paquetage
java.lang. On hrite ainsi de toutes les mthodes ncessaires la gestion du thread.
Le point dentre du thread est la mthode run() 1 ; celle-ci doit donc dfinir les actions raliser par ce nouveau
processus.
Pour lancer le thread au niveau du systme, et permettre ainsi son excution en parallle du reste de lapplication, il
faut appeler la mthode hrite start(), laquelle se charge alors dappeler implicitement la mthode run().
Ex. : Une application qui utilise un thread.
MonThread.java
package ExempleThread;
public class MaClasse extends Thread // nouveau thread
{
public void run() // surcharge de la mthode run()
{
...
}
...
}
Application.java
public class Application
{
...
{
MaClasse th1 = new MaClasse(); // instanciation d'un thread
th1.start(); // lancement du thread
...
}
}
Une mme application peut tre dcompose en autant de threads quil en ait besoin 2.
Ex. : Une application qui utilise 2 threads (donc 3 excutions pseudo-parallles).
ThreadA.java
public class ThreadA extends Thread
{
public void run()
{
while (true)
System.out.println("A");
}
}
1
2
Et peut donc tre considre comme lquivalent de la mthode main() du thread.

La gestion des threads est toujours coteuse en ressources processeur (sans compter les problmes de synchronisation et daccs concurrents),
il convient donc de crer des threads uniquement lorsque lapplication le ncessite.
44 / 59
1.1.0.1 07/05/2010
ThreadB.java
public class ThreadB extends Thread
{
public void run()
{
while (true)
System.out.println("B");
}
}
Application.java
{
...
{
ThreadA th1 = new ThreadA();
ThreadB th2 = new ThreadB();
th1.start();
th2.start();
...
}
}
6.3.2
Linterface Runnable
Linconvnient de la mthode prcdente (drivation de la classe Thread), est que, comme lhritage multiple est
impossible en Java, on ne peut pas crer une classe multithreads qui drive dune autre classe quelconque. Pour pallier
ce problme, il faut utiliser linterface Runnable du paquetage java.lang.
La classe devant offrir le service de pouvoir tre excute en tant que thread, doit alors implmenter linterface
Runnable, qui dfinit le prototype de la mthode run(). Toute instance dune classe qui implmente cette interface
devient ainsi un thread potentiel.

Ex. :
MonThread.java
public class MaClasse implements Runnable // classe pouvant tre "threade"
{
public void run() // implmentation de la mthode run()
{
...
}
...
}
45 / 59
1.1.0.1 07/05/2010
Application.java
{
...
{
MaClasse mc1 = new MaClasse(); // instanciation d'un objet "runnable"
Thread th1 = new Thread(mc1); // cration dun thread sur l'instance
th1.start(); // lancement du thread
...
}
}
On peut aussi dcider de dmarrer directement le thread dans le constructeur-mme de la classe ; une simple
instanciation suffit alors pour lancer le thread.
Ex. :
MonThread.java
public class MaClasse implements Runnable // classe pouvant tre "threade"
{
public MaClasse()
{
(new Thread(this)).start();
}
public void run() // implmentation de la mthode run()
{
...
}
...
}
Application.java
{
...
{
MaClasse mc1 = new MaClasse(); // instanciation d'un objet "runnable"
...
}
}
Nb : Linconvnient de cette dernire solution, est quen terme de r-utilisabilit, il faut tre certain que la classe,
dans sa dfinition, adhre totalement une excution parallle 1.
6.4 GESTION DES THREADS

6.4.1
Cycle de vie
En ralit, mme si on ne cre pas de thread, toute application Java contient toujours au moins un thread, appel
thread principal, qui est en fait le processus correspondant lexcution de lapplication. Les autres threads ventuels
sont appels alors threads secondaires.
1
Par exemple, un composant de type horloge permettant dafficher lheure dans une application devra toujours tre excut en parallle du
reste de lapplication, la solution est donc bien approprie ici.
46 / 59
1.1.0.1 07/05/2010
Toute excution de code Java est donc apparente un thread ; ainsi, une application prend fin lorsque tous ses
threads sont termins.
Un thread suit un cycle de vie, cest--dire que son excution suit une logique bien prcise, dcrite par le schma
suivant :
cr
(initialis)
constructeur()
start()
stop()
run() termin
arrt
(mort)
actif
(excutable)
excut
sleep() termin
resume()
notify()
stop()
endormi
sleep()
suspend()
wait()
Figure 6.3 : cycle de vie dun thread
Voici le dtail de ce cycle de vie et des mthodes affrentes :

Y constructeur() : construit une instance du thread ;
Y start() : dmarre le thread en excution pseudo-parallle, et appelle la mthode run() ;
Y stop() : stoppe lexcution du thread de manire dfinitive ;
Y sleep() : place le thread dans ltat endormi pendant une dure dtermine ;
Y suspend() : suspend lexcution du thread en le plaant dans ltat endormi ;
Y resume() : reprend lexcution dun thread endormi ;
Y wait() : place le thread dans un tat endormi, en attente dun signal provenant dun autre thread avec la
mthode notify() ou notifyAll() ;
Y notify() : permet un thread endormi avec la mthode wait() de reprendre son excution.
6.4.2
Autres outils de gestion
Il est possible dassigner une priorit un thread en utilisant la mthode setPriority() 1.

Un thread peut tre dfini comme tant un thread daemon, qui sera alors termin automatiquement si tous les threads
normaux sont termins. Pour cela on utilise la mthode setDaemon() 2.
Afin de faciliter la gestion des threads, il est possible de runir plusieurs threads au sein dun groupe de thread, avec
la classe ThreadGroup. On peut alors grer tous les threads de ce groupe en faisant appel des mthodes reprises de
la classe Thread : suspend(), resume(), stop(), etc.
Le dveloppement dune application multithreads soulve de nombreuses questions dont il faut imprativement tenir
compte :
Y dfinition de priorits et de dpendances (priorit, thread daemon) ;
Y exclusion mutuelle pour laccs une ressource partage (verrou, smaphore, etc.).
Y synchronisation entre threads (mthodes wait(), notify(), notifyAll()) ;
1
2
Dix niveaux de priorits existent en tout, inclus dans la plage [1 ; 10] (1 : MIN_PRIORITY, 5 : NORM_PRIORITY, 10 : MAX_PRIORITY).
En gnral, un thread accdant une ressource partage est positionn comme un thread daemon, afin dviter le blocage de laccs la
ressource en cas darrt ou de sortie anormale de lapplication lors dun dysfonctionnement.
47 / 59
1.1.0.1 07/05/2010
7 LES SOCKETS
7.1 INTRODUCTION
Un socket est un moyen de communication de type point--point entre deux applications diffrentes, sexcutant
gnralement chacune sur un ordinateur diffrent 1. Bas sur le protocole TCP, la fiabilit de la communication est
donc ainsi assure, tout comme la rception des donnes dans lordre de lmission.
Dans une communication par socket, on a donc une application qui est serveur, et lautre qui est cliente :
Y serveur : attend les connexions des clients, et reoit les donnes des clients, ou bien leur en transmet ;
Y client : initie une communication avec le serveur, afin de transmettre des donnes, ou bien den recevoir.
La communication par socket utilise les flux pour mettre ou recevoir les donnes.
client
serveur
connexion
adresse IP :
port :
en attente de
connexion
Figure 7.1 : communication client/serveur par socket
Les flux tant unidirectionnels, il faut crer deux flux distincts, la fois au niveau du serveur et du client, pour
mettre et recevoir des donnes 2. Si lon a uniquement besoin dmettre des donnes dans un seul sens, alors un seul
flux suffit.
Un socket utilise la notion de port de connexion du protocole TCP afin de permettre dautres communications
dtre tablies sur la mme machine ; ce port correspond un nombre entier cod sur 16 bits.
1
2
Il est cependant tout fait possible de faire communiquer 2 applications excutes sur le mme ordinateur en utilisant un socket.
Un flux en criture au niveau du serveur correspondant un flux en lecture au niveau de client, et vice-versa.
48 / 59
1.1.0.1 07/05/2010
Les ports 0 1023 sont rservs par convention 1 (appels well known ports 2) ; les ports 1024 49151 sont
enregistrs (registered ports 3) ; les ports 49152 65535 sont les ports publics et dynamiques.
7.2 IMPLMENTATION
Toutes les classes et mthodes ncessaires la gestion des sockets font partie du paquetage java.net. Une fois la
communication tablie, on utilise des flux, donc des classes du paquetage java.io.
7.2.1
La classe Socket
Pour crer un socket, il faut utiliser la classe Socket, dont voici les principales mthodes utiles :
Y Socket(InetAddress adresseIpDistante, int portDistant) : cre un nouveau socket connect
au serveur dadresse IP adresseIpDistante sur le port portDistant ;
Y Socket(String nomDistant, int portDistant) : cre un nouveau socket connect au serveur dont
le nom DNS est nomDistant sur le port portDistant ;
Y getInputStream() : InputStream : renvoie un flux de lecture associ au socket ;
Y getOutputStream() : OutputStream : renvoie un flux dcriture associ au socket ;
Y close() : void : ferme le socket.
7.2.2
Serveur socket
Le serveur socket permet de fournir un service accessible par toute machine sur le rseau. Il attend donc les
connexions des clients sur un port prcis, et rpond aux connexions inities sur ce port par les clients. Cette
rponse se traduit par lmission et/ou la rception de donnes en utilisant des flux.
Le principe du serveur est le suivant :
Y cration du serveur socket sur un port prcis ;
Y boucle sans fin ou contrle.
` attente de connexion (fonction bloquante) ;
` rcupration du socket cr par le serveur socket suite une connexion ;
` rcupration des flux dentre et/ou de sortie associs au socket ;
` lecture et/ou criture partir des flux ;
` fermer les flux ;
` fermer le socket.
Pour crer un serveur socket, on utilise la classe ServerSocket ; parmi ses mthodes, on retiendra :
Y ServerSocket(int portLocal) : cre un nouveau serveur socket en coute sur le port portLocal ;
Y accept() : Socket : attend une connexion, et une fois celle-ci tablie, renvoie le nouveau socket associ ;
Y close() : void : ferme le serveur socket.
Ex. : Un serveur socket en coute sur le port 7474.
MonServeur.java
package ExempleSocket;
import java.net.*;
import java.io.*;
public class MonServeur
{
private final int srvPort = 7474; // port local dcoute
private ServerSocket srvSock = null;
Cest lorganisme international IANA (Internet Assign Numbers Authority), charg de coordonner un certain nombre de standards sur
linternet (adressage IP, noms de domaines, etc.), qui gre ces spcifications (http://www.iana.org/assignments/port-numbers).
Exemples : ports standards multi-plateformes (FTP : 20-21, HTTP : 80, SMTP : 25, POP3 : 110, HTTPS : 443, ...), ou ports reconnus comme
tels (NetBios : 137-139, partage de fichiers et dimprimante Windows / SaMBa : 445, )
Gnralement utiliss temporairement par le systme dexploitation (aussi utilisables pour le domaine priv).
49 / 59
1.1.0.1 07/05/2010
public MonServeur() throws IOException

{
this.srvSock = new ServerSocket(this.srvPort); // instanciation du serveur
}
public void atWork() throws IOException
{
Socket sock = null;
String msg = null;
while (true) {
sock = this.srvSock.accept(); // attente d'une connexion
System.out.println("Connexion tablie");
InputStream is = sock.getInputStream(); // ouverture d'un flux d'entre
DataInputStream dis = new DataInputStream(is); // chanage du flux
msg = dis.readUTF(); // lecture du flux
System.out.println("Message reu: " + msg);
OutputStream os = sock.getOutputStream();// ouverture d'un flux de sortie
DataOutputStream dos = new DataOutputStream(os); // chanage du flux
dos.writeUTF("Message bien reu"); // criture dans le flux
System.out.println("Message envoy");
dis.close(); // fermeture du flux d'entre
dos.close(); // fermeture du flux de sortie
sock.close(); // fermeture du socket
}
}
{
try {
MonServeur srv = new MonServeur(); // instanciation d'un serveur socket
srv.atWork(); // lancement du serveur
}
System.out.println("erreur serveur");
}
}
}
7.2.3
Client socket
Le client socket se connecte un serveur bien prcis, connaissant son adresse IP, ou son nom DNS, et le port de
connexion. Une fois connect, il communique avec le serveur en utilisant des flux, ce qui permet dmettre ou de
recevoir des donnes.
Pour crer un client socket, il faut utiliser la classe Socket.
Ex. : Un client socket se connectant sur un serveur en coute sur le port 7474.
MonClient.java
import java.net.*;
import java.io.*;
public class MonClient
{
final static int portSrv = 7474; // port de connexion distant
public MonClient()
{
...
}
50 / 59
1.1.0.1 07/05/2010
public void receiveFrom(String ipSrv) throws IOException

{
Socket sock = new Socket(ipSrv,portSrv); // cration d'un socket et connexion
if (sock != null) {
OutputStream os = sock.getOutputStream(); // ouverture d'un flux de sortie
DataOutputStream dos = new DataOutputStream(os); // chanage du flux
dos.writeUTF("msg " + sock.getLocalPort()); // criture dans le flux
DataInputStream dis = new DataInputStream(is); // chanage du flux
System.out.println("rponse srv: " + dis.readUTF()); // lecture du flux
dos.close(); // fermeture du flux d'entre
}
}
{
try {
MonClient clt = new MonClient(); // instanciation du client
clt.receiveFrom("localhost"); // lancement du client
}
System.out.println("erreur client");
}
}
}
7.3 CAS PRATIQUE

Si on observe le fonctionnement du serveur socket, on se rend compte dune faiblesse dans son implmentation :
lorsquune connexion dun client a t initi, le serveur est alors dans lincapacit de rpondre dautres clients tant
que la communication avec le premier client nest pas termin. Il faudrait pouvoir grer plusieurs traitements en
parallle.
La solution est donc dutiliser un thread secondaire qui va soccuper de la communication avec le client, pendant
que le thread principal continue dtre lcoute. Lorsque le serveur reoit une connexion, il lance un thread
secondaire, puis se repositionne en coute 1.
Ex. : Un serveur socket multi-connexions en coute sur le port 7474.
MonServeur.java
import java.net.*;
import java.io.*;
public class MonServeur {
private final int srvPort = 7474; // port local d'coute
private ServerSocket srvSock = null;
public MonServeur() throws IOException
{
this.srvSock = new ServerSocket(this.srvPort); // instanciation du serveur
}
{
Socket sock = null;
Bien videmment, durant le laps de temps trs court o le thread principal lance le thread secondaire, un autre client peut ventuellement se
connecter. Ceci est palli car le serveur socket possde une file dattente, qui par dfaut est de 50 (nda : compulser les diffrentes formes du
constructeur de la classe ServerSocket pour plus de dtails).
51 / 59
1.1.0.1 07/05/2010
while (true) {
sock = this.srvSock.accept(); // attente d'une connexion
new ServeurWork(sock); // lancement de la communication avec le client
}
}
{
try {
MonServeur srv = new MonServeur(); // instanciation d'un serveur socket
srv.atWork(); // lancement du serveur
}
System.out.println("erreur serveur");
}
}
}
ServeurWork.java
import java.net.*;
import java.io.*;
public class ServeurWork implements Runnable // classe "threadable"
{
private Socket sock;
public ServeurWork(Socket sock)
{
this.sock = sock;
(new Thread(this)).start(); // dmarrage du thread
}
public void run()
{
String msg = null;
try {
DataInputStream dis = new DataInputStream(is);
msg = dis.readUTF(); // lecture du flux
System.out.println("Message reu: "+msg);
OutputStream os = sock.getOutputStream(); // ouverture d'un flux de sortie
DataOutputStream dos = new DataOutputStream(os);
dos.writeUTF("Message bien reu"); // criture dans le flux
dos.close(); // fermeture du flux de sortie
}
System.out.println("erreur serveur thread");
}
}
}
7.4 DTAILS SUR LA COMMUNICATION CLIENT-SERVEUR

Les diffrents changes dune communication client-serveur par socket peuvent tre rsums de la manire
suivante :
52 / 59
1.1.0.1 07/05/2010
MonServeur.java
{
Socket sock = null;
String msg = null;
while (true) {
sock = this.srvSock.accept();
InputStream is = sock.getInputStream();
msg = dis.readUTF();
System.out.println("Message reu: "+msg);
OutputStream os = sock.getOutputStream();
dos.writeUTF("Message bien reu");
dis.close();
dos.close();
sock.close();
}
}
MonClient.java
public void receiveFrom(String ipSrv) throws IOException
{
Socket sock = new Socket(ipSrv,portSrv);
if (sock!= null) {
OutputStream os = sock.getOutputStream();
dos.writeUTF("msg " + sock.getLocalPort());
InputStream is = sock.getInputStream();
System.out.println("rponse srv: " + dis.readUTF());
dos.close();
dis.close();
sock.close();
}
}
: Le serveur est en attente de connexion (la mthode accept() est bloquante) ; le client se connecte au
serveur lorsque quun objet socket client est instanci ; le serveur poursuit alors son excution.
: Le serveur veut lire des donnes mises par le client, en utilisant donc un flux dentre (lensemble des
mthodes du type read() des flux dentre sont bloquantes) ; le client envoie une donne au serveur, en
utilisant donc un flux de sortie (une mthode du type write()) ; la prsence de donnes dans le flux permet
alors au serveur de poursuivre son excution.
: Le client veut lire des donnes mises par le serveur ; le serveur envoie une donne au client via le flux ; le
client poursuit alors son excution.
53 / 59
1.1.0.1 07/05/2010
A MOTS-CLEFS DU LANGAGE JAVA

A.1 ORDRE ALPHABTIQUE
A
B
C
D
E
F
G
I
L
N
P
R
S
T
V
W
abstract
boolean
case
default
else
false
goto
if
long
native
package
return
short
this
void
while
assert
break
catch
do
extends
final
byte
char
double
class
const
finally
float
for
implements
import
instanceof
int
interface
new
private
null
protected
public
static
throw
volatile
strictfp
throws
super
transient
switch
true
synchronized
try
continue
Les mots-clefs sont rservs, donc inutilisables comme noms de classe, dinterface, mthode, attribut ou variable 1.
A.2 CATGORIES
A.2.1 Paquetages, classes, membres et interfaces
class
extends
implements
import
instanceof
interface
new
package
super
this
Dclaration dune classe.

Drivation dune classe pour une sous-classe, ou dune interface pour une sous-interface ;
hritage des membres publics et protgs.
Implmentation dune interface par une classe.
Importation dune classe ou dune bibliothque de classes (/paquetage).
Oprateur de test dappartenance dun objet une classe.
Dclaration dune interface.
Instanciation dun objet (rservation de lespace mmoire).
Dclaration dun nom de paquetage (pour regrouper diverses classes).
lintrieur dune classe, rfrence la super-classe dont elle drive.
lintrieur dune classe, rfrence lobjet de la classe elle-mme.
Mme si Java distingue la casse, il est dconseill dutiliser les mots-clef, mme avec une casse distincte.
54 / 59
1.1.0.1 07/05/2010
A.2.2 Modificateurs de visibilit de membres

C : Classe, A : Attribut, M : Mthode, 1 : si interne.
(package)
private
protected
public
Visibilit limite aux classes du mme paquetage que la classe du membre ;

visibilit par dfaut ( ne pas utiliser de manire explicite).
Visibilit limite la propre classe du membre (une classe interne est
considre comme un membre de la classe).
Visibilit limite la propre classe du membre, aux sous-classes de la classe
du membre et aux classes du mme paquetage que la classe du membre.
Aucune restriction de visibilit.
A.2.3 Autres modificateurs

C : Classe, A : Attribut, M : Mthode, 1 : si interne.
C
abstract
final
native
static
synchronized
transient
volatile
M : mthode dont seul le prototype est dfini, doit tre implmente par
surcharge lors de la drivation ; consquence directe : classe abstraite.
C : classe contenant une ou plusieurs mthodes abstraites ; ne peut pas tre
instancie, utilisable seulement par drivation.
A : attribut constant.
M : mthode ne pouvant tre surcharge lors de la drivation.
C : classe ne pouvant tre drive.
M : mthode implmente dans un autre langage (souvent C++) et accde
via une librairie dynamique (recherche de rapidit).
A : attribut disponible mme sans disposer dinstance de la classe ; commun
tous les objets de la classe.
M : mthode disponible mme sans disposer dinstance de la classe.
C : classe interne disponible mme sans disposer dinstance de la classe.
M : mthode excutable par un seul thread la fois (applicable aussi pour un
bloc de code de la mthode plutt que la mthode entire).
A : attribut non sauvegard lors de la srialisation de lobjet (scurit).
A : attribut sauvegard directement en RAM, sans tre bufferis, assurant
ainsi la fiabilit de sa valeur instantane lors de laccs par divers membres.
A.2.4 Types primitifs

boolean
byte
char
double
float
int
long
short
void
Boolen (true/false).
Entier sur 1 octet.
Caractre sur 2 octets (standard Unicode).
Rel sur 8 octets.
Rel sur 4 octets.
Entier sur 4 octets.
Type vide (utilis pour les dclarations de mthodes uniquement).
A.2.5 Structures de contrle

assert
break
case
continue
default
do
else
for
Vrification dune condition ncessaire lexcution dune instruction.

Sortie de boucle ou de bloc de code.
Test multiple slection (cf. default, switch).
Poursuite de lexcution de la boucle (branchement litration suivante (test de continuit)).
Test multiple slection par dfaut (cf. case, switch).
Boucle avec une itration minimale (cf. while).
Test simple test conditionnel inverse (cf. if).
Boucle avec itration.
55 / 59
if
return
switch
while
1.1.0.1 07/05/2010
Test simple test conditionnel (cf. else).

Sortie du bloc de code avec ou sans valeur de retour.
Test multiple test de slection (cf. case, default).
Boucle avec une itration minimale (cf. do) ou aucune.
A.2.6 Gestion des exceptions

catch
finally
throw
throws
try
Capture et traitement de lexception (cf. try, finally).

Dclaration dun bloc de code final excut la sortie du bloc try / catch (), quune
exception ait t signale ou pas (cf. try, catch).
Lancement explicite dune exception (cf. throws).
Dclaration des types dexceptions quune mthode est susceptible de dclencher (cf. throw).
Dclaration dun bloc de code susceptible de signaler une exception (cf. catch, finally).
A.2.7 Autres
const
goto
false
null
strictfp
true
Rserv (usage futur).

Rserv (usage futur).
Valeur boolenne quivalente FAUX / 0.
Pointeur nul (pas despace mmoire rserv).
Calcul en virgule flottante avec respect du standard IEEE, assurant ainsi lunicit du rsultat
du calcul quelque soit la JVM utilise.
Valeur boolenne quivalente VRAI / 1.
56 / 59
1.1.0.1 07/05/2010
B RFRENCE DU LANGAGE
B.1 BIBLIOTHQUES DES CLASSES JAVA
LAPI 1 Java est constitu de lensemble des bibliothques des classes Java, et constitue toute la richesse du langage.
java.lang
java.util
java.io
java.text
java.math
java.awt
javax.swing
java.applet
java.net
java.sql
java.beans
java.lang.reflect
java.rmi
java.security
Langage : Classes de base du langage Java.

Utilitaires : Structures de donnes (notamment dynamiques).
Entres/sorties : Gestion des divers types dentres/sorties.
Texte : Gestion du texte, des dates, des nombres et des messages.
Maths : Calcul en prcision entire et en virgule flottante.
AWT (Abstract Window Toolkit) : Conception dIHM et gestion dvnements
(composants graphiques lourds 2).
Swing : Conception dIHM et gestion dvnements (composants graphiques
lgers 3).
Applet : Cration et gestion dapplets (application intgres un navigateur).
Rseau : Accs et communication via le rseau.
SQL : Accs aux bases de donnes, traitement des requtes.
Beans : Gestion des JavaBeans.
Rflexion : Gestion et manipulation de concepts lis aux objets ou la programmation
en gnral.
RMI (Remote Method Invocation) : Programmation dapplications distribues (accs
des objets distants via le rseau) 4.
Scurit : Gestion de la scurit par cryptographie.
B.2 DITIONS DE LA PLATE-FORME JAVA

Lune des vocations principales du langage Java tant de dvelopper une portabilit maximale, toute application
Java est oriente multi-plateformes (Windows/Linux/Mac, x86/x64, etc.). Il existe donc autant de machines virtuelles
diffrentes que de plates-formes dexcutions diffrentes ; en sus, pour une plate-forme donne, la JVM est dcline
en 3 ditions :
Y J2SE Standard Edition : classes pour le dveloppement dapplications et dapplets ;
Y J2EE Enterprise Edition : J2SE + classes pour le dveloppement dapplications dentreprise (JDBC,
Servlet/JSP, etc.) ;
Y J2ME Micro Edition : sous-ensemble de classes du J2SE destines aux produits lectroniques grand public
mobiles (PDA, tlphones mobiles, etc.).

1
2
Application Programming Interface (eng) [ Interface de Programmation dApplication (fr).

Un composant graphique lourd (heavyweight GUI component (eng)) est dessin en faisant appel au gestionnaire de fentres du systme
dexploitation, cest--dire quil aura le look & feel (apparence) du thme utilis par le gestionnaire de fentres de lOS (on parle parfois de
skin). Pour dessiner le composant ainsi, la JVM communique avec lIHM de lOS en utilisant des mthodes natives (JNI : Java Native
Interface) ; lappel ces mthodes est coteuse en ressources, do le terme lourd . Ce choix a t fait au dpart pour assurer une portabilit
maximale aux applications Java. AWT ne comprend ainsi que des composants graphiques lourds .
Un composant graphique lger (lightweight GUI component (eng)) est dessin directement par la JVM selon un look & feel dcid par le
dveloppeur. Le composant graphique est ainsi compltement indpendant du gestionnaire de fentres de lOS, et autant son look & feel peut
tre mul pour ressembler celui de lOS, autant il peut tre compltement diffrent puisquil est interchangeable volont avec extrmement
peu de modification du code. Une application Java peut ainsi avoir exactement la mme apparence dune plateforme une autre. Swing, cens
supplanter AWT, possde des quivalents aux composants graphiques AWT, dont le nouveau nom reprend lancien nom prcd dun J
(Frame
JFrame). Swing ne comprend que des composants graphiques lgers (cods intgralement en Java), exception faite des
composants ayant besoin dinteragir directement avec le gestionnaire de fentres de lOS, savoir : JFrame, JApplet, JDialog et JWindow.
Identique dans les fonctionnalits CORBA, mais limit un dveloppement en Java ( linverse de RMI-IIOP).
57 / 59
1.1.0.1 07/05/2010
Dans chaque dition, deux versions 1 sont disponibles :

Y Java Runtime Environment (J2RE ou JRE) : Environnement dexcution Java, ncessaire et suffisant pour
excuter un programme Java ; compos de la JVM et de lAPI 2 ;

Y Java Development Kit (J2DK ou JDK) : Kit de dveloppement dapplications Java ; compos du JRE, de tous
les outils ncessaires au dveloppement (compilateur, etc.), et dannexes (code source, dmos, etc.).
B.3 VERSIONS DE LA PLATE-FORME JAVA

Depuis ses dbuts en 1995, le langage Java a fortement volu afin de voir sa stabilit samliorer, ainsi que de
proposer de nouvelles classes et/ou bibliothques de classes.
Nom
officiel
Versions et
dates de
sortie
1995
1997 (1.1.4)
1997 (1.1.5)
1998 (1.1.6)
1998 (1.1.7)
1998 (1.1.8)
1998 (1.2.0)
1999 (1.2.1)
1999 (1.2.2)
Nom de
code
Principales volutions
Sparkler
Pumpkin
Abigail
Brutus
Chelsea
Playground
(aucun)
Cricket
J2SE 1.3
1999 (1.3.0)
2000 (1.3.1)
Kestrel
Ladybird
J2SE 1.4
2001 (1.4.0)
2002 (1.4.1)
2003 (1.4.2)
Merlin
Hopper
Mantis
J2SE 5.0
2004 (1.5.0)
Tiger
Srialisation, classes
internes, JavaBeans,
archives Jar, RMI,
JDBC, internationalisation, JNI,
Swing + JFC, Java IDL
(CORBA), JDBC 2.0,
collections, compilateur
JIT, rflexion,
JNDI, HotSpot JVM,
JPDA, amlioration
performances,
JavaSound,
JAXP (XML), JDBC
3.0, journalisation,
expressions rgulires,
WebStart, JCE,
Programmation
gnrique, JAXP 1.3,
JMX management,
SASL, autoboxing,
enum, metadata,
JSE 6
JSE 7
2006 (6.0)
2010 ?
Mustang
Dolphin
Java 1.0
Java 1.1
J2SE 1.2
Version
teste
n.d.
1.1.8_10
Nombre de
paquetages
/ classes
8 / 211
22 / 477
Taille JRE /
JDK / Doc JDK
(Mo)
n.d.
6 / 20 / 12
1.2.2_17
59 / 1524
20 / 65 / 86
1.3.1_20
76 / 1840
18 / 82 / 108
1.4.2_19
135 / 2723
42 / 199 / 177
1.5.0_18
166 / 3279
70 / 189 / 224
6.0_13
203 / 3793
86 / 295 / 265
Nb : Les tests de taille ont t effectus avec la version Windows de la plate-forme ; les nombres de paquetages et
de classes ont t comptabiliss par rapport ceux rfrencs dans la documentation officielle (Doc JDK).
1
2
Les 2 versions (JRE et JDK) sont libres dutilisation, et sont tlchargeables gratuitement sur http://java.sun.com/.
Un certain nombre de navigateurs utilisent directement le JRE pour lexcution des applets (Opera, Mozilla Firefox), ce nest pas le cas de
Internet Explorer qui intgre sa propre machine virtuelle, mais que linstallation du JRE peut supplanter (hautement conseill !).
58 / 59
1.1.0.1 07/05/2010
C BIBLIOGRAPHIE
Wazir Dino, Cours Java, TS IRIS LEGT Louis-Modeste Leroy vreux, 2002 ;
Sun Microsystems, Documentation JDK API J2SE 1.4.2, http://java.sun.com/j2se/1.4.2/docs/api/index.html, 2003 ;
Doudoux Jean-Michel, Dveloppons en Java v0.80.2, http://perso.wanadoo.fr/jm.doudoux/java/tutorial/, 2004 ;
Borland, Apprendre Java avec Jbuilder 7, 2002 ;
Infini.fr, Java, http://www.infini-fr.com/Sciences/Informatique/Langages/Imperatifs/Java/java.html, 2005 ;
Clavel Gilles, Mirouze Nicolas, Munerot Sandrine, Pichon Emmanuel, Soukal Mohamed,
Java : la synthse vers la maturit avec le JDK 1.2 (2 dition), InterEditions, 1998 ;
Touravane, Introduction Java, http://pages.univ-nc.nc/~touraivane/main/Enseignement.html,
Ecole Suprieure dIngnieurs de Luminy Dpartement Gnie Bio Mdical, 1998 ;
Eteks.com, Du C/C++ Java, http://www.eteks.com/coursjava/tdm.html, 2005 ;
Hardware.fr, Forum Java, http://forum.hardware.fr/hardwarefr/Programmation/Java/liste_sujet-1.htm, 2005 ;
Niedermair Elke et Michael, Programmation Java 2, MicroApplication, 2000 ;
Delannoy Claude, Exercices en Java, Eyrolles, 2001 ;
Boichat Jean-Bernard, Apprendre Java et C++ en parallle, Eyrolles, 2000 ;
CommentaMarche.net, Java, http://www.commentcamarche.net/java/, 2005 ;
Wikipedia lencyclopdie libre, Java, http://fr.wikipedia.org/, 2009 ;
Dveloppez.com, Introduction Java, http://java.developpez.com/, 2005 ;
Oplog, Formation internet : Java, OpLog lOpportunit Logicielle, 2002 ;
Longuet Patrick, Livre dor Java votre guide complet de dveloppement, Sybex, 1996 ;
Peignot Christophe, Langage UML, http://info.arqendra.net/, 2009.
59 / 59

Java Cours

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Java Cours

Încărcat de

Drepturi de autor:

Formate disponibile

Langages > Langage Java > Cours

chapitre 3.1 : visibilit des attributs et mthodes

Langages > Langage Java > Cours

TABLE DES MATIRES

INTRODUCTION AU LANGAGE JAVA ............................................................ 6

RAPPELS SUR LA PROGRAMMATION OBJET ................................................................................ 7

Les oprateurs dvaluation dexpression......................................................................................12

GESTION DES VNEMENTS ..................................................................................................... 14

Les types de variables prdfinis....................................................................................................11

LES STRUCTURES DE CONTRLE .............................................................................................. 12

Environnement de dveloppement ....................................................................................................9

LES VARIABLES ....................................................................................................................... 11

DVELOPPEMENT JAVA ............................................................................................................. 9

Gnralits sur lobjet ......................................................................................................................7

Les applications console ...........................................................................................................16

LHRITAGE SIMPLE ................................................................................................................ 20

LES INTERFACES ...................................................................................................................... 22

Introduction : mthode et classe abstraite......................................................................................22

Langages > Langage Java > Cours

LES FLUX DENTRES/SORTIES .................................................................... 28

LES APPLETS ...................................................................................................... 37

CYCLE DE VIE .......................................................................................................................... 37

EMPAQUETAGE DES APPLETS ................................................................................................... 40

GESTION DES THREADS............................................................................................................ 46

Enregistrement des donnes ...........................................................................................................30

GESTION DES FLUX DOBJETS .................................................................................................. 33

Les flux doctets..............................................................................................................................29

GESTION DES FLUX SUR FICHIER TEXTE ................................................................................... 30

Notion de flux .................................................................................................................................28

LES FLUX STANDARD............................................................................................................... 29

LES SOCKETS ..................................................................................................... 48

CAS PRATIQUE ......................................................................................................................... 51

Langages > Langage Java > Cours

DTAILS SUR LA COMMUNICATION CLIENT-SERVEUR .............................................................. 52

TABLE DES ANNEXES

Paquetages, classes, membres et interfaces ...................................................................................54

TABLE DES ILLUSTRATIONS

Langages > Langage Java > Cours

Langages > Langage Java > Cours

1 INTRODUCTION AU LANGAGE JAVA

Langages > Langage Java > Cours

Gnralits sur lobjet

Parfois appeles aussi proprits dans certains langages.

Langages > Langage Java > Cours

Figure 2.2 : exemple de respect de lencapsulation grce aux accesseurs

Figure 2.3 : exemple dun hritage de classe

de la super-classe (nom et signature de la

Uniquement si ceux-ci ont t dclars publics ou protgs.

Langages > Langage Java > Cours

signature est diffrente ; aussi appel gnricit 1.

Ex. : La classe Voiture possde plusieurs dfinitions de la mthode fairePlein() : void

2.2 DVELOPPEMENT JAVA

Figure 2.4 : exploitation du code source Java

Structure dun fichier source

projet Java, on a donc autant de fichiers que de classes ;

Gnricit (fr) [ template (eng).

Langages > Langage Java > Cours

La structure dun fichier source Java est donc la suivante :

// importation d'une bibliothque/paquetage

public class NomClasse

public void uneMethode()

Langages > Langage Java > Cours

Les bibliothques de classes Java