Module JAVA FVanderhaegen Versionauxétudiants2016-2017

Professeur Frédéric VANDERHAEGEN
Université de Valenciennes et du Hainaut-Cambrésis

Institut des Sciences et Techniques de Valenciennes
Sommaire
Chapitre 1 - Les bases ................................................................................................................ 1
Chapitre 2 – Les instructions conditionnelles et itératives ......................................................... 7
Chapitre 3 – Les variables et les méthodes ................................................................................ 9
Chapitre 4 – Les exceptions ..................................................................................................... 15
Chapitre 5 – Les flux d‟entrée/sortie ........................................................................................ 18
Chapitre 6 – Les filtres sur les flux d‟entrée/sortie .................................................................. 21
Chapitre 7 – Les interfaces utilisateurs : les classes AWT et Swing ....................................... 25
Chapitre 8 – La gestion d‟événement ....................................................................................... 32
Chapitre 9 – La classe Graphics ............................................................................................... 38
Chapitre 10 – Les applets ......................................................................................................... 40
Chapitre 1 - Les bases
Introduction :
 JAVA est un langage hybride semi-compilé (compilateur en langage byte-
code qui sera interprété ensuite lors de l‟exécution),
 Il est portable (byte-code interprétable par une machine virtuelle MVJ),
 Il est distribué et sécurisé, défini pour un environnement serveur :
structure + sécurité non négligées,
 C‟est un langage orienté-objet,
 Il est simple (proche du C ou C++; pas de pointeurs explicites),
 Il est fiable (moins d‟erreurs : pourquoi ?  pas de gestion dynamique de
la mémoire, pas de pointeur à gérer par le programmeur ; 2 filtres :
compilateur + interpréteur ce qui évite par exemple de confondre
allocation ou test d‟égalité dans une proposition conditionnelle ; pas
d‟héritage multiple)
Cours Programmation Orientée Objet – JAVA – F. VANDERHAEGEN – UVHC– ISTV 2016/2017 Valenciennes 1
Télécharger JAVA :
Télécharger et installer une plate-forme JAVA (télécharger le Java Development
Kit pour développer des applications et des applets, contenant le Java Runtime
Environnement) :
http://www.oracle.com/technetwork/java/javase/downloads/index.html ou
http://java.com/fr/download/index.jsp),
Types d’exécutable :
- application : programme indépendant du Web, exécuté en local en
tapant la commande java nomdelaclasse sans extension à partir
d‟une fenêtre MS-DOS (via l‟invité de commande) ou via un
éditeur dédié (Eclipse, NetBeans, JBuilder, etc.)
- applet : programme à insérer dans un page Web, est exécuté par le
client. C‟est le fichier byte-code qui est envoyé au client (et non le
fichier source). Dans une page Web, une applet est une image
statique ou dynamique.
- servlet : programme exécuté sur le serveur permettant de répondre à
une requête d‟un client http. Un servlet reçoit une requête http avec
des données, traite ces données, et peut renvoyer une réponse sous
la forme d‟une page Web dynamique
Ce cours se limite à la création d‟applications et d‟applets.
Ecrire, compiler et exécuter une application:

- Sous éditeur de texte quelconque (sans formatage ! Par exemple :
Bloc-notes), écrire les lignes d‟instruction de votre application.
Attention : le compilateur distingue les majuscules des minuscules !
- Sauvegarder et enregistrer le fichier source avec l‟extension .java.
Le fichier doit porter le même nom que la classe ou la classe qui
contient la fonction principale (la méthode « main ») s‟il y en a
plusieurs
- Compiler ce fichier avec l‟extension .java avec javac via une
fenêtre DOS (taper la commande javac Nomduprogramme.java).
Un fichier byte-code est généré avec extension .class dans le même
répertoire que le fichier source. Chaque classe du fichier donne lieu
à la création d‟un fichier .class
- Exécuter l‟application avec la commande java Nomduprogramme
sans extension.
Variable d’environnement ou éditeurs spécifiques

Les commandes javac et java sont disponibles dans le répertoire \bin du jdk.
Pour pouvoir exécuter une application à partir d‟une fenêtre MS-DOS (par
l‟Invité de commandes), différentes possibilités s‟offrent au développeur pour
pré-compiler et exécuter :
- Se mettre dans le répertoire \bin du jdk (changement de
répertoire en MS-DOS : cd .. pour revenir au répertoire précédent ;
cd nomdurepertoire pour accéder au répertoire nomdurepertoire à
partir du répertorie courant ; etc.). Taper les commandes javac
chemindelapplication\Nomduprogramme.java puis java
chemindelapplication\Nomduprogramme
- Modifier la variable d‟environnement utilisateur Path en intégrant
le chemin du répertoire \bin du jdk. Variable à créer si elle n‟existe
pas dans votre compte utilisateur. Par défaut, l‟installation de
JAVA est proposée dans le répertoire C:\Programme File, mais
l‟utilisateur peut définir l‟emplacement lui-même… Voir figure ci-
dessous. Dans cet exemple, le JDK a été installé dans le compte
utilisateur dans la variable « Path » du compte utilisateur est créée
car elle n‟existait pas, et le chemin pour accéder directement aux
commandes JAVA telles que « javac » ou « java » est :
C:\Users\FredV\Documents\jdk1.7.0_11\bin
- Utiliser un éditeur qui intègre la possibilité d‟exécuter directement

les applications (ex : Eclipse, NetBeans, JBuilder téléchargeables
gratuitement)
Contenu d’une application sous éditeur :

- Importer les packages (regroupements de classes et d‟interfaces liés
fonctionnellement, i.e. même domaine, même fonctionnalité – 1
package correspond à une bibliothèque ou un dossier - library ou
repertory)
- Ecrire le corps du programme (déclaration de variables, création de
méthodes, création des Interfaces Utilisateurs (IU), etc)
- Ecrire la méthode main(). Toutes les applications doivent avoir une
méthode main() car c‟est ce qui les différencie des applets et les
détermine en tant que programme ; possibilité d‟intégrer des
arguments à l‟exécution du programme.
- Insérer des commentaires (// sur une ligne ; /* … */ sur plusieurs
lignes)
Packages
Appel des packages existants par import nomPackage.nomClasse (égale à
#include du C)
Package importé automatiquement : java.lang où il y a les bases de JAVA telles
que String ou System
Exemples de noms de package « standard » du JRE:
 Java.applet : contient la classe Applet et interfaces, sert d‟intermédiaire
entre applet et navigateur
 Java.awt : interfaces utilisateur, graphiques
 Java.io : entrées-sorties (écriture / lecture de données)
 Java.lang : classe racine Object, types de données avancés, …
 Java.math : fonctions mathématiques
 Java.net : client/server
 Java.rmi : Remote Method Invocation –méthodes à distance)
 Java.security : sécurisation des transmissions
 Java.sql : accès à des bases de données relationnelles via SQL
 Java.text : formatage de chaîne de texte
 Java.util : conversions, structures de données, gestion d‟événements
