Cours Programmation Java

v 1.4
Mohammed Lahmer (©2002-2023)
[Link]@[Link]

Méthodes static et default dans une Interface (p.24)

Intégration du Lambda Language (p.29 et p. 47)
Ajout d’un chapitre sur le JavaFX (Chapitre 7)

1
© M. Lahmer 2002-2023



 SOMMAIRE

SOMMAIRE.............................................................................................................................................................2
1. Pr sentation du Langage ...........................................................................................................................4
1. Bref historique ..................................................................................................................4
2. Les caractéristiques du langage Java ................................................................................4
3. Kit de développement .........................................................................................................6
2. Structure du Langage ..................................................................................................................................9
1. La syntaxe ...................................................................................................................9
2. Classes et Objets .......................................................................................................12
2. Méthodes et variables de la classe ............................................................................14
3. Les packages .............................................................................................................15
4. Classes particulières .................................................................................................16
3. L’h ritage en Java ................................................................................................................................21
1. Principe de L’héritage ...............................................................................................21
2. Syntaxe de l’héritage ................................................................................................21
3. Polymorphisme ...............................................................................................................22
4. Classes et méthodes abstraites ........................................................................................23
5. Les interfaces ..................................................................................................................24
4. Les Collections .............................................................................................................................................25
1. Définitions ......................................................................................................................25
2. L’interface Collection .....................................................................................................26
3. La classe ArrayList .........................................................................................................27
4. L’interface Map...............................................................................................................28
5. Tri et Recherche dans des collections .............................................................................29
6. La gestion du temps (Date/Time) ...................................................................................30
4. Les entr es sorties............................................................................................................................31
1. Les flux java ...................................................................................................................31
2. La classe File ..................................................................................................................31
3. Les flux octets .................................................................................................................32
4. Les flux caractères ..........................................................................................................34
5. Les filtres ........................................................................................................................35
6. Sérialisation des objets ...................................................................................................35
6. Le graphique en Java .................................................................................................................................37
1. Graphique en Java...........................................................................................................37
2. Composants lourds/ légers ..............................................................................................39
3. Composants de base........................................................................................................40
4. Mise en page des composants dans un conteneur ...........................................................42
5. Traitement des événements .............................................................................................44
6. Les autres Composants graphiques.................................................................................47
7. JavaFX ...............................................................................................................................................................55
1. Introduction .....................................................................................................................55
2. Architecture .....................................................................................................................55
3. Application JavaFX .........................................................................................................56
4. Exemple ...........................................................................................................................59
5. ListView ..........................................................................................................................60

2
© M. Lahmer 2002-2023

é
é
é












































 6. Text Style .........................................................................................................................61
7. Charts ...............................................................................................................................61
8 Acc s aux bases de donn es en JDBC .........................................................................................63
1. Principe ...........................................................................................................................63
2. Mise en œuvre ................................................................................................................63
3. PreparedStatement et CollablStatement ..........................................................................65
4. Les métadonnées.............................................................................................................66
9. Client / Serveur en RMI ..................................................................................................................67
1. Définition ........................................................................................................................67
2. Mise en œuvre ................................................................................................................67

3
© M. Lahmer 2002-2023

è
é










 1. Présentation du Langage

1. Bref historique
■ 1993 : projet Oak (langage pour l' lectronique grand public)
■ 1995 : Java / HotJava
■ Mai 95 : Netscape prend la licence
■ Sept. 95 : JDK 1.0 b1
■ Déc. 95 : Microsoft se dit int resser
■ Janv. 96 : JDK 1.0.1
■ Eté 96 : Java Study Group ISO/IEC JTC 1/SC22
■ Fin 96 : RMI, JDBC, JavaBeans, ...
■ Fév. 97 : JDK 1.1
■ 98 : C’est la grande r volution JDK 1.2 ou java 2

Java 2
Spécification
J2ME J2SE J2EE
(Java 2 Micro Edition) (Java 2 Standard Editon) (Java 2 Enterprise Edition)

■ J2SE 1.3 2000

■ J2SE 1.4 2002 (instruction assert, int gration XML et des extensions de s curit )
■ J2SE 5.0 2004 (annotation@, type enum, varargs, for each)
■ Java SE 6 2006 (support du web services, am lioration du graphique)
■ Java SE 7 2011 (String dans switch, nouveau lux I/O)
■ Java SE 8 2014 (JavaFX nouveau mode de d veloppement du graphique, fonction
Lambda, nouvelle api Date/Time )

2. Les caractéristiques du langage Java

1. Java est un langage orienté objets

■ Tout est classe (pas de fonctions l’ext rieure d’une classe) sauf les types primitifs (int,
loat, double, ...) et les tableaux
■ Toutes les classes d rivent de [Link]
■ H ritage simple pour les classes
■ H ritage multiple pour les interfaces
■ Les objets se manipulent via des r f rences
■ Une API objet standard est fournie
■ La syntaxe est proche de celle de C

4
© M. Lahmer 2002-2023

f

é
é
é
é
é
à
é
é
é
é
é
f
é
é
é
é
 2. Langage semi-compilé et semi-interprété
■ Un langage compil est un langage qui permet de cr er un ichier ex cutable partir d’un
programme source
■ Un langage interpr t est un langage ou le code source doit tre lu par un interpr teur
pour s’ex cuter.
■ Le code source est d’abords compil en byte code (attention ce n’est pas un code
machine) puis interpr t et ex cut par la machine virtuelle Java (JVM)

3. Java est portable

■ Les programmes java ( part certains cas tr s particuliers) sont ind pendants de la plate-
forme.
■ Il est d’abord traduit dans un langage appel « bytecode » qui est le langage d’une
machine virtuelle (JVM ; Java Virtual Machine) dont les sp ci ications ont t d inies
par Sun.
■ La Java Virtual Machine (JVM) est pr sente sur Unix, Linux,Win32, Mac, OS/2, Mozilla,
Netscape, IE, ...
■ La taille des types primitifs est ind pendante de la plate-forme contrairement C ou C++.
■ Java supporte un code source crit en Unicode facilement internationalisable.

4. Java est robuste

■ Gestion de la m moire par un garbage collector qui Lib re la m moire d’un objet non
utilis . vite la surcharge
■ M canisme d'exception des erreurs syst me pris en charge par la JVM. (Acc s une
r f rence null exception)

5
© M. Lahmer 2002-2023


é
é
é
é
É
é
é
é
é
é
é
à
é
é
é
é
é
é
é
è
è
é
é
è
f
é
ê
f
é
é
é
à
é
à
é
è
é
à
f
é
 ■ Compilateur contraignant (erreur si exception non g r e, si utilisation d’une variable non
affect e, ...).
■ Tableaux = objets (taille connue, d bordement : exception)
■ Contr le des cast l'ex cution. Seules les conversions s res sont automatiques.

5. Java est sécurisé

La s curit est indispensable avec le code mobile (Applications r partis). Il existe trois
niveaux de s curit au niveau de la JVM:
■ Véri ication : v ri ie le byte code.
■ Chargement (Class Loader) : responsable du chargement des classes. (v ri ier les
autorisations private, protected, public)
■ Contrôle (Security Manager) : contr le l’acc s aux ressources. En plus vous avez la
possibilit de certi ier le code par une cl . (m canismes de cryptographie et
d’authenticit )
Une fois le code est charg en m moire, il est impossible de faire un acc s direct la
m moire contrairement C et C++.

6. Java est multi-thread et Distribué

■ Java est multi-thread
■ Acc s concurrents objet g r s par un monitor (verrou, sémaphore, ..).
■ Impl mentation propre a chaque JVM->Dif icult s pour la mise au point et le
portage.
■ Java est distribu
■ API r seau ([Link], [Link], ...).
■ Chargement / g n ration de code dynamique.
■ Applet.
■ Servlet.
■ (RMI) Remote Method Invocation.
■ JavaIDL (CORBA).

3. Kit de développement

1. JVM / JRE

Les machines virtuelles java sont fournies gratuitement par Sun Microsystems. Elles sont
fournies sous forme de JRE (Java Runtime Environment) comprenant la machine virtuelle et les
package du noyau de java (APIs).

JRE = JVM + APIs Noyau

6
© M. Lahmer 2002-2023

é
è
f
é
é
é
é
ô
é
é
é
é
é
é
é
f
à
é
é
à
f
é
à
é
é
é
é
ô
é
è
é
f
é
é
é
é
û
é
é
f
è
à
 Le JRE ne contient pas d'outils ou d'utilitaires pour compiler ou d buguer les applets ou les
applications.
Intel, Motorala, Ultra-sparc sont des exemples de processeurs int gr s dans des plate-formes
type : Pc, Mac ou Station Sun

2. Structure JSDK
JSDK (Java Software Developpement Kit) est compos de JRE et plusieurs outils.

JSE = JRE + Outils

Les outils
■ javac : compilateur de sources java
■ java : interpr teur de byte code
■ appletviewer : interpr teur d'applet
■ javadoc : g n rateur de documentation (HTML, MIF)
■ javah : g n rateur de header pour l'appel de m thodes natives

7
© M. Lahmer 2002-2023



é
é
é
é
é
é
é
é
é
é
é
 ■ javap : d sassembleur de byte code
■ jdb : d begueur
■ javakey : g n rateur de cl s pour la signature de code
■ rmic : compilateur de stubs RMI
■ rmiregistry : "Object Request Broker" RMI

2. Les APIs de base

■ [Link] : Types de bases, Threads, ClassLoader, Exception, Math, ...
■ [Link] : Hashtable, Vector, Stack, Date, ...
■ [Link]
■ [Link] : Interface graphique portable
■ [Link] : acc s aux i/o par lux, wrapping, iltrage
■ [Link] : Socket (UDP, TCP, multicast), URL, ...
■ [Link] lect : introspection sur les classes et les objets
■ [Link] : composants logiciels r utilisables
■ [Link] (JDBC) : acc s homog ne aux bases de donn es
■ [Link] : signature, cryptographie, authenti ication
■ [Link] : s rialisation d'objets
■ [Link] : Remote Method Invocation
■ [Link] : extension du [Link], plus riches en terme de composants
■ Java2D : int gr depuis JDK 1.2 sous forme de sous paquetage du awt.
■ [Link] et [Link] : contient une impl mentation de la plupart des
standard de la cryptographie et le hashage.
■ [Link] : pour le traitement des ichiers xml

Il existe d’autres Apis tierces que vous pouvez t l charger ind pendamment du Kit :
■ JFreeChart / JGraph : pour la génération des graphes tels que les histogrammes, les secteurs,….
■ SNMP4J : La supervision d’un r seau par le biais du protocole snmp
■ Jpcap : La capture des trames, paquets qui circules dans un r seau
■ [Link] : offre un support la majorit des protocoles r seaux (FTP/
FTPS, NNTP, SMTP(S), POP3(S), IMAP(S), Telnet, TFTP, …)

8
© M. Lahmer 2002-2023

é
é
é
è
é
f
é
é
è
é
é
f
è
é
f
é
f
à
é
é
f
é
é
é
é
é
é
 2. Structure du Langage

1. La syntaxe

1. Premier programme Java

On cr e un ichier [Link] qu’on met directement dans c :

public class HelloWorld {
public static void main(String[] args)
{
[Link]("Hello world"); // Afficher sur Ecran
}}

• La classe Helloworld est public, donc le ichier qui la contient doit s’appeler (en tenant
compte des majuscules et minuscules) [Link]
• Un ichier .java peut contenir la d inition de plusieurs classes mais une et une seule qui
doit tre publique
• Compilation avec javac c:\>javac [Link]
o cr e un ichier « [Link] » qui contient le bytecode, situ dans le m me
r pertoire que le ichier « .java »
• Execution avec java c:\>java HelloWorld
o interpr te le bytecode de la m thode main() de la classe HelloWorld
• [Link] doit tre dans le r pertoire courant ou dans un des emplacements
indiqu s par une option -classpath ou par la variable CLASSPATH

2. Les identi icateurs et les commentaires

■ Un identi icateur Java
– est de longueur quelconque
–commence par une lettre Unicode (caract res ASCII recommand s)
– peut ensuite contenir des lettres ou des chiffres ou le caract re souligner _
– ne doit pas tre un mot-cl ou les constantes true, false et null
■ Les commentaires
■ Sur une seule ligne int prime = 1500; // prime in de mois
■ Sur plusieurs lignes : /* Premi re ligne du commentaire
Suite du commentaire */

3. Les types primitifs

■ boolean(true/false), byte (1 octet), char (2 octets), short (2 octets), int (4 octets), long
(8 octets), loat (4 octets), double (8 octets).
■ Les caract res sont cod s par le codage Unicode (et pas ASCII) ’\u03a9’

9
© M. Lahmer 2002-2023

é
é
f
ê
é
é
è
f
f
è
f
f
f
ê
f
à
ê
é
à
é
é
è
é
f
é
f
è
f
è
é
é
ê
 ■ Les variables peuvent tre d clar es n'importe o dans un bloc.
■ Les affectations non implicites doivent tre castées (sinon erreur la compilation).
int i = 258;
long l = i;
■ Valeurs par d faut
Si elles ne sont pas initialis es, les variables d’instance ou de classe (pas les variables
locales d’une m thode) reçoivent par d faut les valeurs suivantes :
boolean false
char ’\u0000’
Entier (byte short int long) 0 0L
Flottant ( loat double) 0.0F 0.0D
R f rence d’objet null
Les constantes
■ Une constante « enti re » est de type long si elle est suf ix e par « L » et de type
int sinon
■ Une constante « lottante » est de type loat si elle est suf ix e par « F » et de type
double sinon : .123587E-25F // de type loat

4. La conversion de type
■ En Java, 2 seuls cas sont autoris s pour les casts :
– entre types primitifs (suit les m mes r gles que C),
– entre classes m re/anc tre et classes illes (voir plus loin dans ce cours)
■ Un cast entre types primitifs peut occasionner une perte de donn es Par exemple, la
conversion d'un int vers un short
■ Un cast peut provoquer une simple perte de pr cision. Par exemple, la conversion d'un
loat vers un int
int i = 258;
long l = i; // ok
byte b = i; // error: Explicit cast needed to convert int to byte
byte b = 258; // error: Explicit cast needed to convert int to byte
byte b = (byte)i; // ok mais b = 2