Déclaration de variables :
Les classes de base et la taille des objets associés sont les suivants :
La déclaration de ces variables simples ne nécessite pas l‟usage du mot clé
« new » pour instancier une des classes. Par contre, la création d‟un tableau dont
le contenu n‟est pas défini préalablement requiert une instanciation de la classe
associée avec le mot clé « new ».
Opérateurs d’affectation :
Opération Opération développée Opération simplifiée
Addition x=x+y x+=y
Soustraction x=x-y x-=y
Multiplication x=x*y x*=y
Division x=x/y x/=y
Modulo x=x%y x %= y
Opérateurs de comparaison :
Opérateur Description
= = (2 égalites) Egal à
!= Différent de
< Inférieur à
> Supérieur à
<= Inférieur ou égal à
>= Supérieur ou ègale à
Opérateurs logiques :
Opérateur Description
&& ET logique
|| OU logique
! NON logique
^ OU EXCLUSIF
Caractères d’échappement :
JAVA distingue les minuscules des majuscules et nécessite parfois l‟usage de
caractères d‟échappement tels que :
\n : nouvelle ligne
\t : tabulation
\b : retour arrière
\r : retour chariot
\f : changement de page
\\: antislash
\‟ : guillemet simple
\ » : guillemet double
\xd : hexadécimal
\ud : caractère unicode (à : \u2026 ; â : \u0192 ; é : \u201a ; è : \u0160 ; ê :
\u02c6 ; î : \u0152 ; ô: \u201c ; û: \u00ea) (voir: http://www.unicode.org)
Votre premier programme :

La méthode pour écrire du texte à l‟écran d‟exécution de l‟application est :
system.out.println(« Ecrire à l‟écran »)
class PremierProgrammeJAVA
{
public static void main (String args[])
{
System.out.println(“Premier Programme JAVA”);
}
}
Etapes à realiser:
 Sauvegarde de ce fichier qui aura le nom PremierProgrammeJAVA.java
 Pré-compilation avec la commande suivante: javac
PremierProgrammeJAVA.java
 Ce qui génèrera le fichier PremierProgrammeJAVA.class
 L‟exécution de cette application s‟obtiendra avec la commande : java
PremierProgrammeJAVA
 Après cette commande, voici ce qui est affiché à l‟écran : Premier
Programme JAVA
Note : le paramètre de la méthode main est un tableau de chaîne de caractères.
Les éléments de ce tableau peuvent être exploités dans le code source (e.g.,
args[0], args[1], etc.), ce qui oblige d‟intégrer ces éléments lors de l‟exécution
de l‟application (i.e., lors du lancement de la commande jave nomdelaclasse
args[0] args[1]).
Exercice 1
Faire la même chose mais sur 3 lignes distinctes, écrire les phrases suivantes:
Je suis en cours
de simulation
et de systèmes h-m
Exercice 2
Faire un programme qui écrit des mots mis en paramètre lors de l‟appel
Exercice 3
Un passager achète un billet de train à 55 euros. Il donne 100 euros. Avec la
monnaie, il achète un carnet de tickets de métro à 13 euros. Il donne 20 euros au
guichet. Faire un programme qui affiche les flux d‟argent depuis l‟achat du billet
de train jusqu‟à la monnaie rendu au guichet de métro.
Chapitre 2 – Les instructions conditionnelles et itératives
Instructions conditionnelles:
Voici quelques exemples d‟instructions conditionnelles:
If then else:
if (age > 39) System.out.println(“plus de 39 ans”);
Si le contenu de la variable age est supérieur à 39 strictement, alors le

programme écrit « plus de 39 ans ».
if (age > 39)

System.out.println(“plus de 39 ans”) ;
else
System.out.println(“moins de 39 ans ou égal”);
Si le contenu de la variable age est supérieur à 39 strictement, alors le

programme écrit « plus de 39 ans », sinon il écrit « moins de 39 ans ou égal ».
Opérateur conditionnel :
test ? retourtrue retourfalse ;
Si la variable test est vrai alors retour de la valeur « retourtrue » sinon
« retourfalse »
Que fait la commande suivante ?
int meilleurresultat = resultat1 > resultat2 ? resultat1 resultat2 ;
Elle renvoie le plus grand de resultat1 et resultat2 dans meilleurresultat
switch
Dans l‟exemple suivant, si la variable grade contient A, le programme affiche
“OK”, si elle contient B, il affiche “BOF”, sinon il affiche “Pas terrible”:
switch (grade)
{
case „A‟: System.out.println(“OK”); break;
case „B‟: System.out.println(“BOF”); break;
default: System.out.println(“Pas terrible”);
}
Instructions itératives:
Voici quelques exemples d‟instructions itératives. Implémenter-les et vérifier ce
qu‟elles font.
while (i<10)
x = x + i++;
while (i!=0)
System.out.println(“valeur de i = “+i--);
do
x = x + i++;
while (i<10);
for (i=0; i<10; i++)

System.out.println(“valeur de i = “+i); /* affichage de ? à ? */
for (i=0;i!=10;i++)
for (i=10;i!=0;i--)
for (i=10;i>=0;i--)
Exercice 1
Ecrire un programme qui dit si un point de coordonnée (x, y) se trouve dans un
cercle de centre (a,b) et de rayon r, tous les paramètres étant donnée lors de
l‟appel de l‟application.
Exercice 2
Ecrire un programme qui permet de trier un tableau d‟entiers comprenant (12, 5,
7, 45, 18, 20, 60) par ordre croissant
Exercice 3
Ecrire un programme qui permet de dire si un nombre entier donné supérieur à 1
(valeur constante donné au départ en paramètre) est un nombre premier (un
nombre premier est un nombre divisible par 1 et par lui-même).
Exercice 4
Ecrire un programme donnant la somme des éléments du tableau d‟entiers
comprenant (10, 40, 10, 7, 7, 8, 10, 40), et donnant la plus grande valeur du
tableau ainsi que le nombre d‟occurrence de cette valeur.
Chapitre 3 – Les variables et les méthodes
Quelques mots mots-clés :

 « private » : encapsulation, impossibilité d‟accès de l‟extérieur de l‟objet
 « public » : interfaçage entre objets, possibilité d‟accès de l‟extérieur
 « void » : pas de retour dans la méthode, i.e. il n‟y a pas le mot clé
« return » dans la méthode
 « static » devant une variable: même valeur de variable pour tous les
objets d‟une classe ; intérêts : faire communiquer des objets d‟une classe
ou suivre l‟évolution des informations entre objets. Avec le mot clé
« static », il s‟agit d‟une variable de classe, sans le mot clé « static », il
s‟agit d‟une variable d‟instance associée à une référence d‟un objet :
ref_objet.nomvariable ou this.nomvariable.
 « static » devant une méthode. Même rapport entre méthodes
d‟instance/méthodes de classe et variables d‟instance/variables de classe.
Avec le mot clé « static », les méthodes de classe sont accessibles à toutes
les instances de la classe elle-même, et il est possible de les rendre
accessible à d‟autres classes. Il n‟est alors pas nécessaire de disposer
d‟une instance de la classe lorsque l‟application n‟utilise pas le mot-clé
« new ». Sans le mot clé « static », la méthode devient une méthode
d‟instance associée à une référence d‟un objet : ref_objet.nommethode()
ou this.nommethode().
 Par exemple : public static void main(String args[]) signifie que 1) main()
est accessible dans toutes les autres classes, et de tous les autres objets
(obligatoirement déclarée en public) ; 2) main() est une méthode de classe
avec le « static » ; 3) ne revoie pas de valeur ; 4) peut avoir des
paramètres dans une matrice de chaînes.
Mot clé « new » :

 Ce mot-clé permet l‟instanciation de la classe par la création d‟un objet
 L‟objet ainsi crée est donc l‟instance d‟une classe
 Une classe peut servir à créer plusieurs instances (i.e. objets)
 Un objet n‟est pas déclaré comme une variable simple mais est créé
dynamiquement avec l‟opérateur « new »
 La déclaration nécessite le nom de la classe et sa référence.
L‟instanciation de la classe s‟effectue par l‟instruction : référence =
new nom de la classe à instancier.
 Compilateur : si le type d‟une variable est « primitif » alors variable
simple, si le type est une classe alors la variable déclarée est une
référence à un objet, il faudra ensuite créer un objet qui sera désigné
par cette référence
 Attention : il y a souvent confusion entre l‟objet instancié et sa
référence. Dans le programme, attention donc à la manipulation des
références : si une instruction réalise une affectation d‟une référence à
une autre, il n‟y a pas de copie d‟objet mais cela réalise une référence
double pour un même objet !
Mot-clé « this »
Mot clé utilisée pour :
 Faire référence à l‟objet en cours, i.e. faire référence à l‟objet pour lequel
la méthode est appelée
 Utiliser les variables d‟instance de l‟objet en cours ou transmettre l‟objet
en cours sous forme d‟argument à une autre méthode
 Utiliser partout où l‟objet est susceptible d‟apparaître
 Exemples :
 t= this.x /* variable d‟instance x de cet objet */
 this.demarrer(this) /* appeler la méthode demarrer(this) définie dans la
classe et lui transmettre l‟objet */
 return this /* retourner l‟objet en cours */
Définition d’une méthode :
La définition d‟une méthode nécessite une signature et le corps ou contenu de la
méthode. La signature comprend :
 Le nom de la méthode
 Le type d‟objet ou de données que la méthode retourne
 La liste paramètres
Différents type de méthodes peuvent être développées :

 Des méthodes surchargées : il s‟agit de méthodes avec signatures et corps
différents mais avec même nom
 Des méthodes Constructeurs : il s‟agit de méthodes permettant
d‟initialiser des objets afin de définir leur état initial au moment de leur
création
 Des méthodes redéfinies : il s‟agit de créer une nouvelle définition pour
une méthode déjà définie dans une super-classe
 Des méthodes de finalisation : elles permettent de faire le « ménage »
derrière un objet avant suppression par le système
Méthode Constructeur :
 C‟est une méthode appelée sur un objet lors de sa création
 Elle ne peut pas être appelée directement comme les autres méthodes :
elle est appelée automatiquement par JAVA lors de la création d‟objets
(i.e. arguments nécessaires à la création d‟un objet)
 3 opérations sont réalisées lors de l‟instaciation d‟une classe avec le mot-
clé « new » : 1) allocation mémoire, 2) initialisation des variables
d‟instance (avec valeur initiale donnée par le programmeur ou valeur par
défaut : 0 pour les nombres, null pour les objets, false pour les booléens,
„\0‟ pour les caractères), 3) appel de la méthode constructeur de la classe
qui peut être une méthode choisie parmi plusieurs (i.e., méthodes
constructeur surchargées)
 Avantage de la définition de méthodes constructeurs : possibilité
d‟initialiser les variables d‟instance, appel de méthodes reposant sur ces
valeurs, appel de méthodes sur d‟autres objets, définition de propriétés
initiales d‟un objet.
 S‟il n‟y a pas de création de méthode constructeur car ceci est facultatif :
JAVA en crée une.
 Les méthodes constructeurs portent toujours le même nom que la classe
 Les méthodes constructeurs ne possèdent pas de retour, i.e. ne contienne
pas le mot-clé « return ».
Appel croisé entre méthodes constructeurs
 Le principe est le suivant: une méthode effectue le travail d‟une autre, i.e.
une méthode fait appel à une autre méthode de même nom
 Quand une méthode constructeur reproduit une partie du comportement
d‟une méthode, il est possible d‟appeler la première méthode constructeur
depuis le corps de la seconde méthode constructeur.
 La syntaxe pour ce type d‟opération est par exemple: this(arg1, arg2,
arg3) où arg1, arg2 et arg3 sont les arguments utilisés pour la méthode
constructeur ;
 « this » s‟utilise avec une méthode constructeur comme pour accéder aux
variables de l‟objet en cours
Surcharge des constructeurs

 Comme les méthodes ordinaires, il est possible de définir des méthodes
avec le même nom mais avec un nombre et/ou des types de paramètres
différents
Redéfinir une méthode et rappeler l’originale

 Quand une méthode est appelée, Java en recherche la définition
dans la classe de l‟objet. S‟il y a échec (i.e., JAVA ne trouve pas
cette méthode), JAVA poursuit cette recherche en suivant la
hiérarchie jusqu‟à ce que la méthode soit trouvée. Le principe
d‟héritage de méthodes permet de les utiliser dans les sous-
classes sans dupliquer le code !
 Parfois, un objet utilisant les mêmes méthodes doit pouvoir
réagir différemment selon le moment de l‟appel de la méthode !
Il faut alors redéfinir la méthode en lui affectant la même
signature que celle avec laquelle elle a été définie depuis une
super-classe
 Mot-clé à utiliser: « extends » permet de créer un classe fille. La
classe mère s‟appelle la super-classe ou la classe mère.
 Mot-clé : “super” pour redéfinir la super-classe
 Voir exemple de cours :
Redéfinition d’une méthode constructeur

 Il est possible de modifier la manière dont un objet est initialisée
en 1) initialisant les nouvelles variables ajoutées par la classe ou
2) en modifiant le contenu des variables existantes
 Mot-clé : « super (arg1, arg2, …) »
 Ex :