5. Les structures de contrôle

■ Essentiellement les m mes qu'en C
■ if, switch, for, while, do while
■ ++, +=, &&, &, <<, ?:,!,~,^…
■ Plus les blocs labellis s
UN: while(...) {
DEUX: for(...) {

10
© M. Lahmer 2002-2023
f

é
é
f
é
é
f
è
è
é
ê
ê
ê
é
é
é
é
ê
f
é
ê
f
è
f
é
ù
f
f
é
é
é
à
 TROIS: while(...) {
if (...) continue UN;// Reprend sur la première boucle while
if (...) break DEUX;// Quitte la boucle for
continue;// Reprend sur la deuxième boucle while
}}
■ Une boucle for sp ciale a t rajout e depuis la version 1.5 a in de faciliter le parcours
des tableaux d’objet (voir exemple Tableau paragraphe 6.)
■ A partir de JDK 1.8, il est d sormais possible de faire un switch sur un type String
Switch (jour) {
case ’’Lundi’’ :
….
}

6. Les tableaux
E Java un tableau est trait comme un objet, donc il faut le d clarer et l’initialiser avant de
l’utiliser
■ Déclaration
int[ ] tab_of_int; // quivalent : int tab_of_int[ ];
Color rgb_cube[ ][ ][ ];
■ Création et initialisation
array_of_int = new int[42];
rgb_cube = new Color[256][256][256];
int[ ] primes = {1, 2, 3, 5, 7, 7+4};
tab_of_int[0] = 3 ;
■ Utilisation
int l = tab_of_int.length; // l = 42
L’indice commence 0 et se termine length - 1
int e = tab_of_int[50]; /* Lève une Exception ArrayIndexOutOfBoundsException*/
Exemple de programme qui af iche les l ments d’un tableau
public class AfficherTab {
public static void main(String[] args)
{
int [ ] T={10, 2, 15, -8, 7};
for (int el:T)
{
[Link](el);
}
}
}

Il existe d sormais plusieurs fonctions pr d inies qui permettent par exemple de :

■ copier une partie d'un tableau dans un autre
■ La fonction arraycopy de la classe System

11
© M. Lahmer 2002-2023

é
é
é
à
é
é
é
é
f
à
é
à
é
é
é
é
f
é
f
 ■ public static void arraycopy(Object src, int src_position,Object dst,
int dst_position, int length)
■ comparer 2 tableaux
■ La fonction equals() de la classe [Link]
■ public static boolean equals(double[] a1, double[] a2)
Les param tres de ligne de commande ou les arguments de main constituent un tableau de
cha nes de caract res
class Arguments {
public static void main(String[] args) {
for (int i=0; i < [Link]; i++)
[Link](args[i]);
}}
java Arguments toto titi //affichera toto puis titi

2. Classes et Objets

1. Objet / Classe

■ Un objet peut tre envisag de façon pragmatique comme constitu de deux parties :
■ Une partie de stockage physique (Objet)
■ Une partie descriptive (Classe)
■ L'Objet peut tre apparent une variable de type structure en C (record en pascal, ligne
d'une table dans une BD Relationnelle)
■ Une classe n'est pas destin e au stockage des donn es. C'est un type de donn es abstrait,
caract ris par des propri t s (attributs et m thodes) communes des objets et
permettant de cr er des objets poss dant ces propri t s.

Nom_Classe Point

Attributs float x
float y

Constructeurs Point(int x,int y)

Méthodes Void afficher(Point p)

Les objets sont construits partir d’une classe en utilisant un constructeur.

2. Les constructeurs
Chaque classe a un ou plusieurs constructeurs qui servent
– cr er les instances
– initialiser l’ tat de ces instances

12
© M. Lahmer 2002-2023


î
é
é
é
è
ê
é
ê
é
è
é
à
é
é
é
é
à
é
é
é
é
é
à
à
é
é
 Un constructeur a le m me nom que la classe et n’a pas de type retour. Lorsque le code d’une
classe ne comporte pas de constructeur, un constructeur sera automatiquement ajout par
Java. Pour une classe Nom_Classe, ce constructeur par d faut sera [public] Nom_Classe() { }
Exemple
Fichier [Link]
/** Modélise un point de coordonnées x, y */
public class Point {
private int x, y;// Les attributs
// Le constructeur
public Point(int x1, int y1) {
x = x1; y = y1;
}
//Methode
public double distance(Point p) {
return [Link]((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}}

Fichier [Link]
/** Pour tester la classe Point */
class TestPoint {
public static void main(String[] args) {
Point p1 = new Point(1, 2);
Point p2 = new Point(5, 1);
[Link]("Distance : " + [Link](p2));
}}
Le mot cl new permet d’allouer de l’espace m moire au nouvel objet de type Point.

3. Les méthodes
Une m thode est l’ quivalent d’une fonction en C. Quand la m thode renvoie une valeur, on doit
indiquer le type de la valeur renvoy e dans la d claration de la m thode double
calculSalaire(int indice, double prime). Le pseudo-type void indique qu’aucune valeur n’est
renvoy e void setSalaire(double unSalaire)

public class Employe {

private double salaire; Modificateur
public void setSalaire(double unSalaire) {
if (unSalaire >= 0.0)
salaire = unSalaire; Accesseur
}
public double getSalaire() {
return salaire;}
}

4. Surcharge d’une méthode

Signature d’une méthode : nom de la m thode et ensemble des types de ses param tres :
Signature de la m thode main() : main(String[])
En Java, on peut surcharger une m thode, c’est- -dire, ajouter une m thode qui a le m me
nom mais pas la m me signature qu’une m thode existante :
■ calculerSalaire(int)
■ calculerSalaire(int, double)

13
© M. Lahmer 2002-2023

é
é
é
é
é
ê
ê
é
é
é
é
é
é
à
é
é
é
é
è
ê
é
 Il est interdit de surcharger une m thode en changeant le type de retour par exemple, il est
interdit d'avoir ces 2 m thodes dans une classe :
■ int calculerSalaire(int)
■ double calculerSalaire(int)

5. Passage des paramètres

Le mode de passage des param tres dans les m thodes d pend de la nature des param tres :
■ par r f rence pour les objets
■ par copie pour les types primitifs
public class C {
void methode1(int i, StringBuffer s)
{ i++; [Link]("d");}
void methode2() {
int i = 0;
StringBuffer s = new StringBuffer("abc");
methode1(i, s);
[Link](i=" + i + ", s=" + s); // i=0, s=abcd }}
Du moment que I est de type primitif il est pass m thode1 par copie et donc sa valeur n’a
pas chang e. Mais s est un Objet donc il prend la derni re valeur attribu e dans methode1
parce qu’il est transf r par r f rence.

2. Méthodes et variables de la classe

1. Variables de classe
Certaines variables peuvent tre partag es par toutes les instances d’une classe. Ce sont les
variables de classe (modi icateur static en Java). Si une variable de classe est initialis e dans
sa d claration, cette initialisation est ex cut e une seule fois quand la classe est charg e en
m moire
Les variables static sont communes toutes les instances de la classe.
public class Employe {
private static int nbEmployes = 0;
// Constructeur
public Employe(String n, String p) {
nom = n;prenom = p;nbEmployes++;}}

public static void main(String[] args){}

Employe e1=new Employe("Toto","Titi");
[Link]("Nombre Employer est: "+ [Link] );}}
Les blocs static permettent d’initialiser les variables static trop complexes initialiser dans
leur d claration. Ils sont ex cut s une seule fois, quand la classe est charg e en m moire
class UneClasse {
private static int[] tab = new int[25];
static {
for (int i = 0; i < 25; i++) {
tab[i] = -1;
}
….
} // fin du bloc static

14
© M. Lahmer 2002-2023

é
é
é
é
é
é
é
é
é
f
é
ê
é
é
è
é
é
à
é
é
é
é
é
à
é
è
é
é
é
à
é
é
è
é
 2. Méthodes de classe
Une m thode de classe (modi icateur static en Java) ex cute une action ind pendante d’une
instance particuli re de la classe. Elle ne peut utiliser de r f rence une instance courante
(this)
■ static double tripleSalaire() {return salaire * 3;} // NON
La m thode main() est n cessairement static. Pourquoi ?
Pour d signer une m thode static depuis une autre classe, on la pr ixe par le nom de la
classe :
■ int n = [Link]();
On peut aussi la pr ixer par une instance quelconque de la classe ( viter car cela nuit la
lisibilit : on ne voit pas que la m thode est static) : int n = [Link]();

3. Variable d’état inal

Le modi icateur inal indique que la valeur de la variable (d' tat ou locale) ne peut tre
modi i e. On pourra lui donner une valeur une seule fois dans le programme ( la d claration
ou ensuite). Une variable de classe static inal est vraiment constante dans tout le
programme ;
static inal double PI = 3.14;
Une variable d’instance (pas static) inal est constante pour chaque instance ; mais elle peut
avoir 2 valeurs diff rentes pour 2 instances. Elle peut ne pas tre initialis e sa d claration
mais elle doit avoir une valeur la sortie de tous les constructeurs

3. Les packages
Un package regroupe un ensemble de classes sous un m me espace de 'nomage'. Les noms
des packages suivent le sch ma : [Link] ...
Une classe employe appartenant au package [Link] doit se trouver dans le
ichier societe\travail\. L'instruction package indique quel package appartient la ou les
classe(s) de l'unit de compilation (le ichier). En dehors du package, les noms des classes
sont : [Link], sinon L'instruction import packageName permet
d'utiliser des classes sans les pr ixer par leur nom de package.
Encapsulation (public, protected et private)

15
© M. Lahmer 2002-2023
f

é
f
f
é
é
é
é
f
f
f
è
é
é
é
f
é
é
é
f
à
é
é
f
f
f
f
é
à
ê
é
é
ê
é
é
à
à
f
é
é
é
à
à
é
é
ê
à
 class c1 {
public int A; Package P2
protected int B; PackageP1
int C;
private int D;} class c4 extends c1 {
...
}

class c2 extends c1 { class c5 {

class c3 { ...}
...} ...}

A B C D
Accessible par c2 o o o -
Accessible par c3 o o o -
Accessible par c4 o o - -
Accessible par c5 o - - -

4. Classes particulières

1. Les chaînes de caractères

Il existe deux classes pour la manipulation des cha nes de caract res :
■ String pour les cha nes constantes
■ StringBuffer pour les cha nes variables
On utilise le plus souvent String, sauf si la cha ne doit tre fr quemment modi i e.
L'affectation d'une valeur litt rale un String (pas un StringBuffer) s'effectue par :
chaine = "Bonjour";
La sp ci ication de Java impose que
■ chaine1 = "Bonjour";
■ chaine2 = "Bonjour";
cr e un seul objet String (r f renc par les 2 variables)
La Concaténation
La concat nation se fait par l’op rateur + :
■ String s = "Bonjour" + " les amis";
■ int x = 5;
■ s = "Valeur de x + 1 = " + x + 1;
Les types primitifs lorsqu’ils sont concat n s avec un message sont convertis en String,
ainsi s contient Valeur de x + 1 = 51
Attention, la concat nation de Strings est une op ration co teuse (elle implique en
particulier la cr ation d'un StringBuffer). Il faut passer explicitement par un
StringBuffer si la concat nation doit se renouveler. Une seule cr ation d'un StringBuffer
pour toutes les concat nations

16
© M. Lahmer 2002-2023


é
é
f
é
é
î
é
é
é
î
é
é
é
é
à
é
é
é
î
à
é
î
ê
û
è
é
é
f
é
 char[] t={‘a’,’b’,’r’,’c’,’e’,’f’};
c = new StringBuffer(t[0]);
for (int i = 1; i < [Link]; i++) [Link](t[i]);
Fonctions de comparaison
La m thode equals() teste si 2 instances de String contiennent la m me valeur elle retourne
true ou false:
String s1, s2;
s1 = "Bonjour ";s2 = "les amis";
if ((s1 + s2).equals("Bonjour les amis"))
[Link]("Egales");
■ equalsIgnoreCase() pas de diff rence entre majuscule et minuscule
■ [Link](t) renvoie ( « signe » de s-t)
■ 0 en cas d’ galit de s et de t,
■ un nombre entier positif si s suit t dans l’ordre lexicographique
■ un nombre entier n gatif sinon
■ compareToIgnoreCase(t)
D’autres fonctions

Fonction Rôle
int length() Retourne la longueur de la cha ne appelante
String toString() Convertir un objet en String
char charAt(int i) Retourne le caract re la position i (0<= i < length())
String substring (int d, int f) Retourne tous les caract res entre la position d et f dans
une cha ne.
int indexOf(String sCh) Retourne la position de la sous cha ne sCh s’elle existe.
-1 si non
int indexOf(String sCh, Cherche la position de sCh partir de debut. elle
int debut) retourne sa position s’elle existe et – 1 si non
String [ ] split(String sep) Permet de d composer une cha ne en un tableau de
String en utilisant le s parateur sep
■ Exercice
Ecrire un programme Java qui permet de r cup rer le protocole, la machine, le
r pertoire et le nom du ichier une adresse Web [Link]
[Link]

2. Les classes enveloppes

Le paquetage [Link] fournit des classes pour envelopper les types primitifs (les objets
sont constants) : Byte, Short, Integer,Long, Float, Double, Boolean,Character.

17
© M. Lahmer 2002-2023
f

é
é
î
é
é
é
è
é
é
à
è
f
î
à
é
î
î
é
é
ê
 les classes enveloppes offre des m thodes utilitaires (le plus souvent static) pour faire des
conversions entre types primitifs (et avec la classe String)

Fonction Classe Rôle

int intValue() Integer Retourne l’entier encapsul dans l’objet
de type Integer
static int parseInt(String ch) Convertis une cha ne de caract re ch en
un entier
static String toBinaryString(int i) Integer Convertis un entier en String
repr sentant la repr sentation binaire
de i.
static String toHexString(int i) Integer Convertir un entier en String
repr sentant la repr sentation Hexa
D cimal de i.
static String valueOf(int i) String Convertis un entier en String.

static String toString(char c) Character Convertis un caract re c en String

3. La classe System
Cette classe est tr s utile pour diverses op rations d'entr e et sortie, d' mission d'erreurs,
d'acc s aux propri t s du syst me, et bien d'autres fonctionnalit s relatives des t ches
syst me.
■ [Link](NomPropriete) : renvoie la valeur de la propri t system ci-
dessous quelques exemples de R cup ration des variables d’environnement :
- Nom Utilisateur Connect : [Link]("[Link]")
- R pertoire de travail : [Link]("[Link]")
- Nom OS install : [Link]("[Link]")
- Version OS install : [Link]("[Link]");
■ [Link](code retour) : arr t imm diat de la JVM
■ [Link]() : appel explicite du Garbage Collector ou (Ramasse Miettes). Le ramasse-
miettes (garbage collector) est une t che(job) qui travaille en arri re-plan et dont le r le
de lib rer la place occup e par les instances non r f renc es. Il intervient
automatiquement quand le syst me a besoin de m moire ou, de temps en temps, avec
une priorit faible (voir Thread). Avant la suppression d’un objet par le ramasse miettes,
le syst me appelle la m thode inalize() de la classe de l’objet (si elle existe).
class garbage{
static boolean gcok=false;/*devient true lorsque le GC est
appelé*/
static int count;
public garbage(){count++;}
public void finalize(){

18
© M. Lahmer 2002-2023

é
é
è
é
é
è
è
é
é
é
î
è
é
é
è
é
é
é
é
é
é
é
f
è
ê
è
è
é
é
â
é
é
é
é
é
é
é
è
é
é
é
é
é
à
ô
â
 if(gcok==false)
[Link]("Appel GC:\n"+"Nombre d'instance
crees/supprimées : "+count);
gcok=true;}
public static void main(String[] args)
while(!gcok) {new garbage();}}}

4. La classe exception et ces dérivées

Les exceptions permettent de traiter s par ment les erreurs pouvant survenir dans un bloc
d’instructions. Ce sont des instances de classes d rivant de [Link]. L'appel
une m thode pouvant lever une exception doit :
■ soit tre contenu dans un bloc try/catch
try {
/* Code pouvant lever des IOException ou des SecurityException*/
}
catch (IOException e) {
/* Gestion des IOException et des sous-classes de
IOException*/}
catch (Exception e){
// Gestion de toutes les autres exceptions}
finally{
// Code qui sera exécuté dans tous les cas}
Noter bien que inally est optionnel. Il est utilis lorsque vous voulez ex cuter un bloc
d’instruction ind pendamment du r sultat de try/catch.
■ soit tre situ dans une m thode propageant (throws) de cette classe
d'exception void fonction throws IOException { // . . . }
Plusieurs exceptions sont d j d inies dans [Link] comme par exemples :
- NullPointerException
- OutOfMemoryException
- ArithmeticException
- ClassCastException
- ArrayIndexOutOfBoundsException
La lev e d'une exception provoque une remont e dans l'appel des m thodes jusqu' ce qu'un
bloc catch acceptant cette exception soit trouv . Si aucun bloc catch n'est trouv , l'exception est
captur e par l'interpr teur et le programme s'arr te.

19
© M. Lahmer 2002-2023

ê
ê
é
é
é
é
f
é
é
é
à
é
é
f
é
é
é
é
é
é
ê
é
é
é
é
à
à
 Object getContent()
{
try
{
openConnection(); void openConnection()
} 1 throws IOException
catch(IOException e) {
{ openSocket();
... sendRequest(); 4 2
} 5 receiveResponse(); void sendRequest()
finaly { } throws IOException
... {
} 6 write(header);
... 3write(body);//ERROR
} }

Il est tout fait possible de d inir vos propres exceptions en cr ant une classe qui d rive de la
classe m re Exception.
public class MonException extends Exception
{ public MonException(String text)
{ super(text); }}

On utilise le mot cl throw pour lever une exception en instanciant un objet sur une classe
d riv e de la classe Exception : throw new MonException("blabla");

20
© M. Lahmer 2002-2023


é
é
è
à
é
é
f
é
é
 3. L’héritage en Java

1. Principe de L’héritage
Le concept d'h ritage est un des concepts les plus importants de l’orient objet. C’est gr ce
ce dernier que la programmation objet est ce qui est aujourd’hui. Par d inition l’h ritage est
le fait de pouvoir utilis tout ce qui a d j t fait (r utilisation) et de pouvoir l'enrichir
(sp cialisation). Il indique toujours une relation de type "est un" ou « est une sorte de » :
- Un lapin est un animal,
- Un employ est une personne,
- Un pc est une machine.
En Java, chaque classe a une et une seule classe m re (pas d’h ritage multiple) dont elle
h rite les variables et les m thodes. Le mot clef extends indique la classe m re par exemple :
class B extends A{ }. La classe A s'appelle une classe m re, ou super-classe et la classe B qui
h rite de la classe A s'appelle une classe ille ou sous-classe.
Dans B on indique seulement ce qui a chang dans B par rapport au code de A ; on peut :
■ ajouter des variables, des m thodes et des constructeurs
■ redé inir des m thodes (exactement la m me signature et le m me type retour)
■ surcharger des m thodes (m me nom mais pas m me signature) (possible aussi
l’int rieur d’une classe)
Note : Si « B extends A », le grand principe est que tout B est un A

2. Syntaxe de l’héritage

1. Constructeur
La r gle g n rale est que pour construire un objet de la sous-classe il faut d’abord
construire un objet de la super-classe. Si un constructeur de la classe d riv e appelle
explicitement un constructeur de la classe de base, cet appel doit tre obligatoirement la
premi re instruction de constructeur. Il doit utiliser pour cela, le mot cl super.

2. Règles de visibilité dans l’héritage

Si une classe B h rite de A (B extends A), elle h rite automatiquement et implicitement
de tous les membres de la classe A (mais pas les constructeurs et les membres private)

3. Redé inition
Supposons que B h rite de A et que la m thode m() de A soit red inie dans B selon le
sch ma UML suivant :

21
© M. Lahmer 2002-2023
à

é
é
é
é
è
f
f
é
è
é
é
é
é
é
é
é
é
é
é
é
ê
f
é
ê
é
à
é
é
é
é
ê
è
é
è
ê
é
ê
é
f
é
é
f
é
é
è
é
é
â
à
 B
A
String s
void m()
void m()
void p()

Un objet d'une classe d riv e peut toujours tre utilis au lieu d'un objet de sa super-
classe donc on peut crire par exemple :
■ A a = new B();
■ a.m();
Quelle m thode m() sera ex cut e celle de A ou celle de B ?. ventuellement celle de B
parce que le contenu de a est un objet de B.

4. Conversion
Un objet de type B est un A. Mais l’inverse n’est pas vrai. Une machine n’est pas
n cessairement un pc.
A a ; B b = new B(’’s’’);
■ Cas a=b; // vrai
L’ criture a.m(); est vrai parce que m() est d inie dans A. Mais a ne peut pas appeler
p() donc a.p() est fausse.
■ Cas b=a; // fausse
Dans ce cas un cast est n cessaire parce que a ne contient pas tous les l ments de b
(dans ce cas le champs s)
■ Cas b=(B) a ;// vrai lors de la compilation mais pas à l’exécution

5. Le mot clé inal

Une classe utilise le mot clef inal dans sa d inition ne peut avoir de classes illes (String et
[Link] sont inal)
• Une M thode inal : ne peut tre red inie
• Un Param tre inal (d’une m thode) : la valeur ( ventuellement une r f rence)
ne pourra tre modi i e dans le code de la m thode
• Une Variable (locale ou d’ tat) inal : la valeur ne pourra tre modi i e apr s son
initialisation

3. Polymorphisme
Une m thode est dite polymorphe si elle a le m me nom dans plusieurs classes d riv es mais
pas la m me impl mentation.

22
© M. Lahmer 2002-2023

é
é
é
é
ê
é
è
ê
f
f
f
é
é
f
f
é
é
é
é
é
ê
f
é
é
f
é
é
f
é
é
f
é
ê
f
ê
é
é
ê
É
f
é
é
é
é
é
è
f
é
é
 Figure

void dessiner()

Cercle Rectangle

void dessiner() void dessiner()

La façon de dessiner un cercle est diff rente de celle qu’on utilise pour dessiner un rectangle
donc la m thode dessiner() est polymorphe.

public class Figure { public class Dessin {

public void dessiner() { } private Figure[] figures;
} public void afficher() {
public class Rectangle extends for (int i=0; i < nbFigures; i++)
Figure { figures[i].dessiner();
public void dessiner() { }
. . . public static void main(String[]
} args) {
public class Cercle extends Figure Dessin dessin = new Dessin(30);
{ Cercle C ; Rectangle R ;
public void dessiner() { …
… [Link](C)
} [Link](R);
[Link]();
…}}

Bien utilis le polymorphisme permet de :

- viter les codes qui comportent de nombreux branchements et tests. En effet sans
polymorphisme le code de la m thode af icher() aurais du tre comme suit :
for (int i=0; i < nbFigures; i++)
{if(figures[i]isInstanceOf Cercle) dessiner_Cercle();
if(figures[i]isInstanceOf Rectangle) dessiner_Rectangle();
…}
Il faut savoir que les op rations comportant des ifs sont co teuses au niveau processeur.
- faciliter l’extension des programmes : on peut cr er de nouvelles sous classes
sans toucher aux programmes d j crits. Par exemple, si on ajoute une classe Losange, le code
de af icher() sera toujours valable.

4. Classes et méthodes abstraites

Une m thode est dite abstraite (modi icateur abstract) si on la d clare, sans donner son
impl mentation : public void payer() ;

23
© M. Lahmer 2002-2023



é
é
f
é
é
é
é
é
é
à
é
f
é
f
é
û
ê
é
 • Une classe doit tre d clar e abstraite (abstract class) si elle contient au moins une
m thode abstraite. Mais il est possible de d clarer une classe abstraite sans aucune
m thode abstraite
• Il est interdit de cr er une instance d’une classe abstraite.
Une m thode static ne peut tre abstraite (car on ne peut red inir une m thode static)

abstract class Geometrie{ class Rectangle extends

//Methode abstraite geometrie {
abstract double perimetre();} double L,l;
} double perimetre(){
return L*l;}}

5. Les interfaces
Une interface est une « classe » purement abstraite dont toutes les m thodes sont abstraites et
publiques (les mots-cl s abstract et public sont optionnels dans la d claration des m thodes).
En fait, une interface correspond un service rendu ou un comportement qui correspond aux
m thodes de l'interface
[public] interface NomDeLInterface [extends InterfaceMere] {}
Une interface ne peut contenir que :
■ des m thodes abstract et public
■ des d initions de constantes publiques (« public static inal »)
Une interface ne peut contenir de m thodes static, inal, synchronized , native ou default
(voire la in du chapitre)
Pour impl menter une interface, il faut rajouter la d claration de la classe concern e le mot
cl implements suivi du nom de l'interface. Une classe peut impl menter une ou plusieurs
interfaces (et h riter d'une classe)

public interface Figure { class rectangle implements Figure{

void dessineToi(); void dessineToi(){
void deplaceToi(int x, int y); /*Dessiner Rectangle*/}
Position getPosition(); void deplaceToi(int x, int y){
} /*Deplacer Rectangle*/}
Position getPosition(){
/*Retourner la position du
rectangle*/}
}

Lorsqu’une classe C impl mente une interface I elle doit red inir toutes les m thodes de I, sinon
il faut la d clarer abstraite.
A partir de Java 8, il est d sormais possible de d inir dans une interface des m thodes de type
default et ou static. Une m thode de type default peut tre red inie mais une m thode static
non.

24
© M. Lahmer 2002-2023



é
é
é
é
é
é
f
é
à
é
é
f
é
ê
é
é
é
é
é
é
é
ê
à
é
é
é
à
f
f
f
é
ê
é
f
é
f
é
f
é
é
é
é
é
é
é
é
é
 4. Les Collections

1. Définitions
Une collection est un objet qui contient d’autres objets par exemple, un tableau est une
collection. Le JDK fournit d’autres types de collections sous la forme de classes et d’interfaces
d inies dans le paquetage [Link] et organis es selon 2 hi rarchies d’interfaces principales
■ Collection correspond aux interfaces des collections proprement dites

■ Map correspond aux collections index es par des cl s ; un l ment d’une map est
retrouv rapidement si on conna t sa cl .

25
© M. Lahmer 2002-2023


é
f
é
î
é
é
é
é
é
é
é
 2. L’interface Collection

1. Les méthodes d’une collection

boolean add(Object) Ajoute un objet dans une collection

void clear() Supprime tous les l ments du conteneur
boolean contains(Object) V ri ie si l’objet argument est contenu dans la
collection
boolean isEmpty() Vrai si le conteneur ne contient pas d' l ments.

boolean remove(Object) Supprime un objet de la collection

int size() Renvoie le nombre d' l ments dans le

conteneur.
Object[] toArray() Renvoie un tableau contenant tous les l ments
du conteneur.
Iterator iterator() Renvoie un Iterator qu'on peut utiliser pour
parcourir les l ments du conteneur.

2. Les itérateurs
Un it rateur (instance d’une classe qui impl mente l’interface Iterator) permet d’ num rer les
l ments contenus dans une collection. L’interface Collection fournit la m thode Iterator
iterator() qui renvoie un it rateur pour parcourir les l ments de la collection. Les principales
m thodes de Iterator sont :
■ boolean hasNext() : permet de v ri ier s'il y a un l ment qui suit
■ Object next() : retourne l’ l ment en cours et pointe sur l' l ment suivant

26
© M. Lahmer 2002-2023

é

é
é
é
f
é
é
é
é
é
é
é
é
é
é
é
f
é
é
é
é
é
é
é
é
é
é
é
é
é
é
 Iterator it=[Link]();
while ([Link]()) // tant qu’ il y a un element non parcouru
{
Object o = [Link]();
//les opérations
}

3. La classe ArrayList
Est une classe qui impl mente l’interface List. Une instance de la classe ArrayList est une sorte
de tableau qui peut contenir un nombre quelconque d’instances de la classe Object. Les
emplacements sont rep r s par des nombres entiers ou des indices ( partir de 0). Les
principales m thodes en plus de celle de Collection sont
■ Object get(int indice)
■ int indexOf(Object obj)
■ void add(int indice, Object element)
■ void set(int indice, Object obj)
■ Object remove(int index)
Le type retour de la m thode get() est Object ; on doit donc souvent caster les l ments que l’on
r cup re dans un ArrayList si on veut les utilis s. Ce probl me ne se pose plus dans JDK 1.5 et
sup rieur si on adopte le principe de g n ricit ou de template :
1) sans template
ArrayList l = new ArrayList();// création d’une Liste l
[Link]("Ahmed"); // ajouter les objets ds l
[Link]("Mohamed");
[Link]("Mustapha");
[Link]("Taib");
[Link](l); // trier les objets de l
String Nom =(String)[Link](2) ; // on utilise le cast

2) avec template

ArrayList<String>l=new ArrayList<String>();// création d’une Liste l

// ajouter les objets ds l
[Link](l); // trier les objets de l
String Nom =[Link](2) ; // Pas de cast

2. Parcours d’une ArrayList

En plus de l’Iterator, il est possible de parcourir une ArrayList en utilisant une simple boucle for
ou en passant par l’interface ListIterator.
1) Boucle for
ArrayList L = new ArrayList();// création d’une Liste L
[Link]("Ahmed"); // ajouter les objets ds L
[Link]("Mohamed");
[Link]("Mustapha");
[Link]("Taib");
[Link](L);
for(String nom :L) [Link](nom);

2) ListIterator

27
© M. Lahmer 2002-2023

é
é
è
é
é
é
é
é
é
é
é
é
è
à
é
é
 ListIterator est une interface qui h rite de Iterator, ainsi en plus des m thodes hasNext() et
next() elle dispose de deux autres m thodes suppl mentaires hasPrevious() et previous() qui
permettent de parcourir la liste dans le sens inverse.
List list = = new ArrayList();
// ajouter les objets ds List
ListIterator iterator = [Link]([Link]());
while ([Link]()) {
Object element = [Link]();
// traitement d'un élément
}

4. L’interface Map
Une Map est un ensemble de couples objets (cl , valeur) o Deux cl s ne peuvent tre gales au
sens de equals(). Dans l’algorithmique classique c’est une table de hachage (hashTable).

Cl (code Module) Valeur(Module)

IF11 M11
IF12 M12
Une entr e de la table est repr sent e par l’interface Entry qui permet de manipuler les
l ments d'une paire comme suit :
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}
getKey() et getValue() retournent respectivement la clé et la valeur associée à l’entrée en cours.
Il existe deux impl mentations de l’interface Map savoir :
■ HashMap, table de hachage ; garantit un acc s en temps constant
■ TreeMap, arbre ordonn suivant les valeurs des cl s avec acc s en log(n)
La comparaison des objets d’une Map utilise l’ordre naturel (interface Comparable) ou une
instance de Comparator. Les principales m thodes d’une hashMap sont :
• Object put(Object key, Object value)
• Object get(Object key)
• Object remove(Object key)

2. Parcours d’une Map

On peut parcourir une Map en utilisant :
Les valeurs : La m thode values() permet de convertir une hashMap en une Collection ne
contenant que les valeurs.
Les cl s : La m thode setKey() permet de convertir une hashMap en un Set ensemble de cl s.
Map hm = new HashMap();
Employe e = new Employe("Halim");
[Link]("E125");
[Link]([Link], e);
/*crée et ajoute les autres employés dans la table de hachage*/

28
© M. Lahmer 2002-2023
é

é
é
é
é
é
é
é
é
é
é
é
é
é
è
é
à
é
é
ù
è
é
é
ê
é
é
 Employe e2 = (Employe)[Link]("E369");
Collection elements = [Link]();
Iterator it = [Link]();
//Afficher tous les employes
while ([Link]()) {
[Link](
((Employe)[Link]()).getNom());}

5. Tri et Recherche dans des collections

La classe Collections contient des m thodes static, utilitaires pour travailler avec des
collections :
■ tris (sur listes)
■ recherches (sur listes)
■ copies
■ minimum et maximum
a) Tri
Si l est une liste, on peut trier l par : [Link](l). La m thode sort() ne fonctionnera que
si tous les l ments de la liste sont d’une classe qui impl mente l’interface
[Link]. Toutes les classes du JDK qui enveloppent les types primitifs (Integer
par exemple) impl mentent l’interface Comparable. Il en est de m me pour les classes du JDK
String, Date, BigInteger, BigDecimal. Cependant si on veut trier une liste d’objets qui ne sont
pas comparables par d faut il faut passer par l’interface Comparator.
Interface Comparator
Si les l ments de la collection n’implantent pas l’interface Comparable, ou si on ne veut pas les
trier suivant l’ordre donn par Comparable on construit une classe qui impl mente l’interface
Comparator, qui permettra de comparer 2 l ments de la collection. Elle comporte une seule
m thode int compare(Object o1, Object o2) qui doit renvoyer
■ un entier positif si o1 est « plus grand » que o2
■ 0 si o1 a la m me valeur (au sens de equals) que o2
■ un entier n gatif si o1 est « plus petit » que o2
//Critère de comparaison
public class CompareSalaire implements Comparator <Employe>{
public int compare(Object o1, Object o2) {
double s1 = ((Employe) o1).getSalaire();
double s2 = ((Employe) o2).getSalaire();
return (int)(s1 - s2);
}}
//..
List employes = new ArrayList();
// On ajoute les employés . . .
[Link](employes,new CompareSalaire());
[Link](employes);

Depuis java 8, il est possible lorsqu’une interface d inie une seule m thode on peut utiliser le
Lambda Langage .
[Link](employes,new Comparator(((Employe) o1, (Employe) o2)->{
return (int)([Link]()- [Link]());

});

29
© M. Lahmer 2002-2023

é
é
é
é
ê
é
é
é
é
é
é
é
é
é
f
é
ê
é
é
é
 b) Recherche
Pour rechercher la position d’un objet dans une liste on peut utiliser les m thodes suivantes :
■ int binarySearch(List l, Object obj)
■ int binarySearch(List l, Object obj, Comparator c)
La liste doit tre tri e en ordre croissant suivant l’ordre naturel (interface Comparable) ou
suivant le comparateur, pour la 2 me m thode.

6. La gestion du temps (Date/Time)

Avant JDK 1.8, on avait quelques classes pour l’obtention et le formatage de la date r partie :
[Link] (Date/Time), [Link] (Calendrier) , [Link] et
[Link] (formatage de la date).
Date now = new Date();
[Link](now); // Date time Système

// Utilisation DateFormat
DateFormat formatter = [Link](); // Date and time
String dateStr = [Link](now);
[Link](dateStr);
formatter = [Link](); // time only
[Link]([Link](now));

// Utilisation de locale (Propriétés locale au système)

formatter = [Link]([Link],
[Link], [Link]);
[Link]([Link](now));

// Utilisation SimpleDateFormat
SimpleDateFormat simpleFormatter = new SimpleDateFormat("E [Link] 'at'
hh:mm:ss a zzz");
[Link]([Link](now));

A partir de JDK 1.8, on a introduit l’api [Link] qui concr tise toutes les fonctionnalit s de la
gestion du temps : [Link].*, [Link].*, [Link].*,
[Link].*

LocalDate today = [Link]();

DayOfWeek dow = [Link];
LocalDate dateOfBirth = [Link](1972, [Link], 23);
[Link]("%s%n", [Link](3));// JEUDI
[Link]("%d%n", [Link]()); //29
YearMonth date = [Link](); // Mois de l annee
boolean validLeapYear = [Link](2012).isLeap();//est c année bissextile

30
© M. Lahmer 2002-2023

ê
é
è
é
é
é
é
é
 4. Les entrées sorties

1. Les flux java

Il existe plusieurs classes en java d inies dans [Link] qui permettent de traiter les lux d’entr es
sorties qu’on peut classi ier en deux cat gories :
■ classes de lux d’octets : input pour les entr es et (output) pour les sorties
■ classes de lux de caract res : Reader pour les entr es et Writer pour les sorties
Il est noter que le package [Link] contient d’autres classes pour le iltrage des donn es, la
concat nation de lux, la manipulation de ichiers, etc ….

2. La classe File
Cette classe fournie une d inition plateform-independent des ichiers et des r pertoires : Un
objet de type File peut repr senter un ichier ou un r pertoire. Elle permet de r aliser les
op rations de base sur les ichiers tels que le listage d’un r pertoire, la v ri ication de l’existence
d’un ichier, etc…. Une partie des m thodes de la File sont illustr es ci-dessous :

Nom méthode rôle

boolean canRead(), boolean indique si le ichier peut tre lu, crit ou ex cut
canWrite() et boolean
canExecute()
File[] listRoots() Retourne le disque associ au ichier sous Linux c’est / mais
pour windows c’est C : ou D : ou autre
boolean delete() d truire le ichier ou le r pertoire. Le bool en indique le succ s
de l'op ration
boolean exists() indique si le ichier existe physiquement
String getAbsolutePath() renvoie le chemin absolu du ichier
String getPath() renvoie le chemin du ichier
boolean isDirectory() indique si le ichier est un r pertoire
boolean isFile() indique si l'objet repr sente un ichier
long length() renvoie la longueur du ichier
String[] list() renvoie la liste des ichiers et r pertoire contenu dans le
r pertoire
Depuis la version 1.2 du J.D.K., de nombreuses fonctionnalit s ont t ajout es cette classe :
• la cr ation de ichiers temporaires (createNewFile, createTempFile)

31
© M. Lahmer 2002-2023

é
é
é
é
f
à
é
é
f
f
f
f
f
f
f
f
f
f
é
f
è
f
é
ê
é
f
é
é
f
f
é
f
é
f
é
é
é
f
é
f
é
f
é
é
é
é
é
é
é
è
é
f
é
é
é
f
é
f
à
é
f
é
é
é
 • la gestion des attributs "cach " et "lecture seule" (isHidden, isReadOnly)
• des m thodes qui renvoient des objets de type File au lieu de type String ( getParentFile,
getAbsoluteFile, getCanonicalFile, listFiles)
Les principaux constructeurs sont :
■ File(File rep, String nom)
■ File(String chemin)
■ File(String rep, String nom)

public static void main(String[]args) {

Scanner in = new Scanner([Link]);
File fichier=new File([Link]());// Lire le nom d’un fichier
if (![Link]()) {
[Link]("le fichier "+nomFichier+"n'existe pas");
[Link](1);
}
[Link]("Nom du fichier : "+[Link]());
[Link]("Chemin du fichier : "+[Link]());
[Link]("Chemin absolu : "+[Link]());
[Link]("Droits : r("+[Link]());
[Link](")w( "+[Link]()+ ")");

if ([Link]() ) {
[Link](" contenu du repertoire ");
File fichiers[] = [Link]();
for(int i = 0; i <[Link]; i++) {
if (fichiers[i].isDirectory())
[Link]("d-"+fichiers[i].getName());
else
[Link]("f-"+fichiers[i].getName());
}}}

3. Les flux octets

Ce sont des lux d’entr es sorties de base ils permettent de lire et crire tout type de donn es. On
se contentera dans ce cours par tudier les classes File(Input|Output)Stream, Data(Input|
Output)Stream et Object(Input|Output)Stream.

32
© M. Lahmer 2002-2023

é
f
é
é
é
é
é
 1. File(Input|Output)Stream
Ces classes permettent d'acc der en lecture et en criture un ichier

import [Link].*;
public class CopyBytes {
public static void main(String[] args) throws IOException {
File inputFile = new File("[Link]");
File outputFile = new File("[Link]");
FileInputStream in = new FileInputStream(inputFile);
FileOutputStream out = new FileOutputStream(outputFile);
int c;
while ((c = [Link]()) != -1)
[Link](c);
[Link](); [Link](); }}

33
© M. Lahmer 2002-2023



é
é
à
f
 2. Data (Input|Output) Stream
Ce sont ces classes qui poss dent des critures ou lectures de plus haut niveau que de simples
octets (des entiers, des lottants, ...).
■ DataInputStream ,
public inal boolean readBoolean() throws IOException
public inal char readChar() throws IOException
public inal int readInt() throws IOException
…
■ DataOutputStream,
public inal void writeBoolean(boolean) throws IOException,
public inal void writeChar(int) throws IOException,
public inal void writeInt(int) throws IOException
Si vous crivez un entier avec writeInt() il faut le lire avec readInt(). Les cha nes de caract res
sont lues par la m thode readUTF(). Pour lire un ichier texte ligne par ligne on peut utiliser la
m thode readLine(). Cette derni re a t d pr cier et donc vous pouvez la remplacer par la
m thode de BuffredReader comme suit :
File inputFile = new File("[Link]");
DataInputStream in = new DataInputStream(inputFile) ;
BufferedReader brin = new BufferedReader(in) ;
String L=[Link]();

4. Les flux caractères

Ces classes permettent de faire des entr es sorties en mode caract res mais en unicode (2
octets).

34
© M. Lahmer 2002-2023


é
é
f
f
f
f
f
f
é
é
f
è
è
é
é
é
é
é
é
f
è
î
è
 import [Link].*;
public class Copy {
public static void main(String[] args) throws IOException {
File inputFile = new File("[Link]");
File outputFile = new File("[Link]");

FileReader in = new FileReader(inputFile);

FileWriter out = new FileWriter(outputFile);
int c;

while ((c = [Link]()) != -1)

[Link](c);

[Link]();
[Link]();
}}

5. Les filtres
Un iltre permet de s lectionner les ichiers qui v ri ient certains crit res. En Java un iltre est un
objet d'une classe qui impl mente l'interface FilenameFilter. Cette classe doit donner une
d inition de la m thode public boolean accept(File rep, Stringnom) et seuls les noms de ichiers
qui renvoie true par cette m thode seront af ich s.
import [Link].*;
class Filtre implements FilenameFilter {
public boolean accept(File rep, String nom) {
if ([Link](".java")) return true;
return false;}
//dans une classe de test
String nomFics[ ] = (new File(rep)).list(new Filtre());}

6. Sérialisation des objets

En Java, seules les donn es (et les noms de leur classe ou type) sont sauvegard es (pas les
m thodes ou constructeurs). Si un objet contient un champ qui est un objet, cet objet inclus est
aussi s rialis et on obtient ainsi un arbre (un graphe) de s rialisation d'objets.
Des objets de certaines classes ne peuvent pas tre s rialis s : c'est le cas des Threads, des
FileXXXputStream, …

35
© M. Lahmer 2002-2023


é
é
f
f
é
é
é
é
é
é
é
f
f
é
é
ê
f
é
é
é
è
é
f
f
 Pour indiquer que les objets d'une classe peuvent tre persistants on indique que cette classe
impl mente l'interface Serializable.
Public class A implements Serializable{
// attributes sérializables
//…}
Certaines classes sont par d faut s rializable (String et Date). Les lux Objets en java
(Object(Input|Output)Stream) permettent de lire et crire des objets s rialisables.
// Ecriture
FileOutputStream fos = new FileOutputStream("tmp");
ObjectOutputStream oos = new ObjectOutputStream(fos);
[Link]("Today");
[Link](new Date());
[Link]();
// Lecture
FileInputStream fis = new FileInputStream("tmp");
ObjectInputStream ois = new ObjectInputStream(fis);
String today = (String)[Link]();
Date date = (Date)[Link]();
Par d faut, tous les champs d’un objets sont s rialis s (y compris private) Cela peut poser des
probl mes de s curit . Alors il existe 3 solutions possibles:
■ R crire les m thodes writeObjet() et readObject()
■ Utiliser le mot cl transient permet d'indiquer qu'un champs ne doit pas tre
s rialis : private transient passwd;

36
© M. Lahmer 2002-2023

é
é
é
é
è
é
é
é
é
é
é
é
é
é
ê
é
é
é
f
ê
 6. Le graphique en Java

1. Graphique en Java

1. Paquetages de base
Une interface graphique est form e d’une ou plusieurs fen tres qui contiennent divers
composants graphiques (widgets) tels que
■ boutons
■ listes d roulantes
■ menus
■ champ texte, etc...
Les interfaces graphiques sont souvent appel s GUI d’apr s l’anglais Graphical User Interface.
L’utilisation d’interfaces graphiques impose une programmation « conduite par les
v nements ». On peut distinguer deux packges de base pour la r alisation des GUI en java :
[Link] (Abstract Window Toolkit, JDK 1.1) et [Link] (JDK 1.2) qui font partie de JFC (Java
Foundation Classes).
Techniquement Swing est construit au-dessus de AWT
■ m me gestion des v nements
■ les classes de Swing h ritent des classes de AWT

2. Les principaux composants awt

37
© M. Lahmer 2002-2023
é


ê
é
é
é
é
é
é
é
è
ê
é
 3. Les principaux composants swing
Tous les composants de AWT ont leur quivalent dans Swing en plus joli et avec plus de
fonctionnalit s. Syntaxiquement un objet swing est un objet awt avec un J comme pr ixe ainsi
une tiquette Label en awt devient un JLabel en swing. En plus Swing offre de nombreux
composants qui n’existent pas dans AWT. La igure ci-dessous illustre quelques exemples de ces
composants.

4. Premier programme Swing

import [Link].*;
public class HelloWorldSwing {
//Déclaration d’une fenêtre et d’une étiquette.
JFrame frm;
JLabel lbl;
public void GUI() {
//Création et initiation de la fenêtre.
frm = new JFrame("HelloWorldSwing");
//création d’une étiquette "Hello World".
lbl = new JLabel("Hello World");
//être sure d’avoir une bonne décoration v1.4.
[Link](true);
//Fermer l’application dès qu’on clique sur le bouton fermer
[Link](JFrame.EXIT_ON_CLOSE);
//ajouter le label à la fenêtre
[Link](lbl);
//Ajuster la taille de la fenêtre à la taille de ses composants
[Link]();
//Afficher la fenêtre.
[Link](true); }
}
class Test{
public static void main(String[] args) {
( new HelloWorldSwing()). GUI(); }
}

38
© M. Lahmer 2002-2023


é
é
é
f
é
f
 2. Composants lourds/ légers
Pour af icher des fen tres (instances de JFrame), Java s’appuie sur les fen tres fournies par le
syst me d’exploitation h te dans lequel tourne la JVM, on dit que les JFrame sont des
composants lourds. Au contraire de AWT qui utilise les widgets du syst me d’exploitation pour
tous ses composants graphiques (fen tres, boutons, listes, menus, etc.), Swing ne les utilise que
pour les fen tres de base « top-level ». Les autres composants, dits l gers, sont dessin s dans ces
containers lourds, par du code « pur Java »

1. Les conteneurs
Pour construire une interface graphique avec Swing, il faut cr er un (ou plusieurs) container
lourd et placer l’int rieur les composants l gers qui forment l'interface graphique.

Il y a 3 sortes de containers lourds (un autre, JWindow, est rarement utilis ) :

■ JFrame fen tre pour les applications
■ JApplet pour les applets
■ JDialog pour les fen tres de dialogue
Il existe d’autres types de conteneurs qu’on appel interm diaire l gers tels que JPanel,
JScrollPane, JSplitPane, JTabbedPane qui servent regrouper des composants dans une zone
sp ci ique d’un conteneur lourds.
Les principales méthodes

Méthode Rôle
component add(Component comp) pour ajouter le composant sp ci i la in du
conteneur

component add(Component comp, int Ajoute le composant sp ci i la position

index) sp ci i par index (0…)

39
© M. Lahmer 2002-2023

é
é
è
f
f
é
f
ê
ê
à
ê
é
ê
ô
é
f
é
é
f
à
é
ê
à
f
é
à
é
é
é
è
é
é
ê
é
 void remove(int index) Supprime le composant situ la position index
void remove(Component comp) Supprime le composant sp ci i
void removeAll() Supprime tous les composants
void setLayout(LayoutManager mgr) D init le Layout (Mise en page) de ce conteneur
void paint(Graphics g) Pour dessiner
void repaint() Met jour le dessin du conteneur

2. La fenêtre JFrame

Taille d’une fenêtre

La m thode pack() donne la fen tre la taille n cessaire pour respecter les tailles pr f r es des
composants de la fen tre. Sinon si vous voulez une taille ou un emplacement pr cis sur l' cran
(en pixels) vous pouvez vous servir des m thodes suivantes :
■ setLocation(int xhg, int yhg) (ou Point en param tre)
■ setSize(int largeur, int hauteur) (ou Dimension en param tre)
■ setBounds(int x, int y, int largeur, int hauteur) (ou Rectangle en param tre)
La taille de l’ cran ainsi que sa r solution en cours peuvent tre obtenues en utilisant la classe
abstraite [Link] impl ment dans AWT. Quelques m thodes publiques de cette classe
sont :getScreenSize, getScreenResolution, getDefaultToolkit, getImage.

//Centrage de la fenêtre
Toolkit tk = [Link]();
Dimension d = [Link]();
int hauteurEcran = [Link];
int largeurEcran = [Link];
//Ajuster la taille et la position de la fenêtre.
[Link](largeurEcran/2, hauteurEcran/2);
[Link](largeurEcran/4,hauteurEcran/4);

3. Composants de base

1. Etiquette JLabel
Avec un Jlabel, on peut cr er un texte « tiquette » et/ou une image. On peut galement int grer
du HTML, sp ci ier la position du texte par rapport l’image ou sp ci ier l’emplacement par
rapport son conteneur. Quelques m thodes publiques de cette classe :
■ JLabel(String, Icon, int) // Création d’un JLabel
■ void setText(String) // Modi ie le texte du JLabel
■ String getText() // retourne le texte du Jlabel
■ void setIcon(Icon) et Icon getIcon()
■ // spéci ier la position du texte par rapport à l’icone
■ void setHorizontalTextPosition(int)
■ void setVerticalTextPosition( int)

40
© M. Lahmer 2002-2023

é
f
à
é
f
à
é
é
f
ê
é
é
à
f
é
f
à
é
é
é
ê
é
é
é
é
é
è
à
è
ê
é
é
f
è
é
é
é
é
é
é
é
 ■ void setToolTipText(String) //associe un info bulles

public class LabelPanel extends JPanel {

public LabelPanel() {
JLabel testLabel = new JLabel("Icon Big Label");
[Link]("a Label with Icone");
// Créer une nouvelle fonte
Font serif32Font = new Font("Serif",[Link]|[Link],32);
// Donner une fonte au contenu du Label
[Link](serif32Font);
// Créer une icone
Icon soundIcon = new ImageIcon("images/[Link]");
// Placer l Icon dans le label
[Link](soundIcon);
// Alligner le Texte à droite de l’icone
[Link]([Link]);
// Ajouter le label au panel
add(testLabel);}}

2. Bouton JButton
Comme le JLabel, on peut cr er un JButton avec un texte (bien videment HTML) et ou une ic ne.
//Création d’un Bouton avec icone
JButton precedent = new JButton("Precedent",leftButtonIcon);
//Création d’un Bouton avec texte HTML
new JButton("<html><h1>Ligne 1</h1></html>");
//positionnement du texte / à l’Icone
[Link]([Link]);
//Associer un raccourcis clavier au bouton ici p
[Link](KeyEvent.VK_P);
//associer une action à un bouton
[Link]("disable");
Quelques m thodes utiles
■ void setText(String) et String getText()
■ void setIcon(Icon)et Icon getIcon()
■ char getMnemonic() String getActionCommand()
■ void setEnabled(Boolean)

3. Les différents composants texte

La classe abstraite JTextComponent est la classe m re de tous les composants permettant la
saisie de texte.
■ JTextField : entrer d’une seule ligne
■ JTextField tf= new JTextField();
■ [Link]("nouveau Texte");
■ JPasswordField : entrer un mot de passe non af ich sur l' cran
■ JPasswordField text ield = new JPasswordField (20);
■ text [Link]('#');//* par defaut
■ char[] input = text [Link]();
■ JTextArea : quelques lignes de texte avec une seule police de caract res
■ textArea = new JTextArea(5, 40);//lignes, colonnes
■ append(String) ajouter du texte la in

41
© M. Lahmer 2002-2023

f
é
f
f
é
à
f
f
é
è
é
é
è
ô
 ■ JTextPane : documents avec plusieurs polices et des images et composants inclus (pas
tudi dans cette partie du cours)

4. Mise en page des composants dans un conteneur

Si vous ajoutez plusieurs composants un conteneur sans sp ci ier de Layout, seul le dernier
sera visible. Les Layouts ou Layout Managers sont des classes qui impl mentent une interface
LayoutManager, et repr sentent des mod les de positionnement des composants. On peut citer
comme exemples :
■ BorderLayout
■ BoxLayout
■ CardLayout
■ FlowLayout
■ GridBagLayout
■ GridLayout
■ GroupLayout
■ SpringLayout

1. FlowLayout
Quand un conteneur utilise FlowLayout, les composants sont arrang s dans l’ordre de leur ajout
dans le conteneur, depuis le haut, de gauche droite. On ne passe la prochaine ligne que quand

42
© M. Lahmer 2002-2023
é


é
é
à
è
à
é
à
f
é
é
 l’espace restant sur la ligne n’est plus suf isant pour contenir le composant. Il est utilis par
d faut dans les applets.

FlowLayout FLayout = new FlowLayout();

JFrame frm =new JFrame("FlowLayoutDemo");
…
[Link](FLayout);
[Link](new JButton("Button 1"));
[Link](new JButton("Button 2"));
[Link](new JButton("Button 3"));
[Link](new JButton("Long-Named Button 4"));
[Link](new JButton("5"));

2. BorderLayout
Quand on ajoute un composant un contenaire qui utilise BorderLayout, on sp ci ie la r gion
dans laquelle on veut le positionner. Si la r gion n’est pas sp ci i e, il le positionne
automatiquement dans le centre. Les 5 r gions utilis s par un BorderLayout sont :NORTH, WEST,
CENTER, EAST et SOUTH

JButton button = new JButton("Button 1 (PAGE_START)");

JPanel pane=new JPanel("BorderLAyoutDemo");
[Link](button, [Link]);
button = new JButton("Button 2 (CENTER)");
[Link](new Dimension(200, 100));
[Link](button, [Link]);
button = new JButton("Button 3 (LINE_START)");
[Link](button, [Link]);
button = new JButton("Long-Named Button 4 (PAGE_END)");
[Link](button, [Link]);
button = new JButton("5 (LINE_END)");
[Link](button, [Link]);

3. GridLayout
Le GridLayout arrange les composants dans un nombre donn de colonnes et de lignes. Il
commence en haut gauche, et passe la colonne suivante, et ainsi de suite, jusqu’ la derni re

43
© M. Lahmer 2002-2023



é
à
à
à
é
f
é
é
é
é
f
é
é
à
f
é
é
è
 colonne, puis passe la deuxi me ligne de la premi re colonne, … etc. Le nombre de colonnes et
de lignes est sp ci i dans les arguments du constructeur :
new GridLayout(nombre_ligne, nombre_colonnes)
Le nombre de colonnes et de lignes ne peuvent pas tre tous les deux des z ros. Si l’un ou l’autre
est un z ro, il est interpr t comme d terminer par le nombre des composants.

JPanel p = new JPanel();

[Link](new GridLayout(3,2));
[Link](new JButton("1"));
[Link](new JButton("2"));
[Link](new JButton("3"));
[Link](new JButton("4"));
[Link](new JButton("5"));
[Link](new JButton("6"));

5. Traitement des événements

1. principe
L'utilisateur utilise le clavier et la souris pour intervenir sur le d roulement du programme. Le
syst me d’exploitation engendre des v nements partir des actions de l’utilisateur ensuite le
programme doit lier des traitements ces v nements. On distingue deux types d’ v nement
Bas Niveau :
■
■ appui sur un bouton de souris ou une touche du clavier
■ rel chement du bouton de souris ou de la touche
■ d placer le pointeur de souris
■ Logique
■ frappe d'un A majuscule
■ clic de souris
■ choisir un l ment dans une liste
Le JDK utilise une architecture de type « observateur - observ ». Les composants graphiques
(comme les boutons) sont les observ s. Chacun de ces composants a ses observateurs (ou
couteurs, listeners). Ces couteurs sont pr venus par le composant graphique d s qu’un
v nement qui les concerne survient sur ce composant. Le code de ces couteurs ex cute les
actions effectuer en r action l’ v nement.

44
© M. Lahmer 2002-2023

é
é

é
é
â
è
é
à
é
é
é
f
é
à
é
é
é
é
è
à
é
é
à
à
é
é
é
é
é
é
é
à
è
ê
é
é
é
é
é
é
è
é
 2. Classes d’événements

3.

Ev nement, Interface de l’ v nement et Composants supportant cet v nement

m thodes d’ajout et de suppression associ es

Ecouteur Composant
ActionEvent JButton, JList, JTextField, JMenuItem and its
ActionListener derivatives including JCheckBoxMenuItem,
addActionListener( ) JMenu, and JpopupMenu.
removeActionListener( )

FocusEvent Component and derivatives*.

FocusListener
addFocusListener( )
removeFocusListener( )

KeyEvent Component and derivatives*.

KeyListener
addKeyListener( )
removeKeyListener( )

MouseEvent (for both clicks and motion) Component and derivatives*.

MouseListener
addMouseListener( )
removeMouseListener( )

MouseEvent (for both clicks and motion) Component and derivatives*.

MouseMotionListener
addMouseMotionListener( )
removeMouseMotionListener( )

ItemEvent JCheckBox, JCheckBoxMenuItem, JComboBox,

ItemListener JList, and anything that implements the
addItemListener( ) ItemSelectable interface
removeItemListener( )

WindowEvent Window and its derivatives, including JDialog,

WindowListener JFileDialog, and JFrame.
addWindowListener( )
removeWindowListener( )

45
© M. Lahmer 2002-2023

é
é
é
é
é
é
é
 3. Ecouteur vs Adaptateur
Pour viter au programmeur d’avoir implanter toutes les m thodes d’une interface
« couteur », AWT fournit des classes (on les appelle des adaptateurs), qui impl mentent toutes
ces m thodes. Le code des m thodes ne fait rien. Ça permet au programmeur de ne red inir
dans une sous-classe que les m thodes qui l’int resse.
Les classes suivantes du paquetage [Link] sont des adaptateurs : KeyAdapter,
M o u s e Ad a p te r , M o u s e M o t i o n Ad a p te r , Fo c u s Ad a p te r , Co m p o n e n t Ad a p te r ,
WindowAdapter.

Supposons que vous voulez traiter le clique de la souris donc il suf it d’impl menter le
traitement de la m thode mouseClicked comme suit :
addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
[Link](0);}});
Mais si vous utilisez un Listener au lieu d’un Adapter il faut impl menter toutes les m thodes de
l’interface MouseListener.

Listener vs. adapter Methods in interface

ActionListener actionPerformed(ActionEvent)
AdjustmentListener adjustmentValueChanged( AdjustmentEvent)
ContainerListener componentHidden(ComponentEvent)
ContainerAdapter componentShown(ComponentEvent)
componentMoved(ComponentEvent)
componentResized(ComponentEvent)
FocusListener focusGained(FocusEvent)
FocusAdapter focusLost(FocusEvent)
KeyListener keyPressed(KeyEvent)
KeyAdapter keyReleased(KeyEvent)
keyTyped(KeyEvent)
MouseListener mouseClicked(MouseEvent)
MouseAdapter mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
MouseMotionListener mouseDragged(MouseEvent)
MouseMotionAdapter mouseMoved(MouseEvent)

4. Exemple Complet sur ActionEvent

Cette classe d crit des v nements de haut niveau tr s utilis s qui correspondent un type
d’action de l’utilisateur qui va le plus souvent d clencher un traitement (une action) :

46
© M. Lahmer 2002-2023

é
é
é
é
é
é
é
é
é
à
é
é
è
é
é
é
f
é
é
é
à
é
f
 ■ clic sur un bouton
■ return dans une zone de saisie de texte
■ choix dans un menu
Ces v nements sont tr s fr quemment utilis s et ils sont tr s simples traiter. Un objet
ecouteur int ress par les v nements de type « action » (classe ActionEvent) doit appartenir
une classe qui impl mente l’interface [Link]. L’exemple suivant af iche
le nombre de clique sur le bouton ok dans le bouton lui-m me.
//Fenetre est un écouteur de ActionEvent
class Fenetre extends JFrame implements ActionListener{
int nbClique=0;
public Fenetre(){
JButton ok=new JButton(’’OK’’+nbClique);
//inscription du bouton ok auprès de l’écouteur
[Link](this);
getContentPane().add(ok);}

//message déclenché lorsque l’utilisateur clique sur le bouton

public void actionPerformed(ActionEvent e){
nbClique++;
Object source = [Link]();
If (Object==ok) [Link](’’OK’’+nbClique);
}}
Ce e façon de faire est un peu lourde c’est pourquoi en u lise généralement un écouteur anonyme
de la façon suivante :
class Fenetre extends JFrame{
int nbClique=0;
public Fenetre(){
JButton ok=new JButton(’’OK’’+nbClique);
//inscription du bouton ok auprès de l’écouteur
[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
nbClique++;
[Link](’’OK’’+nbClique);
} });}}

Depuis java 8, il est possible lorsqu’une interface d inie une seule m thode d’utiliser le Lambda
Langage .
[Link](e ->{nbClique++;
[Link](’’OK’’+nbClique);});

6. Les autres Composants graphiques

JCheckBox zone à cocher

Une zone cocher Java est trait e en tant que bouton et elle peut tre int gr e un menu en
utilisant la classe JCheckBoxMenuItem.
//Création d’un checkBox avec icône
JCheckBox cbn= new JCheckBox("No Choose Me", false);
JCheckBox cbc= new JCheckBox("Choose Me");
//selectionner cbn par defaut
[Link](true);
//recuperer l etat d un checkbox
boolean etat=[Link]()
// associer un raccourcis clavier
[Link](c);
//Ecouteur JCheckBox

47
© M. Lahmer 2002-2023

tt
é
é
à
é
é
é
è
é
é
é
é
é
é
f
ti
ê
è
ê
é
é
à
é
à
f
à
 cbc. addItemListener(new ItemListener(){
public void itemStateChanged(ItemEvent e)
{
// faire quelques choses}}) ;

JRadioButton
Dans awt, les boutons radio sont des checkboxs qui appartiennent au m me CheckboxGroup.
Swing offre un nouveau composant qui est JRadioButton et qu’on peut est ajout un
ButtonGroup. Comme CheckboxGroup, le ButtonGroup est un composant logique qui n’a aucun
effet visuel
ButtonGroup Payement = new ButtonGroup();
JRadioButton btrCheque = new JRadioButton("Chèque");
JRadioButton btrEspece = new JRadioButton("Espèce");
// ajouter le bouton au groupe
[Link] (btrCheque);
[Link] (btrEspece);
[Link](true); [Link](E);

JComboBox Zone de Liste modifiable

M me fonctionnement que le composant Choice avec quelques comportements suppl mentaires.
Il permet un utilisateur de faire un ou plusieurs choix la fois. La forme par d faut d’un
JcomboBox est non ditable.
//crérer un combobox
String[] Villes = {"Rabat", "Casa", "Oujda", "Layoune"};
JComboBox cbVilles= new JComboBox() ;
//Ajouter les éléments à la liste
for (int i=0;i<[Link];i++) { [Link] (Villes[i]);}
// On peut initialiser la liste au moment de sa création
JComboBox cbVilles= new JComboBox(Villes) ;
// choisir un element par defaut
[Link]("Rabat");//setSelectedIndex(0)
Méthodes Rôles
insertItemAt(Objetc , int) Ajouter / R cup rer un l ment dans une position
Object getItemAt(int) ou sp ci ique ou s lectionn
Object getSelectedItem()
removeAllItems() removeItemAt(int) Supprimer un ou plusieurs l ments
void removeItem(Object)
s e t E d i t a b l e ( B o o l e a n ) i s E d i t a b l e ( ) / Modi ier l’ tat de la Combo et r cup rer le nombre
getItemCount() d’ l ments

ActionListener Les couteurs possibles

ItemListener

48
© M. Lahmer 2002-2023

é
ê
é
é
é
f
f
é
à
é
é
é
é
é
é
é
é
é
é
é
à
ê
é
é
é
à
 Liste non modi iable JList
Une JList permet d’af icher des valeurs sous forme d’une ou plusieurs colonnes et est
g n ralement int gr e dans une JScrollPane. Une JList est un composant qui impl mente le
Mod le MVC l’instar de JTable, JTree,…
• Création d’une JList

JList list = new JList(data); //data de type Object[]

//Pour sélectionner un élément à la fois

[Link](ListSelectionModel.SINGLE_SELECTION
);

//Pour sélectionner plusieurs éléments consécutifs

[Link](ListSelectionModel.SINGLE_INTERVAL_
SELECTION);

//Pour sélectionner plusieurs éléments

[Link](ListSelectionModel.
MULTIPLE_INTERVAL_SELECTION);

• Quelques méthodes
Le plus important dans une JList est de pouvoir r cup rer l’ l ment ou les l ments
s lectionn s. Pour cela plusieurs m thodes sont disponibles :

Méthodes Rôles
int getSelectedIndex() R cup rer l’indexe de l’ l ment s lectionn
int getMinSelectionIndex() R cup rer l’indexe minimal est maximal de la s lection
int getMaxSelectionIndex()
int[] getSelectedIndices() R cup rer tous les indexes s lectionn s dans un tableau
en ordre croissant
Object getSelectedValue() R cup rer l’objet s lectionn au lieu de l’indice,
n’oublier pas de faire le cast
Object[] getSelectedValues() R cup rer les objets s lectionn s dans un tableau en
ordre croissant
L’utilisation standard d’une liste est de demander l’utilisateur de cliquer sur un bouton
lorsqu’il a ini de faire ses choix dans la liste. Par ailleurs Il est rare d’ crire un couteur de liste
et on r cup re alors la s lection de l’utilisateur par une des m thodes pr sent es ci-dessus.
Sinon, La classe d'un couteur de liste doit impl menter l'interface ListSelectionListener qui
contient la m thode void valueChanged(ListSelectionEvent e).

49
© M. Lahmer 2002-2023




é
é
é
é
é
é
é
é
è
é
é
é
é
é
é
é
f
è
à
é
f
é
é
é
é
é
é
f
é
é
é
é
é
é
é
é
é
é
é
à
é
é
é
é
é
é
é
é
é
é
é
é
 • Modèle de JList
On peut cr er une JList en l’associant mod le qui fournit les donn es af ich es par la liste :
public JList(ListModel dataModel). ListModel est une interface dont le corps est ci-
dessous :

public interface ListModel {

int getSize();
Object getElementAt(int i);
void addListDataListener(ListDataListener l);
void removeListDataListener(ListDataListener l);}

Pour crire une classe qui impl mente ListModel, le plus simple est d'h riter de la classe
abstraite AbstractListModel qui impl mente les 2 m thodes de ListModel qui ajoutent et
enl vent les couteurs. Les plus simples ont un mod le de la classe DefaultListModel qui
h rite de la classe AbstractListModel et offre des m thodes d’ajout, de suppression et de
r cup ration des l ments de la JList.
Exemple
ListModel pays = new DefaultListModel();
[Link]("Maroc");
[Link]("France");
[Link]("Italie");
[Link]("Espagne");
JList liste = new JList(pays);
• Création d’un nouveau modèle
Pour cr er un nouveau mod le de JList il suf it d’ tendre la classe AbstractListModel et
d’impl menter les m thodes dont vous avez besoins.
import [Link].*;
class ProduitModel extends AbstractListModel
{
public Vector produits;
public ProduitModel()
{produits = new Vector();}
public int getSize(){return [Link](); }
public Object getElementAt(int j)
{return [Link](j);}
public void addElement(Object a)
{[Link](a);
[Link](this,0,getSize()-1);
}}

La méthode ireIntervalAdded permet de rafraîchir le contenu de la JList en intégrant le nouveau

produit ajouté.

Les boîtes de messages

JOptionPane est un composant l ger, classe ille de Jcomponent elle permet d’avoir tr s
simplement les cas les plus fr quents de fen tres de dialogue message d'information avec
bouton OK (showMessageDialog) demande de con irmation avec boutons Oui, Non et Cancel
(showCon irmDialog) possibilit de con igurer les boutons avec showOptionDialog saisie

50
© M. Lahmer 2002-2023

é
é
è
é
é
é
é
é
f
f
é
é
é
é
è
é
é
é
é
à
é
f
è
f
ê
f
é
f
è
é
é
é
f
é
é
è
 d'une information sous forme de texte, showInputDialog. JDialog (composant lourd) est
utilis e pour les cas non pr vues par JOptionPane .
Les arguments complets de JoptionPane sont :
■ Component frame // associée à la boite de dialogue
■ Object message // message à af icher
■ String titre // le titre de la boite de dialogue
■ int TypeBouton // spéci ier les boutons à faire apparaître
■ int TypeIcone // détermine l’icône à af icher
■ Object[] options // le message à af icher sur chaque bouton
■ Object initialValue // le bouton sélectionné par défaut
Pour af icher un message d’erreur :
[Link](null, "Erreur de saisie", "alert",
JOptionPane.ERROR_MESSAGE);
Pour af icher un message de con irmation avec deux boutons oui/non par d faut
[Link] irmDialog(null,
"Voulez vous vraiment Quitter", "Quitter", JOptionPane.YES_NO_OPTION);
On peut indiquer un type de message qui indiquera l'ic ne af ich e en haut, gauche de la
fen tre (message d'information par d faut)
■ JOptionPane.INFORMATION_MESSAGE
■ JOptionPane.ERROR_MESSAGE
■ JOptionPane.WARNING_MESSAGE
■ JOptionPane.QUESTION_MESSAGE
■ JOptionPane.PLAIN_MESSAGE (pas d’icône)
Les types de boutons af icher d pendent de la m thode appel e :
■ showMessageDialog : bouton Ok
■ showInputDialog : Ok et Cancel
■ showCon irmDialog : d pend du param tre pass ; les diff rentes possibilit s
sont :
■ DEFAULT_OPTION
■ YES_NO_OPTION
■ YES_NO_CANCEL_OPTION
■ OK_CANCEL_OPTION
■ showOptionDialog : selon le tableau d'objet pass en param tres (vous pouvez
franciser le texte af icher sur les boutons)

51
© M. Lahmer 2002-2023

ê
é
f
f
f
à
f
à
f
f
é
f
é
f
f
é
f
é
f
è
é
é
é
ô
é
è
é
f
é
é
é
à
 String [] options={"oui","non"};
int n =
[Link](this,
"voulez vous vraiment Quitter?","Quitter",
JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE,
null,options,options[0]);
if(n==1) [Link]();

Les Menus

Le mod le d’utilisation des menu swing est peut pr t identique celui des awt. Les classes
de menu (JMenuItem, JCheckBoxMenuItem, JMenu, et JMenuBar) sont toutes des sous
classe de Jcomponent. Donc on peut placer un JMenuBar dans conteneur par setMenuBar().
On peut associer une ic ne un JMenuItem. JPopupMenu ou Les menus pop-up sont des
menus qui apparaissent la demande (click bouton droit de la souris)
Exemple de construction de Menu
On va cr er un menu Fichier avec trois options (nouveau, ouvrir et fermer).
//Création d’une barre de menu
JMenuBar jmb = new JMenuBar();
//Création d’un menu fichier
JMenu fichier = new JMenu ("Fichier");
[Link](KeyEvent.VK_F);
//Ajouter des éléments au menu Fichier
JMenuItem itemNew,itemOpen,itemClose;
itemNew = new JMenuItem ("Nouveau") ;
itemOpen = new JMenuItem ("Ouvrir") ;
itemClose =new JMenuItem ("Fermer");
[Link] (itemNew);
[Link] (itemOpen);
//Ajout d’un séparateur de menu
[Link]();

52
© M. Lahmer 2002-2023



è
é
ô
à
à
à
ê
à
 [Link](itemClose) ;
//Ajouter le menu fichier à la barre de menu
[Link] (fichier);
//Ajouter le menu à la fenêtre
[Link](theJMenuBar);

Pour traiter le clique sur un MenuItem il suf it d’impl menter l’ couteur ActionListener.
Exemple de JToolBar
//Création d’une barre d’outils
JToolBar toolbar = new JToolBar();
//Ajouter un élément à la barre d’outils
JButton ouvrir=new JButton();
[Link](("images/[Link]");
[Link](ouvrir);
//Désactiver le déplacement de la barre d’outils
[Link] (false);

7. JTabedPane (Onglets)

JTabedPane permet un utilisateur de switcher parmi plusieurs onglets par clique. Chaque
onglet est compos d’un titre, d’un pannel et ventuellement une image. L’ajout des onglets
au TabedPane est effectu par la m thode addTabe ou insertTab. Chaque onglet dispos d’un
indexe correspondant la position dont laquelle il a t ajout , le premier est index par 0 et
le dernier par n-1 ou n est le nombre d’onglets ajout s

JTabbedPane tabbedPane = new JTabbedPane();

ImageIcon icon = createImageIcon("images/[Link]");

JComponent panel1 = makeTextPanel("Panel #1");

[Link]("Tab 1", icon, panel1, "Does nothing at all");
[Link](0, KeyEvent.VK_1);

Les methods de JatbedPane

// ajouter supprimer un élément

insertTab(String, Icon, Component, String, int)
void removeTabAt(int) void removeAll()
//Récupérer un élément
int indexOfComponent(Component|String|Icon)
int getSelectedIndex() Component getSelectedComponent()
//changer la couleur de l’arrière plan et du style d’écriture

53
© M. Lahmer 2002-2023


é
à
à
é
é
f
é
é
é
é
é
é
é
é
é
 void setBackgroundAt(int, Color) Color getBackgroundAt(int)
void setForegroundAt(int, Color) Color getForegroundAt(int)
//Activer désactiver un onglet
void setEnabledAt(int, boolean) boolean isEnabledAt(int)

54
© M. Lahmer 2002-2023

 7. JavaFX

1. Introduction

À l'origine, la plate-forme JavaFX était principalement destinée aux applications Internet

riches (RIA). En 2014, JavaFX a été intégré dans JSDK 8 en tant que nouveauté sous
forme d’API de version 8. Depuis Java 11, JavaFX a été supprimé du SDK Java pour
devenir un projet open source OpenJFX ([Link] ). Maintenant JavaFX est une
plate-forme Open Source de nouvelle génération pour le développement d’applications
clientes riches : Bureau, Web et Mobiles / Embarqués basée sur Java.

2. Architecture

JavaFX est un ensemble de bibliothèques Java conçues pour permettre aux développeurs
de créer et de déployer des applications client riches qui se comportent de manière
cohérente sur toutes les plateformes.

Scene graph
Le JavaFX scene graph, présenté dans la couche supérieure de la gure 1, constitue le
point de départ de la création d'une application JavaFX. C'est une arborescence
hiérarchique de nœuds qui représente tous les éléments visuels de l'interface utilisateur de
l'application. Chaque nœud a un identi ant, une classe de style et supporte un ensemble
d’événements. À l'exception du nœud racine d'un graphe de scène, chaque nœud a un seul
parent et zéro enfant ou plus.
Prism

Prism est un moteur haute performance permettant l’accélération matérielle utilisé pour
restituer les graphiques au format 2D et 3D.
Dans l’absence de l’accélération sur le matériel ou le GPU, Prism utilise DirectX sur
Windows et OpenGL sur Mac, Linux, et les systèmes embarqués.
Glass
Glass Windowing, représente le niveau le plus bas de la pile de graphiques JavaFX. Sa

55
© M. Lahmer 2002-2023


fi
fi
 responsabilité principale consiste à fournir des services du Système d’exploitation natifs,
tels que la gestion des fenêtres, des minuteries et des surfaces. C’est l’intermédiaire entre la
plate-forme JavaFX et le système d'exploitation natif. Glass est également responsable de
la gestion de la le d'attente d'événements. Contrairement à (AWT), qui gère sa propre le
d'attente d'événements, Glass utilise les fonctionnalités de le d'attente des événements du
système d'exploitation natif pour plani er l'utilisation des processus.
Quantum Toolkit
Quantum Toolkit relie Prism et Glass Windowing Toolkit et les met à la disposition de la
couche JavaFX située au-dessus d’eux dans la pile. Il gère également les règles de thread
liées au rendu par rapport à la gestion des événements.
WebEngine : [Link]

Basé sur l’API open source web kit, WebEngine permet à une application javaFX
d’interpréter un contenu HTML (HTML5, CSS, JavaScript, DOM and SVG)
MediaEngine : [Link]
Il est basé sur un moteur open source appelé Streamer. Ce moteur multimédia prend en
charge la lecture de contenu vidéo et audio. Il supporte les formats mp3, wav, aiff et v.

3. Application JavaFX
Introduction
JavaFX vous permet de concevoir avec MVC (Model-View-Controller) en utilisant
FXML (extension XML pour JavaFX) et Java. Le "Modèle" est constitué d'objets du
domaine spéci ques à l'application, la "Vue" est constituée de FXML et le "Contrôleur" est
un code Java
qui dé nit le comportement de l'interface graphique pour interagir avec l'utilisateur. La
personnalisation de l'apparence et le style de l'application peut être fait via le CSS.
CDI : Context Dependency Injection permet de référencer un objet FXML depuis Java
(Contrôleur).
Il est possible de concevoir la GUI sans écrire de code grâce à JavaFX Scene Builder. Lors
de la conception de l'interface utilisateur, Scene Builder crée un balisage FXML pouvant
être transféré dans un environnement de développement intégré (IDE) a n que les
développeurs puissent ajouter la logique métier.
Cycle de vie d’une application JavaFX
Une application JavaFX hérite de [Link]. La JVM maintient le
cycle de vie d'une application JavaFX comme suit:
• Il construit une instance de Application en utilisant la méthode launch()
• Il appelle la méthode init() de l’application.
• Il appelle la méthode start de l'application ([Link]) et passe une instance de
Stage en argument.
• Il attend la n de l’application (par exemple, via [Link] () ou en fermant toutes les

56
© M. Lahmer 2002-2023

fi
fi
fi
fi
fi
fi
fi
fl
fi
 fenêtres).
• Il appelle la méthode stop () de l'application.
Start () est une méthode abstraite, qui doit être redé nie. init() et stop() ont une
implémentation par défaut qui ne fait rien.
Si vous utilisez [Link] (int) pour mettre n à l'application, stop () ne sera pas appelé.
Structure d’une application JavaFX

Une application graphique javaFX ([Link]) est composée de :

Stage ([Link]) : C’est le conteneur racine, il représente une fenêtre qu’on
associe à une scène. Il est passé comme argument de la méthode start public void
start(Stage primaryStage)
Scene ([Link]) : C’est le conteneur des composants graphiques (Scene Graph).
Une application peut avoir plusieurs scènes, mais une seule de ces scènes peut être af chée
dans un Stage à un instant donné.
Pour construire un objet Scene, on a besoin d’un noeud racine (Parent), la largeur et la
hauteur :
Scene(Parent root, double width, double height)
Scene Graph (hierarchie de Noeuds) : Un noeud est une classe abstraite
([Link]) super-class de tous les éléments graphiques (UI) :
• Controls (Composants): sous-classes de Parent dans le package [Link], par
exemple Label, TextField, Button.
• Layout Pane (Conteneurs): sous-classes de Parent dans le package [Link],
par exemple, StackPane, FlowPane, GridPane, BorderPane.
• Geometrical Shapes: sous-classes de Shape et Shape3D dans le package
[Link], par exemple, Circle, Rectangle, Polygon, sphere, Box.
• Media Elements: ImageView, MediaView (pouvant être lu par un lecteur multimédia)
dans les packages [Link] et [Link].

Un noeud implémente deux interfaces :

• [Link]: pour appliquer le style CSS.
• [Link]: pour les événements
Les Layouts
FlowPane : C’est le FlowLayout swing, les composants sont insérés horizontalement ou
verticalement en respectant la largeur respectivement la hauteur du conteneur.

57
© M. Lahmer 2002-2023


fi

fi
fi
 BorderPane : C’est le BorderLayout swing, la fenêtre est décomposée en 5 zones top,
bottom, right, left et center
StackPane : Les composants sont ajoutés l’un au-dessus de l’autre et il y a que le dernier
qui est visible
TilePane : équivalent au FlowPane il permet de placer tous les noeuds dans une grille dans
laquelle chaque cellule a la même taille. Les nœuds peuvent être disposés horizontalement
(en rangées) ou verticalement (en colonnes).
GridPane : C’est le GridLayout swing, Les composants sont ajustés selon une grille
(lignes,colones)
AnchorPane : permet d'ancrer des nœuds en haut, en bas, à gauche, à droite ou au centre
du volet. Lorsque la fenêtre est redimensionnée, les nœuds conservent leur position par
rapport à leur point d'ancrage.
HBox : permet une disposition des composants en une seule ligne
VBox : permet une disposition des composants en une seule colonne

Les composants

• Accordion
• ChoiceBox
• ColorPicker • DatePicker
• ComboBox • ListView
• TableView • Menu
• TabPane • PasswordField
• TextArea • ProgressBar
• TitledPane • Slider
• ToolBar • Spinner
• TreeTableView • SplitMenuButton
• TreeView • SplitPane
58
© M. Lahmer 2002-2023


 4. Exemple

La vue

<?xml version="1.0" encoding="UTF-8"?>

<?import [Link]?>
<?import [Link]?>
<?import [Link]?>
<?import [Link]?>
<?import [Link]?>
<?import [Link]?>
<?import [Link]?>

<BorderPane fx:controller= "[Link]"> ❶

<center>

<GridPane style="-fx-padding:15 20 15 20; " >

<Label text="Login" [Link]="0" prefWidth="100" [Link]="0"/>
<TextField prefWidth="150" [Link]="0" [Link]="1"/>
<Label text="Password" [Link]="1" prefWidth="100"

59
© M. Lahmer 2002-2023



 [Link]="0"/>
<TextField prefWidth="150" [Link]="1" [Link]="1"/>
</GridPane>
</center>
<bottom>
<HBox style="-fx-padding:15 20 15 20; -fx-spacing:20px;" alignment="BASELINE_CENTER" >
<Button text="Valider" prefWidth="100" onAction="#validateAction" /> ❷
<Button text="Annuler" prefWidth= "100" onAction="#cancelAction" />
</HBox>
</bottom>
</BorderPane>

❶ L’attribut fx:controller permet de spéci er le nom de la classe contrôleur qui va par la

suite traiter les événements
❷ Les méthodes validateAction et cancelAction représentent le traitement associé à
l’événement Action (ici clique sur le bouton) seront implémenter dans le contrôleur
Le contrôleur
package application;
import [Link];
import [Link];
import [Link];
import [Link];
public class AuthController {

// L'injection
@FXML
private void validateAction(ActionEvent event){}
@FXML
private void cancelAction(ActionEvent event) {}
}

5. ListView
<?xml version="1.0" encoding="UTF-8"?>
<?import [Link]?>
<?import [Link]?>

<VBox xmlns="[Link] xmlns:fx="[Link]

<children>
<ListView fx:id="listView" />
</children>
</VBox>

import [Link];
import [Link];
import [Link];
import [Link];
public class ListViewController {
@FXML
private ListView<String> listView;
public void initialize() {
// Create a sample list of items
ObservableList<String> items = [Link](
"Item 1", "Item 2", "Item 3", "Item 4", "Item 5");

// Populate the ListView with the items

[Link](items);

// Set an action event handler for item selection

[Link](event -> {
String selectedItem =

60
© M. Lahmer 2002-2023

fi
 [Link]().getSelectedItem();
[Link]("Selected Item: " + selectedItem);
});
}
}
————

// Load the FXML file

FXMLLoader loader = new
FXMLLoader(getClass().getResource("[Link]"));
Parent root = [Link]();
// Set the controller for the FXML file
ListViewController controller = [Link]();

6. Text Style
<?xml version="1.0" encoding="UTF-8"?>

<?import [Link]?>
<?import [Link]?>

<VBox xmlns="[Link] xmlns:fx="[Link]

1" fx:controller="[Link]">
<Label text="Styled Text" style="-fx-font-family: 'Arial'; -fx-font-
size: 16; -fx-font-weight: bold; -fx-fill: #336699; -fx-background-color:
#FFFFCC; -fx-padding: 10px; -fx-border-color: #336699; -fx-border-width:
2px; -fx-effect: dropshadow(three-pass-box, #666666, 10, 0, 0, 0);"/>
</VBox>

7. Charts
JavaFX est livré avec un ensemble de chartes graphiques prêtes à l'emploi :
AreaChart, BarChart, BubbleChart, LineChart, PieChart, ScatterChart,
StackedAreaChart et StackedBarChart
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class BarChartExample extends Application {

@Override
public void start(Stage primaryStage) throws Exception {
// Create a BarChart
BarChart<String, Number> barChart = createBarChart();
Scene scene = new Scene(barChart, 600, 400);
[Link]("JavaFX BarChart Example");

[Link](scene);
[Link]();
}

private BarChart<String, Number> createBarChart() {

// Define the axes
CategoryAxis xAxis = new CategoryAxis();
NumberAxis yAxis = new NumberAxis();

61
© M. Lahmer 2002-2023

 // Create the BarChart
BarChart<String, Number> barChart = new BarChart<>(xAxis, yAxis);
[Link]("BarChart Example");
// Create a data series
[Link]<String, Number> series = new [Link]<>();
[Link]("Data Series");

// Add data to the series

[Link]().add(new [Link]<>("Category 1", 20));
[Link]().add(new [Link]<>("Category 2", 50));
[Link]().add(new [Link]<>("Category 3", 30));
[Link]().add(new [Link]<>("Category 4", 40));
[Link]().add(new [Link]<>("Category 5", 10));

// Add the series to the BarChart

[Link]().add(series);
return barChart;
}
public static void main(String[] args) {
launch(args);
}
}

62
© M. Lahmer 2002-2023

 8 Accès aux bases de données en JDBC

1. Principe
JDBC est une API fournie avec Java permettant l'acc s n'importe quelle base de donn es
locale ou travers un r seau. Le principe de fonctionnement est comme suit :
■ Chaque base de donn es utilise un pilote (driver) qui lui est propre et qui permet de
convertir les requ tes JDBC dans le langage natif du SGBDR.
■ Ces drivers dits JDBC (un ensemble de classes et d’interfaces Java) existent pour tous les
principaux constructeurs : Oracle, Sybase, Informix, SQLServer, MySQL, MsAccess, …

2. Mise en œuvre
Toutes les classes et les interfaces n cessaires la connection la base de donn es et son
exploitation sont fournis par l’api [Link]. Les tapes suivre pour mettre en place une
application java bas e sur JDBC sont :
1. Charger le driver JDBC
Utiliser la m thode de chargement la demande forName() de la classe Class comme suit :
[Link]("Nom du driver");
Exemples de drivers :
[Link] : pour access fournis par JDK
[Link] : pour oracle non fournis
[Link]. SQLServerDriver : SqlServer non fournis

Code de chargement :
try { [Link]("[Link]").
newInstance();

63
© M. Lahmer 2002-2023

à
é
ê
é
é
é
à
é
é
à
à
è
à
à
é
é
 [Link]("Tout est OK"); }
catch (Exception e) { [Link]("Erreur de drivers
JDBC"); }

2. Établir la connexion à la base de données

La m thode getConnexion() de DriverManager qui renvoie un objet de type Connexion
permet d’ouvrir une connection sur la base de donn es elle dispose de trois arguments :
l ’URL de la base de donn es, le nom de l’utilisateur de la base et son mot de passe.
La structure de l’URL doit respecter la forme <protocol>:<subprotocol>:<subname> , avec
protocol : jdbc
subprotocol : driver utilis (mysql)
subname : //<host>[:<port>][/<databasename>]
Exemple : jdbc:mysql://localhost:port (MySQL)/client
Pour une base de donn e odbc jdbc:odbc:NSD, ou NSD est source de donn es associ e la base
de donn es client exemple Access.
Connection cnx = [Link](url,user,password);
Le DriverManager essaye tous les drivers qui se sont enregistr s.

3. Exécuter la requête
La premi re tape est de construire un objet Statement .
Statement stm = [Link]();
Quand un objet Statement execute une requ te, il retourne un objet ResultSet (pour les requ te
de consultation). L'ex cution de la requ te se fait par l'une des trois m thodes suivantes :
• executeQuery : pour les requ tes de consultation. Renvoie un ResultSet pour r cup rer
les lignes une par une.
• executeUpdate : pour les requ tes de modi ication des donn es (update, insert, delete)
ou autre requ te SQL (create table, ...). Renvoie le nombre de lignes modi i es.
• execute : si on conna t pas l'ex cution la nature de l'ordre SQL ex cute
ResultSet rsUsers = [Link]("SELECT * FROM T_Users;");

4. Traiter les données retournées

La manipulation des donn es se fait travers un objet de type ResultSet. Diff rentes m thodes
vous permettent de r cup rer la valeur des champs de l'enregistrement courant.
Ces m thodes commencent toutes par get, imm diatement suivi du nom du type de donn es
(ex: getString). Chaque m thode accepte soit l'indice de la colonne ( partir de 1) soit le nom
de la colonne dans la table :
boolean getBoolean(int); boolean getBoolean(String); byte getByte(int); byte
getByte(String); Date getDate(int); Date getDate(String); double getDouble(int); double
getDouble(String); loat getFloat(int); loat getFloat(String); int getInt(int); int

64
© M. Lahmer 2002-2023

é
é
é
è
é
ê
é
î
é
f
é
é
é
é
é
é
à
ê
ê
é
à
ê
f
ê
f
é
é
é
é
à
à
é
é
f
é
é
é
é
é
é
à
é
é
ê
 getInt(String); long getLong(int); long getLong(String); short getShort(int); short
getShort(String); String getString(int); String getString(String);
String strQuery = "SELECT * FROM T_Users;";
ResultSet rsUsers = [Link](strQuery);
while([Link]()) {
[Link]("Id[" + [Link](1) + "]" + "Pass[" +
[Link]("Password") ); }
Pour parcourir un ResultSet dans tous les sens (premier, dernier, suivant et pr c dent) Il faut
passer des param tres spl mentaires la m thode createStatement de l'objet de
connexion : stm = [Link](type, mode);
• Type :
o ResultSet.TYPE_FORWARD_ONLY
o ResultSet.TYPE_SCROLL_SENSITIVE
o ResultSet.TYPE_SCROLL_INSENSITIVE
• Mode :
o ResultSet.CONCUR_READ_ONLY
o ResultSet.CONCUR_UPDATABLE
Pour le type scroll, on a les possibilit s de parcours irst, last , next et previous. A titre
d’exemple pour modi ier le premier enregistrement de la table T_Users
[Link](); // Se positionne sur le premier enregistrement
[Link]("Password", "toto"); // Modi ie la valeur du password
[Link](); //Applique les modi ications sur la base
Avant de quitter l’application il faut fermer les diff rents espaces ouverts savoir rsUsers, stm et
cnx

3. PreparedStatement et CollablStatement
PreparedStatement : Requ te dynamiques pr -compil e plus rapide qu’un Statement
classique. Le SGBD n’analyse qu’une seule fois la requ te pour de nombreuses ex cutions d’une
m me requ te SQL avec des param tres variables. La m thode prepareStatement() throws
SQLException de l ’objet Connection cr e un PreparedStatement
PreparedStatement ps =
[Link]("UPDATE emp SET sal = ? WHERE name = ?");
for(int i = 0; i < 10; i++) {
[Link](1, salary[i]);
[Link](2, name[i]);
int count = [Link](); }
Les arguments dynamiques sont sp ci i s par un "?" ils sont ensuite positionn s par les
m thodes setInt() , setString() , setDate() , … de PreparedStatement et setNull() positionne
le param tre NULL (SQL). Ces m thodes n cessitent 2 arguments, le premier (int) indique le
num ro relatif de l’argument dans la requ te et le second indique la valeur positionner.

65
© M. Lahmer 2002-2023

ê
é
é
è
ê
à
è
f
é
ê
é
è
é
é
é
f
ê
à
é
é
f
é
é
é
ê
f
é
é
f
à
à
é
é
é
é
 CallableStatement : utilis e pour ex cuter une proc dure sql stock e. Exemple d’addtion
/*
--EXECUTE ADDITION 10,25,NULL
ALTER PROCEDURE ADDITION
@A INT
, @B INT
, @C INT OUT
AS
SELECT @C = @A + @B
*/
CallableStatement cs2 = [Link]("{call ADDITION(?,?,?)}");
[Link](3,[Link]);
[Link](1,10);
[Link](2,25);
[Link]();
int res = [Link](3);
[Link](res);

4. Les métadonnées
JDBC permet de r cup rer des informations sur le type de donn es que l'on vient de r cup rer
par un SELECT (interface ResultSetMetaData), mais aussi sur la base de donn es elle-m me
(interface DatabaseMetaData). Les donn es que l'on peut r cup rer avec DatabaseMetaData
d pendent du SGBD avec lequel on travaille.

Récupération des méta-données select

ResultSet rs = [Link]("SELECT * FROM emp");
ResultSetMetaData rsmd = [Link]();
int nbColonnes = [Link]();
for (int i = 1; i <= nbColonnes; i++) {
String typeColonne = [Link](i);
String nomColonne = [Link](i);
[Link]("Colonne " + i + " de nom " + nomColonne +
" de type " + typeColonne);}

Récupération des méta-données de la base

private DatabaseMetaData metaData;

private Vector<String> listTables = new Vector();
. . .
metaData = [Link]();
// Récupérer les tables et les vues
String[] types = { "TABLE", "VIEW" };
ResultSet rs = [Link](null, null, "%", types);
while ([Link]()) {
[Link]([Link](3));}

66
© M. Lahmer 2002-2023

é
é
é
é
é
é
é
é
é
é
é
é
é
ê
é
 9. Client / Serveur en RMI

1. Définition
Appel de m thode distance (Remote Methode Invocation) est une technologie sun
d velopp e depuis JDK 1.1 qui permet un objet java s’ex cutant sur une machine
cliente d’invoquer des m thodes sur un objet s’ex cutant sur une autre machine serveur.
L’API rmi d charge le d veloppeur de toute connaissance sur les r seaux (protocoles
TCP, socket, format de donn es,….) et l’appelle de m thodes se fait d’une façon
transparente.

2. Mise en œuvre

1. principe
Le développement d’une application distribuée RMI peut être décomposé en deux parties :
Côté serveur
• La d inition d'une interface qui contient les m thodes qui peuvent tre appel es
distance
• L' criture d'une classe qui impl mente cette interface
• L’enregistrement de l’objet distant dans le registre de noms RMI (RMI Registry)
Côté client
• L'obtention d'une r f rence sur l'objet distant partir de son nom
• L'appel la m thode partir de cette r f rence

2. Exemple
L’objectif est de mettre en place une application rmi qui permettra un client d’appeler
une m thode addition(a,b) sur un objet distant calcule.

67
© M. Lahmer 2002-2023

à

é
é
é
f
é
à
é
é
é
é
é
à
é
à
é
é
é
é
é
é
à
à
é
é
é
é
à
ê
é
é
 - D inition de l’interface calcule qui contiendra les services appeler distance :
import [Link].*;
public interface Calcul extends Remote {
public double addition(double a, double b) throws RemoteException;}
- Impl mentation de l’objet distant qui va impl menter l’interface Remote

import [Link];
import [Link];
public class CalculImpl extends UnicastRemoteObject implements Calcul{
protected InformationImpl() throws RemoteException {
super();}
public double addition(double x, double y) throws RemoteException {
return a+b ;}
- Enregistrement dans l’annuaire RmiRegistry (Main)
import [Link];
import [Link];
class Main{
public static void main(String[] args) {
int port=1099;
[Link](port)
CalculImpl srv = new CalculImpl();
String url = "rmi://@serveur:”+port+”/Reference";
[Link](url, srv);
[Link]("Serveur lance :");
} catch (Exception e) { [Link]();}
}
}

- Côté client en recherché l’objet distant par sa référence dans l’annuaire et appeler la
méthode.
import [Link];
import [Link];
public class Client {
public static void main(String[] args) {
try {
Remote serveur = (Calcul)[Link]("rmi://@serveur:1099/Reference ");
[Link]("Resulta = " + [Link](10,20));
}
} catch (NotBoundException e) {
[Link]();
}
}

68
© M. Lahmer 2002-2023

é
f
é
é
à
à