if (condition == true)
super(1, 2, 3) ;
else
super(1, 2) ;
Méthodes de finalisation
 Elles sont le contraire des méthodes constructeurs
 Une méthode constructeur permet l‟initialisation d‟un objet alors
qu‟une méthode de finalisation permet de nettoyer la mémoire
en libérant la place occupée par l‟objet.
 Mot-Clé : finalize()
Exercice 1 :
Que fait ce programme ?
class essai
{
int test = 10 ;
void printTest()
{
int test = 20 ;
System.out.println(“Test = “+test) ;
}
public static void main (String args[])
{
essai es = new essai();
es.printTest();
}
}
Exercice 2 :
Que fait ce programme :
Import java.awt.Point ;
Class NomPoint extends Point
{
String nom ;
NomPoint(int x, int y, String nom)
{
super(x, y) ;
this.nom = nom ;
}
public static void main(String argc[])
{
NomPoint np = new NomPoint(5, 5, « Centre ») ;
System.out.println(« x= »+np.x+ « et y= »+np.y+ « et nom = »+np.nom) ;
}
Exemple 3 :
Que fait l‟application suivante :
class Person
{
String name ;
int age ;
Person(String n, int a)
{
name = n;
age = a;
}
void printPerson()
{
System.out.println(“Nom = “+name+“ et age =“+age);
}
public static void main(String args[])
{
Person p;
p = new Person(“Luc”, 35);
p.printPerson();
p = new Person(“Antoine”, 25);
p.printPerson();
}
}
Exercice 4
Développer une classe qui définit un cercle à partir de son centre (x, y) et son
rayon à partir deux méthodes constructeurs
 une pour définir le centre et le rayon,
 et une seconde pour définir le centre et paramétrer ce rayon sur une valeur
par défaut de 1
Exercice 5 :
Définir un rectangle à partir de 4 coordonnées, de 2 points, d‟un point, de sa
hauteur et longueur – à partir de méthodes surchargées ordinaires et méthodes
surchargées constructeurs.
Chapitre 4 – Les exceptions
Gestion des exceptions

 Pour la gestion de flux d‟entrée/sortie, JAVA oblige le traitement des
exceptions
 Les exceptions sont des objets particuliers associés à des erreurs de
programmation ou d‟exécution générant l‟interruption non prévue ou
prévue d‟un programme
 La classe Exception, comme la classe Error se trouve dans la classe
Throwable. Les éléments de la classe Error sont des exceptions graves
incontournables et bloquant le programme. Les éléments de la classe
Exception sont contournables par programmation.
 Mots-clés : “try … catch … throws … throw ... finally”
 try: pour exécuter une liste d‟instructions
 catch : pour capturer des exceptions lorsque l‟exécution pose problème
 throws … throw (facultatif) : pour prévenir que les instructions
peuvent générer des exceptions (avec throws dans la signature d‟une
méthode suivie de la liste des exceptions à lever séparées par une
virgule) et pour lever ou contourner une exception sans la capturer
(avec throw)
 finally (facultatif): pour exécuter une liste d‟instructions après
l‟exécution des instructions du bloc try avec ou sans exceptions ; pour
autoriser une partie de programme même s‟il y a exception (e.g. :
libérer une ressource externe après usage, fermeture d‟un fichier après
ouverture, code de nettoyage après un « break », « continue » ou
« return », etc.).
Hiérarchie des exceptions:

Throwable (classe qui se trouve dans le package java.lang)
 Exception
o RuntimeException
 ArrayIndexOutofBounds
 SecurityException
 NullPointerException
 …
o ClassNotFoundException
o IOException
 EOFException
 FileNotFoundException
 MalFormedURLException,
 SocketException
 …
o …
 Error
o VirtualMachineError
 OutOfMemoryError
 StackOverflowError
 InternalError
 UnknownError
 …
o LinkageError
 NoClassDefFoundError
 …
o …
Intérêt de cette gestion ?

Compromis entre la gestion des erreurs par programmation et la gestion des
exceptions avec les classes associées. Par exemple :
 Plus facile de gérer la taille d‟une matrice ou d‟un tableau avec la
méthode « length » plutôt qu‟avec ArrayIndexOutofBounds.
 Plus facile de traiter le type des saisies plutôt que de générer une
exception dans une autre partie du programme.
Exercice 1
Que font ces programmes ?
Le premier programme :
Le deuxième programme:
Enfin, le dernier programme:
Exercice 2
Avec le try et le catch, faire une méthode qui permet de renvoyer la somme des
éléments du tableau en incluant une exception liée à un dépassement d‟indice du
tableau.
Dans la suite du cours, on se limitera à l‟usage du try … catch.
Chapitre 5 – Les flux d’entrée/sortie
Gestion de données par les flux d’entrée/sortie

 En JAVA, toutes les données sont lues et écrites à l‟aide de flux
 Un flux est un chemin parcouru par des données dans un programme.
 Un flux d‟entrée est l‟envoi de données d‟une source à un programme et
un flux de sortie, l‟envoi de données d‟un programme à une destination.
 Différents types de flux : flux d‟octets, flux de caractères.
Utilisation d’un flux :

o Pour un flux d‟entrée
 créer un objet associé à la source de données (ex : pour un
fichier du disque dur : objet de la classe FileInputStream)
 Lecture à l‟aide d‟une des méthodes de l‟objet déclaré (ex :
méthode read() de l‟objet FileInputStream)
 Fermeture après traitement : appel de la méthode close() pour
terminer l‟usage du flux
o Pour un flux de sortie
 Créer un objet associé à la destination des données (ex : créer
des fichiers texte à partir de la classe FileOutputStream)
 Ecriture à partir de la méthode write()
 Quand envoi d‟information terminé : close()
Quelques sous classes et méthodes associées:

Il existe beaucoup de sous-classes de gestion de flux d‟entrée/sortie. Nous nous
limiterons aux flux sur des fichiers avec les classes :
 Pour les flux d‟octets:
o FileInputStream de la super classe InputStream
o FileOutputStream de la super classe OutputStream
 Pour les flux de caractères :
o FileReader de la super classe Reader
o FileWriter de la super classe Writer
Pour ces quatre classes, il existe plusieurs constructeurs avec des paramètres
identiques. Par exemple, lors de l‟instanciation d‟une de ces classes, il est
possible de mettre en paramètre :
 Un objet de la classe File en paramètre
 Le nom ou le chemin du fichier à traiter avec un String
Pour chacune de ces classes, voici les méthodes de lecture et d‟écriture.
FileInputStream
 int read(): lit un octet, renvoie -1 quand le flux est terminé
 int read(byte[]): lit un tableau d‟octets, renvoie -1 quand le flux est
terminé
 int read(byte[], int, int) Reads up to len bytes of data from this input
stream into an array of bytes.
FileOutputStream
 void write(int) : écrit l‟octet spécifié en paramètre
 void write(byte[]): écrit le tableau d‟octets donné en paramètre
 void write(byte[], int, int): écrit le tableau d‟octets donné à partir de
l‟indice du deuxième paramètre, et ce pour un nombre d‟octets donné par
le troisième paramètre
FileReader :
 int read(): lit un caractère, renvoi de -1 si fin du flux
 int read(char[]): lit un tableau de caractères
 int read(char[], int, int): lit un tableau de caractères, le premier entier
donne l‟indice du tableau dans lequel le premier caractère lu sera stocké,
le deuxième entier étant le nombre de caractères à lire, renvoie le nombre
de caractères lus ou -1 quand rien n‟a été lu
FileWriter :
 void write(int): écrit le caractère donné en paramètre
 void write(char[]): écrit le tableau de caractères donné en paramètre
 void write(char[], int, int): écrit le tableau de caractères donné, depuis
l‟indice du tableau donné par le premier entier, le deuxième entier
donnant le nombre de caractères à écrire
La classe File
 Objet File comprenant les méthodes constructeurs suivantes :
o File(String) = crée un objet File dont le nom String est donné en
paramètre ;
o File(String, String) = crée un objet File avec le chemin et le nom
donnés en paramètre ;
o File(File, String) = crée un objet File dont le chemin est File et le
nom String
 Quelques exemple de méthodes :
o boolean exists() : renvoie un booléan pour l‟existence ou non du
fichier
o long length() : renvoie la taille du fichier
o boolean renameTo(File) : renomme un fichier et renvoie un booléen
pour dire si opération réalisée correctement ou non
o boolean delete() : suppriment un fichier
o boolean mkdir() : crée un répertoire ou dossier
Une classe particulière : la classe Scanner
 Elle se trouve dans le package java.util.Scanner
 Elle simplifie la lecture de données
 Exemple 1: lecture d‟un entier au clavier
Scanner sc = new Scanner(System.in);
int i = sc.nextInt() ;
 Exemple 2: lecture dans un fichier
Scanner sc = new Scanner(new File(“fichierentree.txt”));
/* hasNextLong ou hasNextLine() pour une ligne ou hasNext()
pour un mot */
While (sc.hasNextLong())
{
long var = sc.nextLong(); // ou nextLine() ou next()
}
 Exemple 3: séparateur de champs
String inp = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(inp).useDelimiter("\\s*fish\\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();
Résultats:
1
2
red
blue
Exercice 1 :
Ecrire une application pour la saisie au clavier d‟octets, transformés en chaîne
de caractères pour écrire à l‟écran ce qui a été saisi. La transformation d‟octet en
chaîne de caractère s‟obtient par l‟instruction : String s = new String(byte). On
utilise le System.in (i.e., périphérique d‟entrée par défaut du système = le
clavier), et le System.out (i.e., le périphérique de sortie par défaut du système =
l‟écran). A l‟affichage du résultat saisi, l‟application doit afficher 128 octets.
Exercice 2 :
Ecrire une application qui permet de charger le contenu d‟un fichier donné en paramètre lors
de l‟exécution de l‟application et d‟écrire son contenu à l‟écran après avoir transformé les
octets en chaîne de caractères. Le nombre d‟octets à lire dans le fichier est également donné
au départ. Le flux d‟entrée est une instanciation de la classe FileInputStream ou FileReader ou
Scanner.
Exercice 3 :
Ecrire une application qui permet de sauvegarder ce qui est saisi au clavier dans
un fichier dont le nom est donné en paramètre d‟appel de l‟application. Le flux
de sortie est une instanciation de la classe FileOutputStream ou de FileWriter.
Exercice 4 :
Ecrire une application qui permet de copier caractère par caractère un fichier
dans un autre, en utilisant FileReader et FileWriter.
Chapitre 6 – Les filtres sur les flux d’entrée/sortie
Gestion de données par des filtres sur les flux d’entrée/sortie

 Filtrer un flux d‟entrée ou de sortie est parfois nécessaire pour
transformer la manière dont sont gérées les données lors de la lecture ou
l‟écriture
 Principes :
o Créer un buffer (i.e. mémoire tampon) pour la lecture ou l‟écriture
d‟une suite de caractères. Ceci permet de conserver les données
avant lecture ou écriture dans un support, et donc d‟éviter les
opérations d‟E/S permanentes.
o Exploiter des méthodes plus faciles à utiliser.
o Filtrer les saisies : filtre pour un flux d‟entrée sur un fichier texte,
filtre anglais-français ; filtre anti-juron, filtre pour mots interdits,
etc.
o Filtrer le format des entrées et sorties
o Filtrer un filtre pour augmenter un niveau de sécurité par exemple.
 Ce cours se limite à quelques filtres :
o BufferedInputStream, DataInputStream de la super classe
InputStream
o BufferedOutputStream, DataOutpuStream, PrintStream de la super
classe OutputStream
o BufferedReader de la super classe Reader
o BufferedWriter, PrintWriter de la super classe Writer
Le filtre BufferedInputStream
 C‟est un filtre sur un flux d‟entrée InputStream.
 Une de ses méthodes constructeurs prend donc un objet InputStream en
paramètre.
 Quelques méthodes
o int read(): idem que pour FileInputStream
o int read(byte[], int, int): idem que pour FileInputStream
o …
Le filtre DataInputStream
 C‟est un filtre sur un flux d‟entrée InputStream
 Une de ses méthodes constructeurs prend donc un objet InputStream
en paramètre
 Quelques méthodes :
o int read(byte[]) : idem que pour FileInputStream
o int read(byte[], int, int): idem que pour FileInputStream
o boolean readBoolean(): lit un octet et renvoie la valeur true s‟il
est différent de zéro et false s‟il est à zéro
o byte readByte(): lit un octet et revoie
o char readChar(): lit un caractère et renvoie sa valeur
o int readInt(): lit quatre octets et renvoie un nombre entier
o float readFloat() : lit quatre octets et renvoie un nombre à
virgule (float)
o …
Le filtre BufferedOutputStream
 C‟est un filtre sur un flux d‟entrée OutputStream
 Une de ses méthodes constructeurs prend donc un objet OutputStream
en paramètre
o void write(byte[], int, int): idem que pour FileOutputStream
o void write(int) : idem que pour FileOutputStream
o …
Le filtre DataOutputStream
en paramètre
o void writeBoolean(boolean): écrit un booléen sur un octet
o void writeBytes(String): écrit une chaîne de caractères comme
une séquence d‟octets.
o void writeChars(String): écrit une chaîne de caractères comme
une séquence de caractère.
o void writeInt(int): écrit un entier sur quatre octets
o …
Le filtre PrintStream
en paramètre
o void print(char) : écrit un caractère
o void print(char[]) : écrit un tableau de caractères
o void print(int) : écrit un entier
o void println(…) : écrit un caracgtère, un tableau, un entier …
avec le passage à la ligne suivante (i.e. « \n »)
o …
Le filtre BufferedReader
 C‟est un filtre sur un flux d‟entrée Reader
 Une de ses méthodes constructeurs prend donc un objet Reader en
paramètre
o int read() : idem que pour FileReader
o int read(char[], int, int ): idem que pour FileReader
o String readLine() : lit une ligne de texte
o …
Le filtre BufferedWriter
 C‟est un filtre sur un flux d‟entrée Writer
 Une de ses méthodes constructeurs prend donc un objet Writer en
paramètre
o void write(int) : idem que pour FileWriter
o void write(char[] cbuf, int off, int len): idem que pour FileWriter
o void write(String, int, int): idem que pour FileWriter à partir
d‟une chaîne de caractèresvoid newLine() : écrit le caractère de
passage à la ligne (i.e., « \n »)
o …
Le filtre PrintWriter
 C‟est un filtre sur un flux d‟entrée Writer ou OutputStream
 Une de ses méthodes constructeurs prend donc un objet Writer ou
OutputStream en paramètre
o void write(int): idem que pour FileWriter
o void write(char[] ) : idem que pour FileWriter
o void write(char[], int, int): idem que pour FileWriter
o void write(String) : écrit une chaine de caractères
o void write(String s, int off, int len): écit une partie d‟une chaîne
de caractères
o void print(boolean) : écrit une valeur booléenne
o void print(char) : écrit un caractère
o void print(char[]) : écrit un tableau de caractères
o void …
Exercice 1
Ecrire une application permettant de copier un fichier dans un autre en prenant
un filtre BufferedReader sur un flux d‟entrée FileReader, et un filtre PrintWriter
sur un flux de sortie FileWriter.
Exercice 2
Ecrire une application permettant de copier un fichier dans un autre en prenant
un filtre BufferedReader sur un flux d‟entrée FileReader, et un filtre PrintStream
sur un flux de sortie FileOutputStream.
Exercice 3
Lire 4 lignes de texte dans un fichier, les trier par ordre alphabétique, et mettre
le résultat dans un fichier. Utiliser la méthode compareTo() de la classe String
qui permet de comparer alphabétiquement deux objets de la classe String
(exemple : string1.compareTo(string2)==0  le contenu de string1 et string2
sont identiques ; string1.compareTo(string2)>0  le contenu de string1 est plus
grand que le contenu de string2, i.e. par ordre alphabétique, string2 est avant
string1)
Chapitre 7 – Les interfaces utilisateurs : les classes AWT et
Swing
Principes de base sur les interfaces
 Une interface est un moyen pour une classe d‟hériter des méthodes dont elle
n‟hériterait pas autrement de sa classe mère
 Une interface est une classe abstraite particulière dont toutes les variables sont
constantes et dont toutes les méthodes sont abstraites (i.e., elles sont limitées à leur
signature, elles n'ont pas de corps).
 Pour signifier qu'une classe hérite d'une interface on dit qu'elle implémente l'interface,
on utilise le mot clé « implements »
 Lorsqu'une classe implémente une interface, elle doit obligatoirement redéfinir toutes
les méthodes de l'interface (leur attribuer du code). Si une méthode de l'interface ne
sert pas, on lui attribue alors un corps vide (écrire l'en-tête avec une paire d'accolades
vides).
 En JAVA, il n‟existe que le principe d‟héritage simple : une classe ne peut avoir
qu'une seule classe mère (un seul extends). Par contre, elle peut implémenter plusieurs
interfaces. Les interfaces permettent donc de réaliser une certaine forme d'héritage
multiple.
 Remarque sur la limite de l‟héritage simple en JAVA. Par exemple : si une classe
Animal a deux sous-classe Oiseau (avec les méthodes becs, plumes et œufs) et
Mammifères (avec les méthodes fourrures et bébés vivants), le cas de l‟ornithorynque
qui fait des œufs et a une fourrure ne peut pas être traité !
 Une classe abstraite ne peut pas être instanciée, i.e. on ne peut pas utiliser l‟opérateur
« new » pour créer une instance de cette classe.
 Utilisation par le mot-clé « implements » + Nom de l‟interface ou Noms des interfaces
séparés par une virgule (C‟est le principe du multi-interfaçage)
 Pour la création d‟une nouvelle interface : public interface Nominterface { // Code }
 Possibilité de créer à partir du mot clé « extends » une classe fille à partir d‟une classe
mère qui implémente une interface
 Avertissement : certaines méthodes sont dites « deprecated », i.e. elles sont amenées à
disparaître dans les futures versions de Java. Elles ne sont pas traiter dans ce cours.
 Par exemple :
interface Fruitlike {
void pourrir() ;
void secraser() ;
}
class Fruit implements Fruitlike {
private Color MaCouleur;
private int jourconcerve;
}
interface Spherelike {
void lancer();
void rouler();
}
class Orange extends Fruit implements Spherelike {
...
}
Remarque: la classe Orange n‟a pas besoin d‟indiquer “implements Fruitlike” car cela est
indiqué dans le fait qu‟elle étend la classe Fruit !
La classe AWT
 Abstract Window Toolkit disponible dans la package java.awt
 Hiérarchie de classes :
 Component
 Button
 Container
 Label
 Window
 Frame
 Dialog
 FileDialog
 TextComponent
 TextArea
 TextField
 …
 MenuComponent
 MenuBar
 MenuItem
 Menu
 …
 Cette classe permet de créer des interfaces utilisateurs, de traiter des

composants graphiques (classe Component), des polices de
caractères, des couleurs, des icônes.
 Certains composants de cette classe sont des conteneurs, i.e., ils
peuvent contenir d‟autres composants graphiques. Ces conteneurs
sont : Panel, Window, Dialog et Frame. Pour ajouter un composant
à un conteneur, utiliser la méthode add(Component)
 Exemple de composants :
 La classe Window : pour traiter des fenêtres
 La classe Frame : pour traiter des fenêtres avec cadre, barre de titre, et
possibilité de barres de menu
 La classe Dialog : pour traiter des boîtes de dialogue spécifiques
 La classe Button : pour traiter des boutons
 La classe TextField : pour traiter des zones de saisie et d‟affichage de
texte
 La classe Label : pour traiter des zones de texte
 La classe MenuItem : pour traiter des menus déroulants
 Etc.
Exemple de la classe Container
 Composant pouvant contenir d‟autres composants
 add(Component) : ajoute un composant à la fin du conteneur.
Par exemple, l‟ajout de composants comme Button ou Label
dans un cadre : add(ref_bouton), add(ref_label), etc. La mise en
page ou la disposition des composants dans le conteneur : traiter
avec le setLayout
o add(Component, int) : ajoute un composant à la position
prédéfinie par l‟entier donné en paramètre
o paint() : dessine le contenu du conteneur
o setFont(Font) : alloue une police de caractère au conteneur
o setLayout(LayoutManager) : alloue un ordre d‟affichage des
composants du conteneur
o …
Disposition des composants:

 Exemples de classes: FlowLayout, GridLayout, BorderLayout, …
 Créer une instanciation d‟un Layout, et la valider par la méthode
setLayout(ref_layout)
 FlowLayout : composants à la suite, en ligne, de gauche à droite ;
lorque qu‟il n‟y a plus de lace sur une ligne, passage à la ligne
suivante :
…
FlowLayout flow = new FlowLayout(FlowLayout.LEFT);
setLayout(flow) ;
…
 GridLayout : composants à la suite sur une matrice dont les lignes et
colonnes sont données par deux entiers :
…
GridLayout grid = new GridLayout(int, int) ;
setLayout(grid);
…
 BorderLayout : décomposition en 5 parties géographiques (nord, sud,
est, ouest, centre)
...
win = new Frame(“Ma super fenêtre”);
win.setLayout(new BorderLayout());
win.add(“North”, new Button(“Commencer”));
win.add(“Center”, new Button(“Déplacer”));
…
Exemple de la classe Window
 Composant fenêtre sans bordure ni menu.
o addWindowListener(WindowListener) : ajoute un écouteur
d‟événement fenêtre (voir chapitre suivant)
o setBounds(int, int, int, int) : dimensionne la taille de la fenêtre par les
coordonnées d‟un point, avec une hauteur et une largeur
o setBackground(Color) : donne une couleur de fond à la fenêtre
o setLocation(int, int) : déplace la fenêtre aux coordonnées du point
donné (le point en haut, à gauche de la fenêtre)
o setLocation(Point) : idem mais avec un objet de la classe Point
o setSize(int, int) : dimensionne la hauteur et la largeur de la fenêtre
o setVisible(boolean) : affiche (boolean=true) ou cache (boolean=false)
la fenêtre
Exemple de la classe Frame

 Création d‟un cadre avec différents constructeurs tels que :
 new Frame() : cadre sans titre
 new Frame(String) avec la chaîne de caractères String comme titre.
 getIconImage() : renvoie l‟image de l‟icône du cadre
 getTitle() : renvoie le titre du cadre
 setIconImage(Image) : envoie une image d‟icône au cadre
 setTitle(String) : envoie un titre au cadre
 setMenuBar(MenuBar) : intègre la barre de menu MenuBar dans la
fenêtre
 …
Exemple de la classe Dialog :

 Constructeurs et classe FileDialog :
o Création d‟une boîte de dialogue : Dialog(Frame, boolean) crée une
boîte de dialogue modale ou non (booléen = true ou false
respectivement) invisible dans la fenêtre en cours ; Dialog(Frame,
String, boolean) crée une boîte de dialogue invisible ou non et ce
avec le titre proposé.
o Sélection de fichiers : objets FileDialog pour créer des boîtes de
dialogue de sélection de fichiers permettant d‟accéder au système
de fichiers local pour ouvrir ou enregistrer des fichiers :
FileDialog(Frame, String) ou FileDialog(Frame, String, int) pour
sélectionner des fichiers dans la fenêtre et le titre indiqués, et
l‟entier permet de dire s‟il s‟agit d‟un enregistrement (i.e., SAVE)
ou d‟un chargement (i.e. LOAD) de fichiers (FileDialog.LOAD ou
FileDialog.SAVE)
o getDirectory() et getFile() renvoie le nom de répertoire ou de
fichier sélectionné.
o setVisible(boolean) : affiche ou n‟affiche pas la boite de dialogue
(boolean= true ou false respectivement)
o getTitle() : renvoie le titre de la boite de dialogue
o …
Exemple de la classe MenuBar :

 Affichage d‟une barre de menu dans la fenêtre : impossible d‟en créer
dans des applets mais possible d‟en créer dans une fenêtre indépendante
d‟une applet
 Créer à partir d‟une nouvelle instance de la classe MenuBar : MenuBar
mbar = new MenuBar() ;
 A partir de cette instance, appliquer les méthodes ci-dessous
o add(Menu) : ajoute le menu indiqué
o getMenu(int) : récupère le menu dont la place est indiquée par
l‟entier donné en paramètre
o getMenuCount() : renvoie le nombre de menus dans la barre de
menu
o …
Exemple de la classe Menu :

o add(MenuItem) : ajoute un objet MenuItem dans le menu indiqué,
la méthode renvoyant un objet MenuItem
o add(String) : ajoute un item String dans le menu
o addSeparator() : intègre un séparateur dans le menu
o getItem(int) : renvoie l‟item dont la place est indiqué par l‟entier
donné en paramètre, la méthode renvoyant un objet MenuItem
o getItemCount() : renvoie le nombre d‟items dans le menu
o insert(MenuItem, int) : insère un objet MenuItem à la place
indiquée par l‟entier
o remove(int) : supprime l‟item dont la place est donnée par l‟entier
o remove(MenuItem) : supprime l‟objet MenuItem donné
o …
Exemple de la classe Button :

 Méthode constructeur :
o Button(String) : crée un bouton avec le nom String
o addActionListener(ActionListener) : ajoute le bouton comme
composant pouvant recevoir et traiter des événements d‟action
o getLabel() : renvoie le nom du bouton
o setLabel(String) : envoie un nom au bouton
Exemple de la classe TextField :

 Exemples de méthodes constructeurs :
o TextField(int) : crée un objet TextField vide avec un nombre de
colonnes défini par l‟entier donné en paramètre
o TextField(String) : crée un objet TextField avec le texte String
initial
o addActionListener(ActionListener) : ajoute le TextField comme
composant à partir duquel des événements d‟action peuvent être
traités
o getColumns() : renvoie le nombre de colonnes du TextField
o setColumns(int) : donne le nombre de colonne du TextField à partir
de l‟entier donné en paramètre
o setText(String) : envoie la chaine de caractères String au TextField
o …
Exemple de la classe TextArea :

o TextArea(int, int) : crée un objet TextArea avec un nombre de
lignes et de colonnes prédéfini
o TextArea(String) : crée un objet TextArea avec le texte String
initial
o append(String) : insère le texte String dans le texte existant
o getColumns() : renvoie le nombre de colonnes du TextArea
o getRows() : renvoie le nombre de lignes du TextArea
o insert(String, int) : insère la chaine de caractères String à la position
spécifiée par l‟entier donné
o …
Exemple de la classe Label :

o Label(String) : crée un objet Label contenant le texte String donné
o getText() : renvoie le texte du Label
o setText(String) : donne le texte String au Label
o …
La classe Swing
 Principes
o Extension de la classe AWT
o Fonctionnalités améliorées
 Différences avec AWT

o Apparence des composants
o Plus de composants pour Swing
o Les composants de Swing commencent par J (ex : JButton, JLabel, …)
o Package : import javax.swing.*
Exemple de composants :
 JFrame, JButton, JLabel, JTextArea, JTextField, JRadioButton, JCheckBox,
JPasswordField, JComboBox, JList, JScrollBar, etc.
 JButton(String) : crée un bouton avec le texte ; JButton(Icon) : crée un
bouton avec l‟icône ; JButton(String, Icon) : crée un bouton avec le texte et
l‟icône
 JLabel(String, int) : crée un intitulé avec le texte et l‟alignement (LEFT,
RIGHT, CENTER) ; JLabel(String, Icon, int) : crée un intitulé avec le texte ,
l‟icône, et l‟alignement
 JTextArea(int, int) : crée un zone de texte avec lignes et colonnes ;
JTextArea(String, int, int) : crée un zone de texte avec le texte, lignes et
colonnes
 JCheckBox(String) : crée une case à cocher avec le texte ; JCheckBox(String,
boolean) : crée une case à cocher avec le texte, case sélectionnée si
l‟argument booléen est vrai ; JCheckBox(Icon) : crée une case à cocher avec
l‟icône ; JCheckBox(Icon, boolean) : crée une case à cocher avec l‟icône,
case sélectionnée si l‟argument booléen est vrai
 JComboBox() : crée une liste de choix en utilisant à chaque ajout de choix la
méthode addItem(Object), puis setEditable(boolean) qui rend la liste éditable
 JScrollBar(int) : crée une barre de défilement avec l‟orientation ;
JScrollBar(int, int, int, int, int) : crée une barre de défilement avec
l‟orientation (HORIZONTAL, VERTICAL), la valeur de départ, la taille du
curseur de défilement, les valeurs min et max
 JTable(int, int) : permet de créer des tableaux en précisant le nombre de
lignes et colonnes
 …
Note : pour simplifier, les classes de swing ne sont pas développées mais seront illustrées au
travers des exercices.
Exercice 1
Afficher une fenêtre avec AWT et swing
Exercice 2
Afficher une fenêtre et la déplacer de (0, 0) à (500, 500) contenant deux boutons B1 et B2, en
utilisant AWT et swing, et en testant le FlowLayout ou le BorderLayout. Mettre une
instruction itérative qui ne fait rien pour percevoir le mouvement de la fenêtre (sinon le
déplacement se fera trop vite et donnera l‟impression qu‟il n‟y en a pas ! Sinon utiliser
l‟instruction Thread.sleep(int))
Exercice 3
Créer une barre de menu dans une fenêtre avec AWT et swing, contenant deux boutons
« bouton1 » et « bouton2 », et dans « bouton 1 », intégrer un menu déroulant contenant deux
options : « sous-menu1 » et « sous-menu2 »
Exercice 4
Avec AWT, afficher dans une fenêtre le contenu d‟un fichier de chaînes de caractère, mettre
le contenu de chaque enregistrement dans une barre de menu
Note : dans ces exemples d‟application, il n‟est pas possible de quitter proprement
l‟application car les événements ne sont pas traiter. En JAVA, il faut explicitement préciser ce
que le programme doit faire lorsqu‟il y a tel ou tel événement. Ces événements sont par
exemple des touches du clavier, des clics avec la souris, des actions sur une fenêtre, etc. Le
chapitre suivant traite de cette gestion des événements.
Chapitre 8 – La gestion d’événement
La classe Component
 Cette classe contient les composants de la classe AWT.
 Elle comporte des méthodes utiles dont certaines pouvant traitées des
évènements sur des composants :
o addMouseListener(MouseListener) : ajoute un écouteur d‟événement
de la souris sur le composant courant
o addMouseMotionListener(MouseMotionListener) : ajoute un écouteur
de déplacement du curseur de la souris sur le composant courant
o addKeyListener(KeyListener) : ajoute un écouteur d‟événement du
clavier sur le composant courant
o getX() : renvoie l‟abscisse du composant d‟origine
o getY() : renvoie l‟ordonnée du composant d‟origine
o getMousePosition() : renvoie un objet Point dont les coordonnées sont
celles du curseur de la souris
o getLocation() :
o paint() : dessine le composant
o processFocusEvent(FocusEvent) : traite les événements liés à la mise
au premier plan ou en arrière plan d‟un composant
o processKeyEvent(KeyEvent) : traite les événements liés au clavier
o processMouseEvent(MouseEvent) : traite les événements liés à la
souris
o processMouseMotionEvent(MouseEvent) : traite les événements liés
au déplacement du curseur de la souris
o processMouseEvent(MouseEvent)
o repaint() : redessine le composant
o …
La classe event
 Cette classe contient :
o Les classes d‟événements telles que : ActionEvent, MouseEvent,
WindowEvent, etc. Ces classes ont leurs propres méthodes et héritent
d‟autres méthodes intéressantes telles que :
 getComponent() : renvoie l‟objet Component à partir duquel
l‟événement a été généré
 getSource() : renvoie l‟objet Object à partir duquel l‟événement
a été généré
 …
o Les écouteurs d‟événements (classes abstraites d‟interface) sur les
composants tels que ActionListener, FocusListener, KeyListener,
MouseListener, TextListener, WindowFocusListener,
WindowListener, etc :
Exemples d’écouteurs d’événements :

 ActionListener : écouteur d‟événements d‟action, générés par une action de
l‟utilisateur (ex : click bouton)
 AdjustmentListener : écouteur d‟événement d‟ajustement, générés quand un
composant est ajusté (ex : déplacer une barre de défilement)
 FocusListener : écouter d‟événement de focus, générés quand un composant
reçoit ou perd le focus (ex : champ de saisie de texte)
 ItemListener : écouteur d‟événements d‟éléments, générés quand un élément
a été modifié (ex : une case à cocher)
 KeyListener : événements de clavier quand saisie au clavier
 MouseListener : écouteur d‟événements de souris (ex : click, entrée ou sortie
dans ou d‟une surface d‟un composant)
 MouseMotionListener : écouteur d‟événements de mouvement de souris (ex :
déplacement de la souris dans un composant)
 WindowListener : écouteur d‟événements de fenêtre (ex : min, max,
déplacement, fermeture d‟une fenêtre)
Méthode 1 pour gérer les événements :

 Implémenter le ou les écouteurs nécessaires avec le mot clé « implements »
 Utiliser les méthodes addxxxListener sur les composants de l‟application ou
de l‟applet sur lesquels des événements sont traités
 Ecrire le contenu de toutes les méthodes d‟instance des écouteurs
d‟événements
L’écouteur ActionListener
 Méthodes d‟instance à réécrire :
o void ActionPerformed(ActionEvent e) {code à écrire si besoin}
L’écouteur MouseListener
o void mouseClicked(MouseEvent) {code à écrire si besoin lorqu‟un
bouton de la souris est activé}
o void mouseEntered(MouseEvent) {code à écrire si besoin lorsque e
curseur de la souris entre dans l‟application}
o void mouseExited(MouseEvent) {code à écrire si besoin lorsque le
curseur de la souris sort de l‟application}
o void mousePressed(MouseEvent) {code à écrire si besoin lorsqu‟un
bouton de la souris est appuyé}
o void mouseReleased(MouseEvent) {code à écrire si besoin lorsqu‟un
bouton de la souris est relâché}
L’écouteur MouseMotionListener
o void mouseDragged(MouseEvent) {code à écrire si besoin lorsque la
souris est déplacée avec le maintien d‟appui sur un bouton}
o void mouseMoved(MouseEvent {code à écrire si besoin lorsque le
curseur de la souris a été déplacé sur un composant}
L’écouteur WindowsListener
o void windowActivated(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est activée}
o void windowClosed(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est fermée, cette méthode est appelée après
fermeture de la fenêtre}
o void windowClosing(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est fermée, mais cette méthode donne la possibilité
de réaliser certaines actions avant la fermeture}
o void windowDeactivated(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est désactivée}
o void windowDeiconified(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est restaurée}
o void windowIconified(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est mise sous icône}
o void windowOpened(WindowEvent) {code à écrire si besoin
lorsqu‟une fenêtre est ouverte}
Fermeture d’une application

o L‟arrêt d‟une application nécessite l‟instruction suivant : System.exit(0).
Cette instruction peut être corrélée avec la fermeture d‟une fenêtre en
l‟intégrant dans la méthode windowClosing par exemple.
o Une autre manière de quitter l‟application en fermant une fenêtre JFrame est
l‟exploitation de la méthode : setDefaultCloseOperation(int) avec l‟entier
égal à JFrame.EXIT_ON_CLOSE.
Méthode 2 pour gérer les événements :

 Appeler la méthode enableEvents(long). Le paramètre long est un masque de
AWTEvent précisant le type d‟événements à traiter. Des variables à valeurs
constantes peuvent être utilisées :
o pour les événements de la fenêtre, mettre le masque prédéfini suivant:
AWTEvent.WINDOW_EVENT _MASK
o pour les événements simples de la souris, mettre le masque prédéfini
suivant : AWTEvent.MOUSE_EVENT_MASK
o pour les événements complexes de mouvement de la souris, mettre le
masque prédéfini suivant :
AWTEvent.MOUSE_MOTION_EVENT_MASK
o pour les événements du clavier, mettre le masque prédéfini suivant :
AWTEvent.KEY_EVENT_MASK
o pour tous les types d‟événement, mettre le masque prédéfini suivant :
AWTEvent.ACTION_EVENT_MASK
o …
 Ecrire le contenu des méthodes suivantes: « protected void
processxxxEvent(xxxEvent) { code à écrire pour traiter les événements}
 Dans le code à écrire, on peut utiliser des méthodes comme la méthode
d‟instance getID() qui renvoie un entier associé à l‟événement généré. Des
variables à valeurs constantes sont prédéfinies dans la classe Event de
JAVA :
o Event.WINDOW_DESTROY : généré quand une fenêtre est détruite à
l‟aide de l‟icône de fermeture
o Event.WINDOW_EXPOSE : généré quand une fenêtre est basculée au
1er plan alors qu‟elle était masquée par d‟autres
o Event.WINDOW_ICONIFY : généré quand une fenêtre est réduite à
l‟état d‟icône
o Event.WINDOW_DEICONIFY : généré quand une fenêtre est
restaurée après avoir été réduite à l‟état d‟icône
o Event.WINDOW_MOVED : généré quand une fenêtre est déplacée
o Event.MOUSE_DOWN : généré quand le bouton souris est enfoncé
o Event.MOUSE_UP : généré quand le bouton souris est relâché
o Event.MOUSE_ENTER : généré quand la souris entre dans l‟aplet ou
dans une application
o Event.MOUSE_EXIT : généré quand la souris sort de l‟application ou
de l‟applet
o Event.MOUSE_MOVE : généré quand le curseur de la souris est
déplacé sans appui sur un bouton de la souris
o Event.MOUSE_DRAG : généré quand la souris est déplacée avec un
bouton maintenu appuyé
o Quelques touches clavier : Event.HOME (home ou début), Event.END
(fin ou end), Event.PGUP (clavier : page précédente), Event.PGDN
(page suivante), Event.UP (flèche haute), Event.DOWN (flèche
descendante), Event.LEFT (flèche gauche), Event.RIGHT (flèche
droite), Event.F1 à Event.F12 (touche F1 à F12)
o Barre de défilement : Event.SCROLL_ABSOLUTE (curseur de barre
de défilement déplacé), Event.SCROLL_LI NE_DOWN (bouton
gauche ou inférieur sélectionnée), Event.SCROLL_LINE_UP (bouton
droit ou supérieur sélectionné), Event.SCROLL_PAGE_DOWN
(champ du dessous ou à gauche du champ d‟une barre de défilement
sélectionné), Event.SCROLL_PAGE_UP (champ au-dessus ou à
droite du champ d‟une barre de défilement sélectionné)
Boites de dialogue de la classe swing

 Boîtes de dialogue
o ConfirmDialog : boîte standard qui pose une question et compose les
réponses Yes/No/Cancel
o InputDialog : boîte qui demande à l‟utilisateur de saisir du texte
o MessageDialog : boîte qui affiche un message
o OptionDialog : boîte qui intègre les 3 types précédents
o Chaque boîte a sa propre méthode JOptionPanel pour définir les options
 Méthodes de boîte de dialogue
o showConfirmDialog(Component, Object) : affiche une boîte de dialogue
standard avec le conteneur qui est le parent de la boîte (si null ou si
conteneur n‟est pas un JFrame : boîte centrée au centre) et l‟objet (Texte,
componant ou Icon). La méthode renvoie un entier : YES_OPTION,
NO_OPTION, CANCEL_OPTION
o Autre options : showConfirmDialog(Component, Object, String, int, int) :
o String sera affiché dans la barre des titres
o int donne les boutons d‟options à afficher
(YES_NO_CANCEL_OPTION ou YES_NO_OPTION)
o int pour le type de boîte de dialogue (ERROR_MESSAGE,
INFORMATION_MESSAGE, PLAIN_MESSAGE,
QUESTION_MESSAGE ou WARNING_MESSAGE)
o showInputDialog(Component, Object) ou showInputDialog(Component,
Object, String, int) : String est le texte du titre, et int est le type de la boîte
(ERROR_MESSAGE, INFORMATION_MESSAGE,
PLAIN_MESSAGE, QUESTION_MESSAGE ou
WARNING_MESSAGE)
o showMessageDialog(Component, Object) ou
showMessageDialog(Component, Object, String, int)
o showOptionDialog(Component, Object, int, int, Icon, Object[], Object) :
o String est le titre de la boîte,
o int les boutons d‟option de la boîte de dialogue
(YES_NO_CANCEL_OPTION ou YES_NO_OPTION ou 0 si autres
boutons)
o int pour les icônes de type de la boîte (ERROR_MESSAGE,
INFORMATION_MESSAGE, PLAIN_MESSAGE,
QUESTION_MESSAGE ou WARNING_MESSAGE)
o Icon à afficher à la place de l‟une des icônes précédentes
o Object[] une matrice d‟objets contenant les composants ou autres
objets représentant les choix de la boîte (si
YES_NO_CANCEL_OPTION et YES_NO_OPTION ne sont pas
utilisés),
o Object l‟objet représentant les choix par défaut (si
YES_NO_CANCEL_OPTION et YES_NO_OPTION ne sont pas
utilisés)
o Exemple :
JButton[] gender = new JButton[3] ;
gender[0] = new JButton(« Masculin ») ;
gender[1] = new JButton(« Feminin ») ;
gender[2] = new JButton(« Indetermine ») ;
int reponse = JoptionPane.showOptionDialog(null, “Specifier votre
sexe”, “questionnaire”, 0,
JoptionPane.INFORMATION_MESSAGE, null, gender,
gender[2]);
Résultat:
Le titre de la boite de dialogue est: questionnaire
Icône de la boîte: Icône de message d‟information avec le texte
“Spécifier votre sexe”
Trois boutons alignés s‟affichent: « Masculin », « Feminin » et
« Indetermine »
Choix par défaut sélectionné : Indetermine
Exercice 1
Mettre en œuvre une application permettant de sélectionner trois boutons
« Masculin », « Feminin » et « Indetermine », et d‟indiquer dans un objet Label
le choix effectué
Exercice 2
Ecrire une application qui affiche sur une zone de texte d‟une fenêtre
l‟historique des événements générés (se limiter aux événements de la souris)
Exercice 3
Faire une palette de couleur sur 64 boutons ayant une couleur de fond variant du
vert vers le blanc
Exercice 4
Ecrire une application affichant deux boutons « Ouvrir/Afficher Fichier » et
« Quitter ». Le premier bouton permet d‟ouvrir une boite de dialogue pour
l‟ouverture d‟un fichier et afficher son contenu dans une zone de texte. Le
deuxième bouton permet de quitter l‟application.
Chapitre 9 – La classe Graphics
Généralités :
 import java.awt.Graphics
 Système de coordonnées graphiques de JAVA: en haut à gauche (0, 0) et
en bas à droite = (max, max)
Exemples de méthodes pour le dessin:

o drawString(“Texte”, x1, y1): écrit le texte “texte” aux coordonnées (x1,
y1)
o drawLine(x1, y1, x2, y2) : trace un trait du point (x1, y1) au trait (x2, y2)
o drawRect(x1, y1, haut, larg) : dessine un rectangle depuis le point (x1, y1)
avec la hauteur « haut » et la largeur « larg » ;
o fillRect(x1, y1, haut, larg) : dessine un rectangle plein
o drawRoundRect(x1, y1, x2, y2, alarg, ahaut) : dessine un rectangle arrondi
o drawPolygon(x[], y[], nbpt) ou drawPolygon(xy[][], nbpt) ou
fillPolygon(x[], y[], nbpt) ou fillPolygon(xy[][], nbpt) dessinent des
polygones
o drawOval(x1, y1, haut-ou-larg) : dessine un forme oval inclut dans le
rectangle partant du point (x1, y1) avec une hauteur « haut » et une
largeur « larg » ; fillOval(x1, y1, haut-ou-larg) : dessine une forme ovale
pleine
o drawArc(x1, y1, larg-de-oval, haut-de-oval, angle-debut-arc, nb-degre-a-
tracer) ou fillArc (pour dessiner les camemberts par ex) dessinent des arcs
o …
Copier et effacer des éléments :

o copyArea(x1, y1, haut, larg, dist-horizontale, dist-verticale) copie une
région rectangulaire de la fenêtre vers une autre région de la fenêtre
o clearRect(x1, y1, larg, haut) efface une région rectangulaire de la fenêtre ;
o Pour effacer complètement une fenêtre : screen.clearRect(0, 0,
size().width, size().height)
Textes et polices :
o getFont() : renvoie la police de caractères courante
o getFontMetrics(Font) : renvoie les caractéristiques de la police de
caractères donné
o Objet Font spécifié avec des constructeurs ayant différents
arguments (e.g., nom de la police, style de la police, taille en point
de la police).
o Exemple : Font f = new Font(« Dialogue »,
Font.BOLD+Font.ITALIC, 24).
o Les méthodes de la classe FontMetrics donnent des infos sur la
police courante. Par exemple :
 stringWidth(String) renvoie la largeur en entier de la chaîne
de caractère donnée
 charWidth(char) renvoie la largeur en entier du caractère
donné
 getHeight() : renvoie la hauteur de la police courante
 …
o setFont(Font) : spécifie la police de caractère à utiliser
Couleur :
 getColor() : renvoie la couleur de l‟objet Graphics
 setColor(Color) : donne une couleur à l‟objet GRaphics
 La classe Color :
 Codage Rouge Vert Bleu de noir (0, 0, 0) à blanc (255, 255, 255).
 Objets de la classe Color dont le constructeur prend 3 int ou float
pour les valeurs RVB.
 Exemple de valeurs par défaut connues :
 Color.red (255, 0, 0)
 Color.black(0, 0, 0)
 Color.pink(255, 175, 175)
 Color.white(255, 255, 255)
 Color.yellow (255, 255, 0)
 …
 Dans les composants contenant les objets Graphics, possibilité de
paramétrer les couleurs de fond et de premier plan avec : les méthodes
setBackground(Color) ou setForeground(Color). Pour obtenir les
couleurs de fond de plan ou de premier plan : getBackground() ou
getForeground()
Exercice 1
Ecrire une application permettant d‟afficher une grille 8x8 dans une fenêtre.
Exercice 2
Ecrire une application permettant d‟afficher une grille 8x8 dans une fenêtre et de
saisir 10 cercles dans 10 cases distinctes. L‟application s‟arrête lorsque les 10
cercles ont été saisis.
Exercice 3
Ecrire une application permettant d‟afficher ou d‟effacer une grille 8x8 en
fonction d‟un clic de la souris
Exercice 4
Ecrire une application permettant d‟afficher ou d‟effacer une grille 8x8 en
cliquant sur deux boutons « Afficher grille » et « Effacer grille ».
Chapitre 10 – Les applets
Consignes de sécurité
 Restriction d‟usage des applets au nom de la sécurité mais sans 100% de
garantie (éviter de lire des fichiers confidentiels de l‟ordinateur de
l‟utilisateur où l‟aplet tourne, d‟en effacer, d‟en créer, etc …)
 Règles d‟usage des applets :
o Ne pas écrire et ne pas lire sur le système de fichiers de l‟utilisateur
o Ne pas communiquer avec un site Internet autre que celui qui
diffuse la page Web dont fait partie l‟applet
o Ne pas faire fonctionner des programmes sur le système du lecteur
o Ne pas charger des programmes stockés sur le système de
l‟utilisateur, tels que des exécutables ou des bibliothèques
partagées.
Principes de base
 Différences entre applets et applications: dans l‟exécution. Applications =
exécutées en utilisant un interpréteur JAVA qui charge le fichier de classe
principal (java nom.class). Applets = exécutées via un navigateur Web
compatible avec JAVA (e.g., Netscape Navigator, Microsoft Internet
Explorer, Google Chrome, etc.) ou testées avec l‟utilitaire appletviewer
inclus dans le JDK.
 Possibilité d‟écrire un programme à la fois sous forme d‟application ou
d‟applet : procédures particulières à appliquer
 Les applications contiennent une méthode main() pour appeler le début du
programme, créer des objets, définir des variables d‟instance et appeler
d‟autres méthodes. Les applets ne contiennent pas de main(). Elles
utilisent différentes méthodes appelées à différents instants de l‟exécution
de l‟applet.
 Les applets sont des sous-classes de la classe Applet qui fait partie du
package java.applet.
 Une applet est un conteneur pouvant intégrer des objets graphiques de la
classe AWT. Avec Swing, il est préférable d‟utiliser JApplet. Dans ce
cours, nous resterons sur AWT. Pour ajouter des composants graphiques
dans l‟applet, utiliser la méthode add(Component).
 Créer une applet :
public class MonApplet extends java.applet.Applet { // Code de l‟Applet
ici }
Ou
import java.applet.*;
public classe MonApplet extends Applet{ // Code de l‟Applet ici }
 Tous les applets: « public » pour la classe Applet principale, les classes
auxiliaires sont soit publiques soit privées.
 Lors du chargement d‟une applet dans un navigateur, la classe de cette
applet et ses classes auxiliaires sont chargées. Il est possible que
différentes applets utilisent la même classe, utilisant des instances
différentes : il est possible de placer plusieurs exemplaires d‟une applet
sur une même page : ils fonctionnent indépendamment les uns des autres.
 Exécution d‟une applet : incorporation dans une page Web à l‟aide de
balises HTML, comme une image. Quand un utilisateur charge une page
Web contenant une applet, le navigateur télécharge l‟applet depuis un
serveur Web et l‟exécute sur l‟ordinateur de l‟utilisateur.
 Aucun interpréteur séparé n‟est nécessaire. Il est inclut dans le navigateur.
 Comme une application, une applet inclut un fichier de classe, et les
classes auxiliaires
Méthodes donnant un comportement à l’applet :

 paint() appelée chaque fois que l‟applet a besoin d‟être dessinée ou
redessinée. Par défaut : cette classe ne fait rien, il faut donc la redéfinir
pour lui affecter un comportement propre à l‟applet ou voir des choses
s‟afficher à l‟écran. Une modification du contenu de l‟applet nécessite
l‟appel de la méthode repaint() qui réactualise la méthode paint().
 init() appelée quand l‟applet est chargée et permet de créer les objets dont
l‟applet a besoin , de créer un état initial, de charger des images ou des
polices, ou à définir des paramètres, etc.
 start() : une fois initialiser, l‟applet peut démarrer. Un démarrage est
possible après l‟arrêt de l‟applet lorsque le navigateur suit un lien sur une
page différente et revient sur la page où l‟applet interrompue
momentanément se trouve. Donc : plusieurs démarrages possibles mais
une seule initialisation !
 stop() : arrêt produit lorsque la page où se trouve l‟applet est quittée ou
lorsque l‟arrêt est directement sollicité
 destroy() fait le ménage avant évacuation en mémoire ou avant fermeture
du navigateur. Peut être utilisé pour supprimer des « threads » ou libérer
des objets en cours d‟exécution. Pas besoin de la redéfinir sauf pour
libérer des ressources particulières telles que des « threads » que l‟applet a
créés
 L‟appel aux méthodes init(), start(), stop() et destroy() n‟est pas
obligatoire car c‟est le navigateur qui le gère.
 Le traitement des événements se fait à partir de la classe event de
l‟interface AWT en implémentant les écouteurs requis et en redéfinissant
les méthodes associées.
La balise Applet
 A partir d‟un navigateur Web, il faut charger un fichier html contenant
la balise Applet.
 Ce fichier contient par exemple ces lignes de code :
<HTML>
<HEAD>
<TITLE> La page de mon applet</TITLE>
</HEAD>
<BODY>
<P> Mon applet …
<BR>
<APPLET CODE= « MonApplet.class » WIDTH=600 HEIGHT=100>
... Message d‟erreur
</APPLET>
</BODY>
</HTML>
 Une balise HTML commence par « <NOM_DE_BALISE> » et se
termine par « </NOM_DE_BALISE> ».
 La balise TITLE donne le nom de votre page Web, la balise P définit un
paragraphe et la balise BR un retour à la ligne (cette balise ne nécessite
pas de « </NOM_DE_BALISE>), etc.
 La balise <APPLET> comprend 3 attributs : CODE (nom de fichier de la
classe principale de l‟applet, stocké dans le même dossier que la page
Web contenant l‟applet), WIDTH (largeur de la fenêtre de l‟applet sur la
page Web) et HEIGHT (hauteur de la fenêtre de l‟applet).
 Pour exécuter une applet, il faut un fichier MonApplet.java, qui sera
précompilé avec la commande javac MonApplet.java, ce qui génèrera le
fichier MonApplet.class qu‟on retrouve dans la balise applet.
 Il suffira donc de recopier le fichier HTML ci-dessus et d‟intégrer le nom
de la classe de votre applet, i.e. remplacer « MonApplet.class » par votre
nom de classe.
Options pour la balise applet :

 Attribut CODEBASE pour indiquer le chemin du dossier ou de la page
Web où se trouve le fichier de la classe principale de l‟applet. Par
exemple :
< APPLET CODE= « MonApplet.class » CODEBASE= « Mes
Documents » …
< APPLET CODE= « MonApplet.class » CODEBASE=
« http://www.univ-valenciennes.fr/javaclasses » …
 Attribut ALIGN=LEFT : aligne l‟applet à gauche du texte qui suit l‟applet
sur la page ; =RIGHT : aligne l‟applet à droite du texte qui suit l‟applet
sur la page ; =TEXTTOP : aligne le haut de l‟applet sur le haut de
l‟élément de texte le plus haut de la ligne ; =TOP : aligne l‟applet sur
l‟élément le plus haut de la ligne (lequel peut être une autre applet, une
image ou le haut du texte) ; =ABSMIDDLE : aligne le milieu de l‟applet
sur le milieu de l‟élément le plus grand de la ligne ; =BASELINE : aligne
le bas de l‟applet sur la ligne de base du texte…
 Attributs HSPACE et VSPACE pour définir l‟espace horizontal
(HSPACE) et vertical (VSPACE) en pixels entre l‟applet et le texte qui
l‟entoure. Par exemple, le code qui suit permet d‟afficher un Smiley en
bas à gauche avec 50 pixels verticalement et 10 pixels horizontalement le
séparant du texte :
<APPLET CODE= »ShowSmiley.class » WIDTH = 45 HEIGHT=42
ALIGN=LEFT VSPACE=50 HSPACE=10>
</APPLET>
 Attribut ARCHIVE : pour lire des archives et réduire les temps de
chargement des applets :
o Archives Java avec extension .jar (= série de classes Java et
d‟autres fichiers réunis dans un seul et même fichier ; une seule
connexion est donc nécessaire)
o Autres formats d‟archivage tels que les fichiers .zip)
o Exemple de l‟archive Smiley.jar qui archive les fichiers *.class et
*.giff :
…
<APPLET CODE=« ShowSimley.class » ARCHIVE=
« Smiley.jar » WIDTH=45 HEIGHT=42
...
…
<APPLET CODE=« MonApplet.class » ARCHIVE=
«appletstuff.zip » WIDTH=45 HEIGHT=42
...
 Balise PARAM pour paramétrer une applet. NAME est le nom d‟une
variable définie dans le fichier MonApplet.java, et VALUE donne affecte
une valeur à cette variable :
…
<APPLET CODE=« MonApplet.class » WIDTH=45 HEIGHT=42>
<PARAM NAME=”etudiant” VALUE=”master2”>
…
…
<APPLET CODE=« MonApplet.class » WIDTH=45 HEIGHT=42>
<PARAM NAME=font VALUE=”TimesRoman”>
<PARAM NAME=size VALUE=”24”>
…
 Les paramètres sont transmis à l‟applet au moment de son chargement.

Récupération possible de ces paramètres dans la méthode init() avec la
méthode getParameter(nomParamRecherché) comprenant en argument
une chaîne qui est le nom du paramètre recherché)
 S‟il n‟a pas de paramètre avec PARAM alors la valeur par défaut est
définie dans l‟applet dans la méthode init(). Dans le fichier
MonApplet.html, on a :
…
<PARAM NAME=chainedecaractere VALUE= « valeur par
defaut »>
…
Dans le fichier MonApplet.java, on a :
import java.awt.* ;
public class MonApplet extends java.applet.Applet
{
Font f = new Font(“TimesRoman, Font.BOLD, 36);
String chainedecaractere;
public void paint(Graphics screen)
{
screen.setFont(f);
screen.setColor(Color.red);
screen.drawString(chainedecaractere, 5, 50);
}
public void init()
{
chainedecaractere=getParameter(“ chainedecaractere “) ;
if (chainedecaractere== null)
chainedecaractere= “valeur initiale” ;
}
}
Exercice 1 :
Ecrire une applet permettant d‟afficher une palette de couleur à partir de 64
boutons pour lesquels la couleur de fond varie du rouge vers le blanc, en
fonction de paramètres RVB. Donner la possibilité de sélectionner un bouton
pour voir afficher dans un TextField ces paramètres RVB. Le texte initial de
TExtField est « 000 000 000 ». Utiliser La méthode getActionCommand() qui
renvoie le texte du bouton que l‟utilisateur sélectionne.
Exercice 2 :
Ecrire une applet permettant d‟afficher la couleur de fond d‟un bouton en
fonction de paramètres RVB saisie au clavier via un composant TextField.
Exercice 3 :
Ecrire une applet permettant d‟afficher une grille 8x8 et de saisir 4 cercles dans
les cases. Implémenter la classe MouseListener.

Module JAVA FVanderhaegen Versionauxétudiants2016-2017

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Module JAVA FVanderhaegen Versionauxétudiants2016-2017

Transféré par

Droits d'auteur :

Formats disponibles

Professeur Frédéric VANDERHAEGEN

Université de Valenciennes et du Hainaut-Cambrésis

Chapitre 1 - Les bases

Ce cours se limite à la création d‟applications et d‟applets.

Ecrire, compiler et exécuter une application:

Variable d’environnement ou éditeurs spécifiques

- Utiliser un éditeur qui intègre la possibilité d‟exécuter directement

Contenu d’une application sous éditeur :

Votre premier programme :

Chapitre 2 – Les instructions conditionnelles et itératives

Si le contenu de la variable age est supérieur à 39 strictement, alors le

if (age > 39)

Si le contenu de la variable age est supérieur à 39 strictement, alors le

Elle renvoie le plus grand de resultat1 et resultat2 dans meilleurresultat

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

Chapitre 3 – Les variables et les méthodes

Quelques mots mots-clés :

Mot clé « new » :

Différents type de méthodes peuvent être développées :

Appel croisé entre méthodes constructeurs

Surcharge des constructeurs

Redéfinir une méthode et rappeler l’originale

Redéfinition d’une méthode constructeur

Gestion des exceptions

Hiérarchie des exceptions:

Intérêt de cette gestion ?

Enfin, le dernier programme:

Dans la suite du cours, on se limitera à l‟usage du try … catch.

Gestion de données par les flux d’entrée/sortie

Utilisation d’un flux :

Quelques sous classes et méthodes associées:

Pour chacune de ces classes, voici les méthodes de lecture et d‟écriture.

Chapitre 6 – Les filtres sur les flux d’entrée/sortie

Gestion de données par des filtres sur les flux d’entrée/sortie

 Cette classe permet de créer des interfaces utilisateurs, de traiter des

Exemple de la classe Container

Disposition des composants:

Exemple de la classe Window

Exemple de la classe Frame

Exemple de la classe Dialog :

Exemple de la classe MenuBar :

Exemple de la classe Menu :

Exemple de la classe Button :

Exemple de la classe TextField :

Exemple de la classe TextArea :

Exemple de la classe Label :

 Différences avec AWT

Chapitre 8 – La gestion d’événement

Exemples d’écouteurs d’événements :

Méthode 1 pour gérer les événements :

Fermeture d’une application

Méthode 2 pour gérer les événements :

Boites de dialogue de la classe swing

Chapitre 9 – La classe Graphics

Exemples de méthodes pour le dessin:

Copier et effacer des éléments :

Chapitre 10 – Les applets

Méthodes donnant un comportement à l’applet :

Options pour la balise applet :

 Les paramètres sont transmis à l‟applet au moment de son chargement.

Vous aimerez peut-être aussi