Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Bloc Note JAVA
Emmanuel ADAM
Institut des Sciences et Techniques de Valenciennes
Université de Valenciennes et du Hainaut-Cambrésis
Contenu
Ce document est en quelque sorte un résumé du cours de Java, à ceci près
qu’il ne contient pas encore d’informations sur les bases de données.
Les parties présentées sont :
•
•
•
•
•
•
•
•
•
•
•
•
une introduction à java et à ses outils,
la classe String,
les ensembles,
la notion d’héritage et de composition de classes,
les exceptions,
les entrées-sorties,
les processus,
la programmation Réseau,
les applets,
les classes graphiques de base (AWT),
quelques notions de swing,
un exemple complet de graphisme awt avec gestion de souris.
Il est à utiliser sous la forme d’un bloc note/aide-mémoire où j’ai jeté
quelques informations que je trouvais utiles mais ne peut remplacer le
cours, beaucoup plus fiable et mis à jour…
A ce propos, si vous trouvez des coquilles ou bugs, n’hésitez pas à m’en
faire part à : [email protected]
Bonne Lecture,
Emmanuel ADAM
Emmanuel ADAM
Bloc Note JAVA
Page 1
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Compilation
Langage
interprété
Java est un langage interprété. Une fois compilé en J-code, un programme
Java ne peut être lancé directement. Le programme ne peut s’exécuter
qu’au travers une « machine » virtuelle, Java Virtual Machine (JVM), qui
simule un processeur capable de comprendre le J-code.
C’est cet environnement virtuel qui est dépendant de l’environnement
d’exécution, et c’est ce qui fait la force de Java par rapport aux autres
langages : on peut programmer sans se soucier de la plate-forme d’exécu­
tion.
Un source java est un fichier texte unicode (pour la portabilité du source
java, il est important de n’utiliser que les 128 premiers caractères d’une
table ASCII, soit tous les caractères sauf les accents et caractères dépen­
dants des pays, ce qui correspond à l’encodage UTF-7). Ce source doit
porter l’extension .java.
Le J-code, le code java compilé, porte l’extension .class. C’est ce code
compilé qui est interprété soit par une JVM soit par un navigateur (brow­
ser).
JDK Java
Development
Kit
Le JDK est le Kit de Développement Java de SUN à l’origine du langage.
Il se compose de deux principaux répertoires : un répertoire de libraires
(lib), et un répertoire d’exécutables (bin) (remarque, sous les environne­
ments Windows, le répertoire jre (JavaRuntime Environment) est égale­
ment obligatoire).
Ce dernier contient les fichiers :
- javac : le compilateur java → Compile les fichiers sources java en
-
-
bytecodes (.class).
java : l’interpréteur Java → Exécute les bytecodes Java.
jre : Interpréteur runtime java → Interpréteur simplifié
appletviewer : l’afficheur d’applets → permet de tester les applets sans
passer par un navigateur
jdb : ‘debugueur’ Java → tout est dit !
javap : ‘désassembleur’ → désassemble les fichiers compilés (.class) et
affiche une interprétation du code.
javadoc : Générateur de documentation java → analyse les déclarations
et les commentaires d’un ensemble de source Java et produit un
ensemble de pages HTML décrivant les classes publiques, privées, les
constructeurs et les méthodes. Génère aussi la hiérarchie des classes et un
index de tous les membres.
javah : générateur de fichier d’entête C (.h) → permet d’attacher de lier
des progs C à des progs Java.
Ce sujet continue page suivante
Page 2
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Compilation,
JDK Java
Development
Kit (Suite)
-
Compiler et
exécuter
: compresseur de classes (Java Archive Tool) → permet de stocker
plusieurs bytecodes (.class) en un seul fichier d’extension .jar (sorte de
DLL).
javakey : outil pour signatures digitales → gère les clés, certificats et
sécurité des programmes.
native2ascii → converti un fichier natif en un fichier ASCII avec la
notation unicode.
rmic : convertisseur d’interface RMI Java → génère des objets à partir des
noms des classes compilées contenant les implémentations des objets
éloignés (remote objects)
rmiregistry : Registre d’objets Java éloignés Java (Remote Object
Registry) → créé et lance un registre d’objets éloignés sur un port spécifié
de l’hôte courant
serialver : Serial Version Command → renvoie le numéro de version de
la classe
jar
Voici comment compiler et exécuter un programme Java.
Attention : ce n’est pas le même schéma pour les applets !
Prenons le classique exemple du programme affichant « Salut tout le
monde ! ». Le source est le fichier texte suivant :
public class Bonjour
{
public static void main(String args[])
{
System.out.println("Salut tout le monde ! ");
}
}
Attention : le fichier doit porter le même nom que la classe, soit ici Bon­
jour.java .
Pour compiler le fichier, il suffit de lancer javac Bonjour.java , le
fichier bytecode Bonjour.class est alors créé. C’est ce fichier qui peut
être interprété par une machine virtuelle. Pour l’exécuter, il faut lancer
l’interpréteur, suivi du nom de la classe créée sans l’extension: java
Bonjour
Petite entrée
en matière
Le code précédent est fort semblable à un code C++,
On retrouve les mots clés class, public (la fonction main est accessible à
tous), static (toutes les instances de Bonjour utilise la même fonction
main), void et main.
String correspond à l’objet chaîne de caractères.
println est une méthode de la classe de l’objet out gérant toutes les
sorties et appartenant à la super-classe System.
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 3
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Compilation,
Documentati
on javadoc
javadoc est un outil très important car il génère automatiquement une
documentation des classes contenues dans un fichier source java.
javadoc se charge de créer l’arbre des classes, l’index des fonctions et
variables utilisées (publiques ou non selon les arguments passés à java­
doc).
Son utilisation première est simple : javadoc source.java
javadoc permet d’intégrer dans la documentation les commentaires pré­
sents dans le source.
Pour cela, ceux ci doivent précéder les éléments (classes, fonctions, va­
riables). Exemple :
/** classe représentant une file d’attente */
public class File
Compression
jar
La commande jar permet d’archiver plusieurs classes en un seul fichier
tout en les compressant, ce qui permet de gagner du temps lors de
l’exécution. Tout comme le code java compilé, le code java compilé et
compressé peut être exécuté sur toutes les plates-formes.
Le fichier archive porte l’extension .jar.
jar ne permet pas seulement d’archiver des classes, il est également ca­
pable d’archiver tout élément nécessaire à l’exécution d’un programme
(telle qu’un fichier son ou image par exemple).
La création d’une archive s’effectue par la commande :
jar cf fichier_archive fichiers
Exemple : jar cf resto.jar resto.class couverts.class images
son
Compresse les classes resto.class et couvert.class ainsi que tous les
fichiers se trouvant dans les répertoires images et son.
Pour lire le contenu d’une archive : jar tf fichier_archive
Pour extraire le contenu : jar xf fichier_archive (fichiers)
Pour exécuter une application archivée :
java –cp fichier_archive classe_principale
Pour exécuter une applet archivée :
L’appel à partir d’une page web se fera sous la forme :
<applet code="Classe Applet" archive= "nom_archive.jar"
width=300 height=200>
</applet>
Manifest :
Lorsque jar crée une archive, il crée également en entête de l’archive le
fichier MANIFEST.MF dans le répertoire META-INF. Ce fichier permet d’a­
jouter quelques informations au fichier archive (concernant la classe
principale et les signatures).
Ainsi, il est possible de définir la classe principale que devra utiliser
l’archive.
Si resto.class est la classe principale, il faut créer un fichier texte (par
exemple, monmanif) ne contenant que la ligne : Main-Class: resto
Il suffit ensuite d’inclure ce fichier dans l’archive en utilisant la commande
suivante : jar cmf monmanif resto.jar resto.class couverts.class
images son
L’exécution pourra alors se faire par la commande java –jar resto.jar
Page 4
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
Emmanuel ADAM
ISTV
Bloc Note JAVA
Page 5
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Les éléments de base en java
Les types
simples
Java dispose de 8 types simples, appelés primitives, pouvant être couvert
par des classes, appelés Wrappers.
Nom
boolean
char
byte
short
int
long
float
double
void
Taille
1 bit
16 bits
8 bits
16 bits
32 bits
64 bits
32 bits
64 bits
-
Minimum
false
Unicode 0
-128
-215
-231
-263
(+/-) 1.4 10-45
(+/-) 4.9 10-324
-
Classe
Boolean
Character
Byte
Short
Integer
Long
Float
Double
Void
Maximum
true
Unicode 216-1
127
215-1
231-1
263-1
(+/-) 3.4 1038
(+/-) 1.8 10308
-
Remarque : Pour passer d’une primitive à un objet, il faut faire appel au construcuteur de
l’objet : int i = 5;
Integer entier = new Integer(i);
Les objets
En Java, à part ces primitives, tout est objet.
Tout découle de la classe Object.
En fait, on a, pour les classes ci-dessus la hiérarchie suivante :
Object
Character
Byte
Void
Short
Number
Integer
Boolean
Long
Float
Double
De la classe object, on peut citer la méthode toString(), qui permet de
transformer tout objet (et donc nombres et booléens) en chaîne de carac­
tère.
De la classe Number, on peut citer les méthodes de conversion d’un objet
vers une primitive: byteValue() (retourne la valeur en byte), doubleVa­
lue(), floatValue(), intValue(), longValue(), shortValue().
Remarque : il est possible aussi d’utiliser le ‘casting’ C ou C++
(reel = (float) entier).
Tableaux
Il est possible de créer de tableaux d’objets, en utilisant la syntaxe
suivante :
int tab_entiers [] = new int[10]; // pour un tableaux de 10 entiers
int cube[][][] = new int [3][3][3];
double tab_reels[] = {1.2, 2.3, 3.4, 4.5};
length permet de connaître la taille d’un tableau.
System.out.println(tab_reels.length) affiche « 4 ».
Ce sujet continue page suivante
Page 6
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Les éléments de base en java,
Opérateur
Je dirais, cf. C++ ! Du moins pour la plus grande partie des programmes.
Pour tout nombre x, on peut écrire :
x++, x--, --x, ++x, x+=2, x-=2, x/=2, x*=2, x%=2 (x = x modulo 2)
Pour tout booléen x et y, on a :
non x !x ; x et y x & y ; x ou y x | y ; x ou exclusif y x ^ y
Pour tout entier x et y, on peut écrire x = x << y (décalage de y bit à
gauche) ; x = x >> y ; x = x <<< y ; x = x >>> y (dans ces deux derniers cas,
des 0 sont ajoutés pour combler les décalages).
Branchement
s
conditionnels
Comme en C++, on a :
if (test)
{
action_1_si_vrai
action_2_si_vrai
}
else
{
action_1_si_faux
action_2_si_faux
}
while (test) {actions ;}
;
;
do { actions ;} while (test) ;
for (int i=0 ; i<10 ; i++) {ac­
;
;
tions ;}
ceci avec des possibilités de :
- break (sorties) ,
Le est pouvant être de la forme : - continue (passe le reste de la
a ; !a ; x<y ; x==y ; x!=y ; ...
boucle, mais n’en sort pas),
- goto (un label est alors suivi de ‘:
‘ (label1 :) )
switch (expression)
{
case valeur_1 : actions ; break ;
case valeur_2 : actions ; break ;
case valeur_3 : actions ; break ;
default : actions ;
}
Emmanuel ADAM
Bloc Note JAVA
Page 7
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
La classe String
Présentation
La classe String correspond, comme d’habitude, aux chaînes de caractères.
Toutes les chaînes manipulées dans un code java sont des instances de
cette classe. Les chaînes sont constantes, leurs valeurs ne peuvent être
changées après leurs créations.
Comme de nombreuses classes java, la classe String dispose de plusieurs
constructeurs. La création de la chaîne str :
String str = "abc";
est équivalente à
char data[] = {'a', 'b', 'c'};
String str = new String(data);
La classe String comporte des méthodes d’accès aux caractères, de com­
paraisons, de recherche,
minuscules/majuscule..
d’extraction,
de
copie,
de
conversion
Le langage Java offre un support spécial à la concaténation ( + ), et à la
conversion d’objets en chaîne. La concaténation est issu de la classe
StringBuffer. Préférer cette classe StringBuffer pour les concaténations
et/ou modifications multiples !!! Gain de temps non négligeable (cf.
cours).
La conversion se fait de manière automatique en faisant appel à la mé­
thode toString() héritée de la classe Object. Il est possible de surchar­
ger cette méthode dans les nouvelles classes créées.
Quelques
méthodes de
String
char charAt(int index) → retourne le caractère de la position index
int compareTo(String anotherString) → compare la chaîne à une autre, en gérant les majus­
cules-minuscules. Retourne 0 en cas d’égalité, un entier négatif si la chaîne est inférieure à
l’autre, et positif si la chaîne est supérieure à l’autre chaîne.
int compareToIgnoreCase(String str) → idem que la précédente, mais ignore la case.
String concat(String str) → ajoute la chaîne str à la fin de la chaîne.
boolean endsWith(String suffix) → teste si la chaine se termine par le suffixe.
boolean equals(Object anObject) → nécessaire pour comparer deux chaînes, traite la case.
boolean equalsIgnoreCase(String anotherString) → idem, mais ignore la case.
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) → copie les caractères de la
chaîne dans un tableau de caractères.
int indexOf(int ch) → retourne l’index de la première occurrence du caractère.
On trouve aussi int indexOf(int ch, int fromIndex) ; int indexOf(String str)
indexOf(String str, int fromIndex)
Ainsi que int lastIndexOf(int ch) ; int lastIndexOf(int ch,
lastIndexOf(String str) ; int lastIndexOf(String str, int fromIndex) ;.
int
et
fromIndex) ;
int
int
int length() → retourne la longueur
String replace(char oldChar, char newChar) → retourne une nouvelle chaîne après le rem­
placement de toutes les occurences du caractère.
boolean startsWith(String prefix) → teste si la chaîne commence par le prefixe.
String substring(int beginIndex, int endIndex) → extrait une sous-chaîne.
String toLowerCase() ; String toUpperCase() → change la case.
Page 8
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
String trim() → efface les espaces avant et après.
Emmanuel ADAM
Bloc Note JAVA
Page 9
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Listes et ensembles
Les
collections
Les tableaux de Java peuvent contenir n’importe quel objet, c’est une des
conséquences de sa structure totalement objet (tout découle de la classe
Object).
Rappel, on définit un tableau comme ceci : hamster tab[] = new
hamster[5];
Ces tableaux sont fixes, une fois créés il est impossible de modifier leurs
tailles. Pour répondre à ce problème, il existe des classes Java correspon­
dant à des listes ou collection.
La classe Vector est la plus utilisée. On définit un vecteur de la façon
suivante : Vector liste_animaux = new Vector() ;
Remarque : on ne précise pas de quoi est constitué le vecteur, il peut
donc contenir des objets de types différents.
La méthode addElement(objet) permet d’ajouter un objet en queue, les
méthodes element_at(index) et get(index) ont le même comportement
et permettent de récupérer l’objet positionné à l’index donné.
La classe Stack, hérite directement de la classe Vector et ajoute entre
autres les méthodes push(objet) : ajoute un objet en tête ; pop() : re­
tire le premier objet ; peek() : renvoie une référence au premier objet
sans le retirer ; empty() : teste si la pile est vide.
Une pile peut aussi contenir des objets de différents types.
La classe Hashtable peut être vue comme un dictionnaire composé de
deux vecteurs : un vecteur pour la clé et un vecteur pour l’objet.
Une table de clés possède les méthodes put(clé, objet) ; get(clé) ;
containskey(clé) ; containsvalue(objet) et isEmpty() entre autres.
La classe Enumeration ne contient que deux méthodes : nextElement() qui
extrait et retourne un élément de la liste (comme pop) et hasMoreEle­
ments() indiquant la présence d’au moins un élément.
elle est utilisée notamment pour la lecture des éléments d’un vecteur :
for (Enumeration e = vecteur.elements(); e.hasMoreElements() ; )
System.out.println(e.nextElement()) ;
Remarque : elements est la méthode qui retourne une énumération à partir du
vecteur.
Cependant l’exécution de cette boucle est beaucoup plus lente que la lec­
ture «classique » des éléments du vecteur suivante :
int nbElt = vecteur.size() ;
for (int i=0; i < nbElt; i++)
System.out.println(vecteur.get(i));
Pour un parcourt encore plus rapide, préférez l’utilisation de ArrayList à
celle de Vector. En effet, ces derniers sont synchronisés par défaut (voir la
gestion de tâches) alors que les ArrayList ne le sont pas…
Les ensembles ne peuvent contenir qu’un exemplaire d’un objet. La classe
Set dispose, entre autres, des méthodes add(objet) qui n’ajoute l’objet
que s’il n’est pas déjà présent; contains(objet) ; remove(objet) ;
isEmpty().
Page 10
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
Emmanuel ADAM
ISTV
Bloc Note JAVA
Page 11
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Héritage et composition de classes
Héritage
La notion d’objet implique la notion d’héritage et de composition de
classes.
En Java, la syntaxe la classe désirant hériter des attributs et méthodes de
la classe principale doit utiliser le mot clé extends :
class Animal { …. }
class Hamster extends Animal { … }
class Chasseur { … }
De quoi hérite le hamster ? De tout ce qui n’est pas privé (private).
En effet, les attributs ou méthodes d’une classe marquées comme private
sont limités à cette classe.
Les attributs ou méthodes d’une classe marquées comme private pro­
tected sont accessible également aux sous classes (donc au Hamster, mais
non au Chasseur).
Les attributs ou méthodes d’une classe marquées comme protected sont
accessibles aux sous-classes, mais également aux classes voisines (soit ici,
le chasseur de Hamster).
Les attributs ou méthodes d’une classe marquées comme public sont
accessibles à tous, même aux classes d’un autre paquetage.
par défaut, les variables et méthodes sont de type protected.
Autres mots
clés
Nous avons donc les mots clés public, protected, private, mais on peut
trouver aussi les mots clés final, static, abstract et synchronized.
final peut être utilisé pour signifier une constante, une méthode qui ne
peut être remplacée dans une sous-classe et une classe qui ne doit pas être
héritée.
associé à une variable signifie que toutes les instances d’une
classe utilisent la même variable (par exemple pi pour la classe cercle).
Une variable statique( dite variable de classe) peut aussi être utilisée en
tant que compteur, chaque instance. Une méthode statique ne peut agir
que sur les variables et méthodes de classe.
static
abstract ne s’applique qu’aux classes et procédures. Une classe abstraite
ne peut être instanciée, seules ses classes dérivées le pourront. L’abstrac­
tion permet de définir un moule général auquel se rapporteront les classes
dérivées.
synchronized sert à gérer l’accès concurrent. En fait protège un code en
le plaçant dans le moniteur (la partie gérant les accès mémoire des pro­
grammes Java).
Remarque : en Java, on trouve aussi des interfaces. ce sont en quelques sorte des
classes totalement abstraites, dont aucune partie n’est implémentée. Les classes se
réclamant d’une interface donnée doivent utiliser le mot clé implements.
Exemple :
class Animal implements etre_vivant
Ce sujet continue page suivante
Page 12
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Héritage et composition de classes,
Constructeur
s
Les constructeurs sans arguments sont automatiquement lancés. (La créa­
tion d’un Hamster sans argument entraîne la construction d’un Animal sans
argument).
Pour les constructeurs avec argument, il faut faire appel à la classe supé­
rieure (super) :
class Animal
{
String nom;
Animal() {nom = ".";}
Animal(String nvnom) {nom = nvnom;}
void print() {System.out.println(nom);}
}
class Hamster extends Animal
{
String couleur;
Hamster(){} // appelle automatiquement Animal()
Hamster(String nvnom) {super(nvnom); } // correspond à Animal(String nvnom)
Hamster(String nvnom, String nvcouleur) {super(nvnom); couleur = nvcouleur;}
void print() {System.out.println(nom + " "+ couleur);}
}
Trouver la
classe
Supposons que l’on ait :
class Lapin extends Animal
{
int taille_oreille;
Lapin(){}
Lapin(String nvnom) {super(nvnom); }
Lapin(String nvnom, int nvtaille)
{super(nvnom); taille_oreille = nvtaille;}
void print() {System.out.println(nom + "taille
taille_oreille);}
}
oreille
:
"
+
Il peut arriver que l’on ait à se demander à quelle classe appartient un ob­
jet. En effet, on peut gérer de manière génériques des animaux dans une
liste, puis vouloir accéder à une caractéristique particulière d’un animal.
Pour cela, la méthode instanceof permet de retrouver la classe d’origine.
Exemple :
for(int i=0; i<vecteur.size(); i++)
{
Object objet = vecteur.get(i);
if (objet instanceof Hamster) ((Hamster)objet).print();
if (objet instanceof Lapin) ((Lapin)objet).print();
}
Combiner les
classes
Emmanuel ADAM
Comme tout est objet, tous les attributs des classes sont objets. Une classe
peut donc sans problème avoir une variable de type Animal ou Hamster ou
autre.
Bloc Note JAVA
Page 13
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Exceptions
Le pourquoi
La gestion des exceptions est très importante, voire primordiale, dans tous
systèmes informatiques. Elle confère un aspect beaucoup plus profession­
nel aux applications.
En effet, l’utilisateur risque d’être fortement perturbé voire lassé d’appli­
cations qui plante sans information précise, comme celles du style :
Heureusement, la plupart des langages actuels permettent de les gérer.
Le comment
Pour récupérer, ou attraper, une exception, il faut utiliser la syntaxe
suivante :
try {…. //endroit où pourrait apparaître une exception }
catch (type_exception_1 e1)
{ …. // traitement de l’exception de type 1 }
catch (type_exception_2 e2)
{ …. // traitement de l’exception de type 2 }
finally
{ …. // dans tous les cas, passer par ici }
Pour lancer, lever, une exception, il faut utiliser la commande throw :
throw new Exception("ceci est une exception") ;
Il est possible de relancer une exception suite à son traitement, il suffit
d’utiliser la commande throw dans le bloc de traitement.
De nombreuses sous classes découlent de la classe Exception telles que : ,
IOException et ArithmeticException.
Et il est possible de créer ses propres exceptions, héritants de la classe Ex­
ception, pour les lever et les traiter dans un programme Java.
Méthodes
d’Exception
La classe Exception possède peu de méthode (juste deux constructeurs Ex­
ception() et Exception (String msg) ).
Mais hérite de méthodes de la classe Throwable, dont :
getMessage qui permet de récupérer le message de l’exception s’il existe.
toString, qui retourne la classe et le message sous forme de chaîne.
printStackTrace, qui fait appel à toString, mais qui en plus indique l’en­
droit du programme où a été levée l’exception.
Si on souhaite définir une méthode porteuse d’exceptions, il faut ajouter
throws Exception suite à sa déclaration.
Page 14
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
Emmanuel ADAM
ISTV
Bloc Note JAVA
Page 15
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Les entrées/sorties
Le package
java.io
Le package java.io propose différentes classes et interfaces (classes tota­
lement abstraites) permettant les différentes entrées/sorties entre un
programme java et le système.
Les classes principales sont les classes :
InputStream dont dérivent les classes BufferedInputStream, ByteAr­
rayInputStream, DataInputStream, FilterInputStream et Push­
backInputStream.
OutputStream dont dérivent les classes BufferedOutputStream, By­
teArrayOutputStream, DataOutputStream et FilterOutputStream.
FileInputStream, FileOutputStream et File.
Les classes DataInputStream et DataOutputStream proposent des mé­
thodes pour gérer les flux de données de type primitifs Java (int, ...).
Lire une saisie Cela peut paraître simple, il existe en effet la fonction println(String)
clavier
qui permet l’affichage d’une chaîne. Mais il n’existe pas de fonction
readln définie en Java !
Depuis le jdk 1.3, il est possible de passer par une classe définie spéciale­
ment pour la gestion de flux de caractères : InputStreamReader et Buffe­
redReader.
Ce qui donne :
InputStreamReader inputReader = new InputStreamReader(System.in) ;
BufferedReader in = new BufferedReader(inputReader) ;
String chaine = in.readLine() ;
Ce sujet continue page suivante
Page 16
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Les entrées/sorties,
La classe File
La classe File permet d’accéder aux caractéristiques des fichiers et réper­
toires (ceux-ci sont considérés comme des fichiers particuliers).
Il existe trois constructeurs :
File(File dir, String name) ; File(String path, String name) et
File(String path).
Les différentes méthodes sont :
canRead() ;
canWrite() ;
delete() ;
equals(Object
obj)
exists() ;
getAbsolutePath() ;
getCanonicalPath()
getName() ;
getParent() ;
getPath() ;
hashCode()
isAbsolute() ;
isDirectory() ;
isFile() ;
lastModified()
length() ; list(FilenameFilter filter) ; list() ; mkdir()
mkdirs() ; renameTo(File dest) ; toString().
(Les méthodes list retournent un tableau de chaînes)
Lecture d’un
fichier texte
;
;
;
;
;
Pour lire un fichier texte, il est possible d’utiliser les classes DataIn­
putStream et BufferedReader en leur passant en paramètre un flux basé
sur le fichier à l’aide de la classe FileInputStream.
Ce qui donne :
BufferedReader
d
=
InputStreamReader(FileInputStream("Io_1.java"))) ;
new
BufferedReader(new
pour créer un flux de caractères à partir du fichier "Io_1.java".
Copie d’un
fichier
La copie d’un fichier est très simple, il suffit d’utiliser les classes DataIn­
putStream et DataOutputStream :
fichier = new FileInputStream("Io_1.java");
DataInputStream data_in = new DataInputStream(fichier);
FileOutputStream copie = new FileOutputStream("Io_1.copie");
DataOutputStream data_out = new DataOutputStream(copie);
while (data_in.available() > 0)
data_out.write(data_in.read());
data_in.close();
data_out.close();
Cet exemple copie un fichier byte par byte, ce qui est assez long. Il est
aussi possible de copier le fichier par paquet de bytes.
Emmanuel ADAM
Bloc Note JAVA
Page 17
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Le stockage d’objets
La
Serialization
La Sérialisation d’objets est apparue avec le Java 1.1.
Elle permet de prendre tout objet implémentant l’interface serializable et
de le transformer en une série de bits qui peuvent être plus tard restaurer
sous la forme de l’objet original. Ce qui est particulièrement intéressant
pour le partage d’objets au travers d’un réseau.
En effet, la sérialisation d’objets a été ajoutée pour supporter deux pro­
priété importantes de Java : le RMI (remote method invocation) permet­
tant à des objets distribués de communiquer, et les Java Beans (petits
noyaux (fèves) de programme).
La sérialisation d’un objet n’est possible que s’il implémente l’interface Se­
rializable.
L’envoi d’un objet vers un flux de sortie est réalisé par ma méthode wri­
teObject() de la classe ObjectOutputStream.
La lecture d’un objet à partir d‘un flux d’entrée est réalisée par ma mé­
thode readObject() de la classe ObjectInputStream.
Attention : on récupère alors un objet général ( Object), il faut alors le
downcaster, le convertir, pour récupérer le bon objet.
La sérialisation ne sauve pas seulement une image de l’objet, mais sauve
aussi les objets qu’il contient, les objets contenus dans ces objets, …
Un exemple
Page 18
import java.io.*;
class Fromage implements Serializable
{
String type;
int poids;
int nb_trous;
Fromage(){};
Fromage(String nvtype, int nvpoids, int nvnb_trous)
{ type = nvtype; poids = nvpoids; nb_trous = nvnb_trous;}
public String toString()
{ String s = type + "poids = " + poids + "nb_trous = " + nb_trous;
return s;
}
}
class Hamster_1
{
static Fromage morceaux[] = new Fromage[5];
public static void main(String[] args)
{
for(int i=0; i<morceaux.length; i++)
morceaux[i] = new Fromage("a", (i+1)*3, i*5);
try
{
FileOutputStream fic_out = new FileOutputStream("fromage.out");
ObjectOutputStream out = new ObjectOutputStream( fic_out );
out.writeObject("Stockage d Hamster ");
for(int i=0; i<morceaux.length; i++) out.writeObject(morceaux[i]);
out.close();
FileInputStream fic_in = new FileInputStream("fromage.out");
ObjectInputStream in = new ObjectInputStream(fic_in);
String s = (String)in.readObject();
for(int i=0; i<5; i++)
{ Fromage f = (Fromage)in.readObject();
System.out.println(f);
}
in.close();
System.out.println(s);
}
catch(Exception e) { e.printStackTrace(); }
}
}
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Gestion de tâches
La classe
Thread
Pour créer une tâche, il suffit de faire hériter sa classe de la classe Thread.
La principale méthode de Thread est run() qui doit être surchargée. C’est
la méthode qui sera exécutée simultanément par les autres tâches du pro­
gramme.
La méthode yield() oblige la tâche à se reposer, pour laisser aux tâches la
possibilité de s’exécuter
Exemple
class une_tache extends Thread
{
une_tache(String nom) { super(nom); } // appel au constructeur de Thread
public void run()
{
while (true)
{
System.out.println("Mon nom est : " + getName());
Thread.yield();
// petite pause
}
}
}
class Exemple_tache_1
{
public static void main(String args[])
{
une_tache tache1 = new une_tache("tache 1");
une_tache tache2 = new une_tache("tache 2");
tache1.start();
tache2.start();
while (true)
{
System.out.println("Je suis la tâche principale");
Thread.yield();
}
}
}
L’interface
Runnable
La classe Thread implémente l’interface Runnable. Il est donc possible de
créer des tâches ayant des comportements particuliers à la terminaison
(méthode stop() ), ou à l’initialisation (méthode init() ).
Eviter les
collisions !
La programmation multitâche implique le partage de ressources (mémoire,
objets). Dans certains cas, ceci peut être problématique, et il peut être
bénéfique de protéger une fonction, d’empêcher son lancement par une
autre tâche tant qu’elle n’est pas totalement exécutée.
Pour cela, Java dispose du mot clé synchronized qui assure l’exclusion
mutuelle d’une section critique en informant le moniteur (gestionnaire de
mémoire).
exemple: public synchronised void compte() {…} empèche toute
instance de la classe de lancer compte tant qu’elle ne s’est pas terminée.
Il est possible de protéger aussi des portions de codes liées à un objet. En
Effet, à chaque objet correspond un moniteur, si on veut protéger une por­
tion de code utilisant un objet, il suffit d’en informer son moniteur :
...
synchronized (compteur) {compteur.add() ; compteur.mult() ; ...}
...
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 19
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Gestion de tâches,
Synchroniser
les tâches
Le mot clé synchronized permet de protéger une ressource lorsque dif­
férents processus tentent de l’utiliser.
Voyons maintenant comment synchroniser ces processus (Thread).
La méthode notify() réveille un processus mis en attente par le moniteur
de l’objet. S’il y a plusieurs processus, le choix de l’un d’entre eux dépend
de la plate-forme.
La méthode wait() impose au processus courant d’attendre tant qu’un
autre processus n’a pas invoqué la méthode notify() ou notifyAll()
pour cet objet. Le processus courant doit posséder le moniteur de l’objet.
Il libère alors ce moniteur et attend la prochaine opportunité de récupérer
le moniteur pour recommencer sa tâche.
La méthode setPriority(int niveau) change le niveau de priorité du
processus, il est possible d’utiliser les constantes MIN_PRIORITY,
NORM_PRIORITY et MAX_PRIORITY.
Exemple : le
producteur
et 2
consommate
urs
class Tab_objets
{
private Object tampon[];
private int taille;
private int produits, consommes, nb_objets_courants;
public Tab_objets (int taille)
{
tampon = new Object[taille];
this.taille = taille;
produits = 0;
consommes = 0;
}
nb_objets_courants = 0;
public synchronized void depose(Object obj)
{
while (nb_objets_courants == taille)
{
try
{ wait(); }
catch (InterruptedException e) {}
}
tampon[produits] = obj;
nb_objets_courants++;
produits = (produits + 1) % taille;
notify(); // réveille un processus en attente de non vide
}
}
public synchronized Object preleve()
{
while (nb_objets_courants == 0)
{
try
{ wait();
}
catch (InterruptedException e) {}
}
Object obj = tampon[consommes];
tampon[consommes] = null;
nb_objets_courants--;
consommes = (consommes + 1) % taille;
notify(); // reveille un processus en attente de non plein
return obj;
}
Ce sujet continue page suivante
Page 20
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Gestion de tâches,
Suite du
producteur
et 2
consommate
urs
class producteur extends Thread
{
private Tab_objets tab;
private int val = 0;
String nom;
public producteur(String nom, Tab_objets tab)
{ this.nom = nom;
this.tab = tab;
}
public void run()
{
while (true)
{
System.out.println(nom + " : je depose l objet "+val);
tab.depose(new Integer(val++));
try { Thread.sleep((int)(Math.random()*100));} // 100 ms max
catch (InterruptedException e) {}
}
}
}
class consommateur extends Thread
{
private Tab_objets tab;
String nom;
public consommateur(String nom, Tab_objets tab)
{ this.nom = nom;
this.tab = tab;
}
public void run()
{
while (true)
{
String nom_obj = (Integer)tab.preleve()).toString();
System.out.println(nom + ": je preleve l objet " + nom_obj) ;
try
{ Thread.sleep((int)(Math.random()*200));
} // max 200 ms
catch (InterruptedException e) {}
}
}
}
class ProductConsom_1
{
public static void main(String args[])
{
Tab_objets tab = new Tab_objets(5);
producteur prod = new producteur("product", tab);
consommateur cons1 = new consommateur("consom 1", tab);
consommateur cons2 = new consommateur("consom 2", tab);
}
Emmanuel ADAM
}
prod.start();
cons1.start();
cons2.start();
try {
Thread.sleep(10000);
}
catch (InterruptedException e) {}
cons2.stop(); cons1.stop(); prod.stop();
Bloc Note JAVA
Page 21
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Programmation réseau
La classe
Socket
Les classes de java.net.* permettent très facilement de se connecter à
une machine afin d’y établir des flux d’entrées/sorties.
En java, la socket est équivalente à un gestionnaire d’entrée/sortie entre
deux machines. La classe Socket permet de définir une socket et la connec­
ter sur le port d’un serveur, soit par passage de son adresse IP, soit par
passage de son nom (par Socket(InetAddress address, int port)ou
Socket(String host, int port) ).
La fonction getInputStream() permet de récupérer un objet de type In­
putStream, donc le flux d’entrée pour la socket.
De même, la fonction getOutputStream() permet de récupérer un objet
de type OutputStream, donc le flux de sortie pour la socket.
La classe
ServerSocket
Pour établir une communication par socket entre des machines, il faut que
l’une d’entre elles soit définie en tant que serveur.
La classe ServerSocket permet de créer une socket serveur guettant des
demandes d’autres sockets du réseau. Cette socket peut alors traiter les
demandes et envoyer des réponses.
Pour créer une socket serveur, il suffit de passer en paramètre le n° du
port que l’on souhaite ouvrir.
La méthode accept() permet de guetter et de capturer une demande de
connexion.
Une socket serveur permet aussi la gestion d’entrées/ sorties par les
mêmes méthodes que la classe Socket.
Exemple de
réception
Par exemple, la déclaration d’une socket server attendant une coonnection
et récupérant la chaîne de caractères envoyée donne :
ServerSocket s = new ServerSocket(8888);
System.out.println("Socket lancee : " + s);
try
{
Socket socket = s.accept();
// Attendre une connection
try
{
System.out.println( "Connection acceptee: "+ socket);
InputStream socket_in = new InputStream( socket.getInputStream());
DataInputStreaam in = new DataInputStreaam (socket.getInputStream());
String str = in.readLine();
}
}
La gestion des exceptions d’entrée/sortie doit bien sûr soit se faire direc­
tement, soit être laissée à la fonction appelante (en ce cas, il faudra défi­
nir la fonction contenant le code ci dessus en conséquence).
Ce sujet continue page suivante
Page 22
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Programmation réseau,
Un exemple :
le serveur
Voici un exemple classique de programmation réseau : le client serveur.
Un serveur est lancé sur une machine et attend la connexion d’un client.
Puis, il récupère es lignes envoyées par le client, les affiche et les lui ren­
voie.
import java.io.*;
import java.net.*;
public class Serveur_1
{
// Choose a port outside of the range 1-1024:
public static final int PORT = 8080;
public static void main(String[] args) throws IOException
{
ServerSocket s = new ServerSocket(PORT);
System.out.println("Socket lancee : " + s);
try
{
// Attendre une connection
Socket socket = s.accept();
try
{
System.out.println( "Connection acceptee: "+ socket);
InputStreamReader socket_in = new InputStreamReader( socket.getIn­
putStream());
BufferedReader in = new BufferedReader( socket_in );
// Output is automatically flushed by PrintWriter:
OutputStreamWriter socket_out =
new OutputStreamWriter( so­
cket.getOutputStream());
PrintWriter
out
=
new
PrintWriter(
new
BufferedWriter(socket_out),true);
while (true)
{
String str = in.readLine();
if (str.equals("END")) break;
System.out.println("Recu : " + str);
out.println(str);
}
// Always close the two sockets...
}
finally
{
System.out.println("fermeture...");
socket.close();
}
}
finally { s.close(); }
}
}
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 23
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Programmation réseau,
Un exemple :
le client
import java.net.*;
import java.io.*;
public class Client_1
{
public static void main(String[] args) throws IOException
{
// récupère l'adresse internet du host
// null permet de tester les applis sur une machine unique
InetAddress addr = InetAddress.getByName(null);
System.out.println("addr = " + addr);
Socket socket = new Socket(addr, Serveur_1.PORT);
try
{
System.out.println("socket = " + socket);
InputStreamReader socket_in = new InputStreamReader( socket.getIn­
putStream());
BufferedReader in = new BufferedReader(socket_in);
OutputStreamWriter socket_out = new OutputStreamWriter( socket.ge­
tOutputStream());
PrintWriter out = new PrintWriter( new BufferedWriter( socket_out )
,true);
for(int i = 0; i < 10; i ++)
{
out.println("envoie de la ligne " + i);
String str = in.readLine();
System.out.println(str);
}
out.println("END");
}
finally
{
System.out.println("fermeture...");
socket.close();
}
}
}
Page 24
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
Les applets
Programmati
on sur
Internet
La programmation d’applets est le second type de programmation Java.
C’est aussi la partie la plus visible et celle qui a le plus fait connaître la
langage Java.
Les applets Java permettent d’intégrer des programmes dans les pages
Web. Elles utilisent la librairie graphique AWT (Abstract Windowing
Toolkit). Cette librairie permet de générer du graphisme portable sur tout
environnement.
La classe
Applet
Une applet est un petit programme destiné à être appelé par une page
Web.
Les méthodes les plus importantes des applets sont les méthodes :
init(), que le navigateur appelle après chaque chargement de l’applet.,
start(), lancée après l’initialisation,
stop(), arrête l’applet lorsqu’elle n’est plus visible,
destroy(), appelé à l’arrêt du navigateur, ou au rechargement de l’ap­
plet,
paint(Graphics g) est appelé chaque fois que l’applet est réaffichée.
Un exemple
d’applet
Voici un exemple d’applet affichant un simple message.
import java.awt.*;
import java.applet.*;
public class Applet1 extends Applet
{
Font font;
public void init()
{
font = new Font("TimesRoman", Font.PLAIN,20);
}
public void paint(Graphics g)
{
g.setFont(font);
g.setColor(Color.red);
g.drawString("Salut tout le monde!", 0, font.getSize());
g.draw3DRect(0, 0, 180, 30, true);
}
}
Voici maintenant un code html lançant cette applet :
<HTML>
<HEAD>
<TITLE>Exemple d'applet</TITLE>
<BODY>
<H1>Un exemple dapplet</H1>
<applet code="Applet1.class" width=200 height=50>
desole ... ce navigateur ne supporte pas les applets ...
</applet>
</BODY>
</HEAD>
</HTML>
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 25
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Les applets,
Passage de
paramètres
Il est encore possible dans une applet de passer des données en paramètres
(sur la ligne d’appel dans la page web).
La méthode getParameterInfo("param") retourne une tableau n × 3 de
chaînes de caractères associant le nom du paramètre à sont type et à sa
valeur.
Exemple :
static final String[][] paramInfo = {{"msg","texte","message"},{"nb","entier","15"}}
Ainsi, la commande msg = getParameter("msg"); permet de récupérer la
valeur du paramètre msg passé en paramètre dans la page web.
Pour passer les paramètres, il faut écrire appeler l’applet dans la page web
comme ceci :
<Applet code="Applet1.class" width=300 height=200>
<param name=msg value="voici le message">
</Applet>
Applets
permanentes
Toutes les applets utilisent la même machine virtuelle. Si l’on souhaite
créer une applet à activité permanente (défilement de texte, d’images,
...), il faut la créer en tant que processus afin de ne pas bloquer les autres
applets.
Pour cela, il faut que l’applet implémente l’interface Runnable (similaire à
Thread, mais qui permet de réécrire la fonction stop()).
Tester les
applets
Utilisez l’appletviewer pour tester vos applets. Les navigateurs chargent
généralement l’applet en mémoire qu’une fois par session. Même après
modification et recompilation, le navigateur risque de ne pas prendre en
compte les changements.
Archiver les
classes
En général, une applet ne se suffit pas et utilise une autre classe située
dans le même répertoire. Elle charge donc cette classe en mémoire en cas
de besoin, ce qui cause un ralentissement du système du à l’attente du
chargement.
Pour éviter les multiples chargement et pour mieux structurer les classes,
java dispose maintenant d’un outil d’archive : jar.
Supposons que l’Applet1 ait besoin de la classe cube. Pour archiver et com­
presser ces classes dans une archive, il faut taper la commande :
jar cvf nom_archive Applet1.class cube.class
L’appel à partir d’une page web se fera sous la forme :
<Applet code="Applet1.class" archive= "nom_archive.jar"
width=300 height=200>
<param name=msg value="voici le message">
</Applet>
Page 26
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
Emmanuel ADAM
ISTV
Bloc Note JAVA
Page 27
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
AWT : pour l’Interface utilisateur
Abstract
Windowing
Toolkit
Le paquetage AWT (java.awt.*) contient les classes nécessaires à la
conception d’interfaces utilisateurs. Les interfaces crées grâce à AWT sont
relativement pauvres, mais ont l’avantage d’être pauvres partout ! ! !
En fait, que ce soit sous Windows, X-Windows ou Mac, les objets de la lib­
rairie AWT se comporte de la même manière.
Classes
principales
Voici quelques classes généralement utilisées :
Font, pour définir les polices de caractère utilisées,
Button, TextField, TextArea, Label, Checkbox,
Choice, List et ActionListener.
CheckboxGroup,
Fonctions
principales
Les fonctions de la classe Graphics permettent de dessiner simplement
différentes figures sur la surface de l’applet ou de la Frame:
clearRect, draw3Drect, drawArc, drawImage, drawLine, drawOval,
drawPolygon, drawPolyline, drawRect, drawString, fill3Drect,
fillArc, fillOval, fillPolygon, fillRect, getColor, getFont, setCo­
lor, setFont.
Le bouton
Voyons tout d’abord l’utilisation de la classe Button, et la gestion des
événements sur les boutons :
import java.awt.*;
import java.awt.event.*;
public class TestBoutons extends Frame
{
Button b1 = new Button("Bouton n°1");
Button b2 = new Button("Bouton n°2");
public TestBoutons()
{
setLayout(new FlowLayout());
b1.addActionListener(new ActionB1());
b2.addActionListener(new ActionB2());
add(b1);
add(b2);
pack() ;
}
class ActionB1 implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
System.out.println ("Button 1"); }
}
class ActionB2 implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
System.out.println("Button 2"); }
}
}
Ce sujet continue page suivante
Page 28
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
AWT : pour l’Interface utilisateur,
Evénements
Dans l’exemple précédent, nous utilisons l’interface ActionListener pour
capturer l‘événement sur les boutons.
En fait cette interface ne définit que la méthode
void actionPerformed(ActionEvent e) qui est à implémenter.
On trouve aussi l’interface MouseListener qui définit les méthodes
void mouseClicked(MouseEvent e) → clic sur l’objet
void mouseEntered(MouseEvent e) → passage sur l’objet
void mouseExited(MouseEvent e) → sortie de l’objet
void mousePressed(MouseEvent e) → pression sur l’objet
void mouseReleased(MouseEvent e) → relâche de l’objet
Ainsi que l’interface WindowListener qui définit les méthodes suivantes :
void windowActivated(WindowEvent e) → la fenêtre devient active
void windowClosed(WindowEvent e) → fermeture par un bouton ou
autre
void windowClosing(WindowEvent e) → fermeture par menu système
void windowDeactivated(WindowEvent e) → la fenêtre n’est plus active
void windowDeiconified(WindowEvent e) → de minimisée à un autre
état
void windowIconified(WindowEvent e) → minimisation
void windowOpened(WindowEvent e) → première ouverture
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 29
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
AWT : pour l’Interface utilisateur,
Label
Un label est un élément simple, il affiche simplement un texte qu’il est
possible de modifier par la méthode setText(String) .
Label l = new Label("une interface") ;
Choix dans
une liste
L’objet Choice permet de choisir un élément dans une liste.
On y ajoute des éléments par la méthode addItem(String)
La méthode String getSelectedItem() retourne la chaîne sélectionnée.
ItemListener est l’interface permettant de gérer les événements sur cet
objet et contient la méthode itemStateChanged(ItemEvent e) déclen­
chée lors de sélection/déselection d’un item.
Liste
L’objet List affiche une liste de choix multiples ou non dans un cadre.
On y ajoute des éléments par la méthode addItem(String)
La méthode String getSelectedItem() retourne la chaîne sélectionnée.
La méthode String[] getSelectedItems() retourne les chaînes sélec­
tionnées.
ItemListener est l’interface permettant de gérer les événements sur cet
objet et contient la méthode itemStateChanged(ItemEvent e) déclen­
chée lors de sélection/désélection d’un item.
Champ de
texte
L’objet TextField permet à l’utilisateur d’entrer une ligne de texte.
Héritant de TextComponent, TextField dispose de GetText() pour récu­
pérer le texte transmis.
La commande setEchoChar(char) permet d’entrer un texte de façon
masquée (pour un mot de passe, par exemple).
L’interface TextListener permet de gérer les événements par la méthode
textValueChanged(TextEvent e)
Zone de
texte
L’objet TextArea permet à l’utilisateur d’entrer des lignes de texte.
Héritant de TextComponent, TextField dispose de GetText() pour récu­
pérer le texte transmis.
De même, l’interface TextListener permet de gérer les événements par
la méthode textValueChanged(TextEvent e)
Ce sujet continue page suivante
Page 30
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
AWT : pour l’Interface utilisateur,
Cases à
cocher
L’objet Checkbox est utilisé à la fois pour les cases à cocher, comme pour
les boutons radio.
Les cases à cocher permettent de choisir aucune, une ou toute une série de
propositions.
La méthode getState() permet de savoir si la case est cochée ou non.
ItemListener est l’interface permettant de gérer les événements sur cet
objet et contient la méthode itemStateChanged(ItemEvent e) déclen­
chée lors d’un cochage/décochage.
Boutons
Radio
Les boutons radio ne permettent qu’un choix dans un ensemble d’options.
Pour les définir, il faut également utiliser l’objet Checkbox. Et, pour gérer
l’unicité du choix, il faut placer les Checkbox dans un groupe défini par la
classe CheckboxGroup.
L’appartenance d’une Checkbox à un groupe est indiqué dans son construc­
teur.
La méthode Checkbox getSelectedCheckbox() retourne la checkbox
sélectionnée.
Zone de
dessin
Il est possible de dessiner directement sur une applet ou une frame, mais il
peut être utile de définir un cadre dans lequel s’effectueront les dessins.
Toute classe étendant Canvas contient aussi la méthode paint(Graphics
g) qui permet d’accéder aux méthodes de la classe Graphics (drawLine,
drawArc par exemple).
Un objet d’une classe étendant la classe Canvas est un composant standard
qui peut être placé sur une applet ou une frame ou JFrame (voir plus loin).
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 31
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
AWT : pour l’Interface utilisateur,
Mise en page
La classe Applet dérive de la classe Panel qui dérive de la classe Contai­
ner.
Cette classe contient la méthode SetLayout(LayoutManager) qui permet
de choisir entre différents gestionnaires d’interface.
Il suffit de l’appeler dans le init() de l’Applet.
Il existe trois principaux gestionnaires : FlowLayout, BorderLayout et
GridLayout.
L’utilisation d’un gestionnaire s’effectue selon l’exemple suivant :
setLayout(new BorderLayout()) ;
FLowLayout
C’est le gestionnaire le plus simple.
L’ajout de composant s’effectue de gauche à droite et de haut en bas.
BorderLayout
Ce gestionnaire permet de placer des composants selon 5 zones.
North
Center
South
West
East
Il suffit d’indiquer où l’on désire placer les composant : add("North", b);
GridLayout
Ce gestionnaire permet de créer une grille (n × m).
Les éléments sont ajoutés de gauche à droite et de haut en bas.
Combiner les
mises en
page
Pour pouvoir utiliser plusieurs gestionnaire dans une même applet, il faut
passer par la classe Panel.
Exemple :
Panel p1 = new Panel() ; Panel p2 = new Panel() ;
p1.setLayout(new BorderLayout()) ;
p2.setLayout(new FlowLayout(FlowLayout.LEFT)) ;
add(p1) ; add(p2) ;
Page 32
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
SWING : Interface évoluée
SWING
Le paquetage SWING (javax.swing.*) contient les classes nécessaires à la
conception d’interfaces utilisateurs plus évoluées que AWT : onglet, arbo­
rescence, éditeur de texte RTF, afficheur de page ouaibe, ….
Les interfaces crées grâce à SWING sont actuelles : images et logos dans les
menus, sur les boutons, …
Bien que faisant appel au maximum au code natif, les programmes utilisant
ce type d’interface sont plus lent que les programmes utilisant les inter­
faces AWT.
Classes
La plupart des classes des interfaces utilisateurs swing portent le même
nom que les classes AWT, à ceci près qu’elles sont précédées de J :
JFrame, JButton, JList, JPanel, …
Quelques exceptions : le bouton radio (JRadioButton) qui fait parti d’un
groupe (ButtonRadio), …
Evénements
Une interface swing utilise les mêmes gestions d’événements qu’une inter­
face AWT, mais peut utiliser quelques écoutes d’événements supplémen­
taires telles que MenuListener pour suivre les évolutions de l’utilisateur au
travers des menus.
L’habillage
Il est possible d’habiller les fenêtres swing et leurs éléments selon la mode
Windows, Motif ou Metal. Il faut alors spécifier leurs LookAndFeel…
/** chaine liee a l'affichage de type Windows*/
String look1 = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
/** chaine liee a l'affichage de type Motif*/
String look2 = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
/** chaine liee a l'affichage de type Metal*/
String look3 = "javax.swing.plaf.metal.MetalLookAndFeel";
Pour modifier le look and feel, placer le code suivant :
try {
UIManager.setLookAndFeel(look);
SwingUtilities.updateComponentTreeUI(fenetre);
}
catch(Exception exception) { exception.printStackTrace(); }
où look est l’une des chaînes précédentes, et fenetre l’objet de type
JFrame dont on souhaite modifier l’affichage.
Il est également possible de demander un affichage particulier au lance­
ment d’un programme :
java Fenetre // affichage façon métal par défaut
java
-Dswing.defaultlaf=com.sun.java.swing.plaf.windows.WindowsLookAndFeel
Fenetre
java -Dswing.defaultlaf=com.sun.java.swing.plaf.motif.MotifLookAndFeel Fenetre
Ce sujet continue page suivante
Emmanuel ADAM
Bloc Note JAVA
Page 33
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
SWING : Interface évoluée,
Contenu
En swing, les composants sont ajoutés dans le contenu (Container) de la fe­
nêtre JFrame et non directement dans la fenêtre comme en AWT.
Ainsi l’exemple de la page 23 proposant deux boutons s’écrit de la façon
suivante (ici la gestion d’événements est centralisée dans une seule classe,
et l’affichage façon Window été demandé) :
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class JTestBoutons extends JFrame
{
JButton b1 = new JButton("Bouton n°1");
JButton b2 = new JButton("Bouton n°2");
public JTestBoutons()
{
super(titre);
Container content = getContentPane();
content.setLayout(new FlowLayout());
ActionBouton ab = new ActionBouton();
b1.addActionListener(ab);
b2.addActionListener(ab);
content.add(b1);
content.add(b2);
try
{
UIManager.
setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
SwingUtilities.updateComponentTreeUI(this);
}
catch(Exception exception) { exception.printStackTrace(); }
setDefaultCloseOperation(EXIT_ON_CLOSE);
pack() ;
}
class ActionB1 implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
String nom = e.getAcionCommand();
if (nom.equals("Bouton n°1")) System.out.println("clic sur 1");
if (nom.equals("Bouton n°2")) System.out.println("clic sur 2");
}
}
}
Ce sujet continue page suivante
Page 34
Bloc Note JAVA
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
ISTV
SWING : Interface évoluée,
Les menus
Les menus sont des composants légers sous SWING, ce qui fait qu’il s’af­
fiche sous les autres composants de poids plus lourds !!!
Il est donc fréquent que le menu déroulant soit caché par les autres com­
posants de l’interface.
Pour remédier à cela, il faut signaler à Java que le menu que l’on a créé
possède un poids fort, ou ne possède pas un poids léger, et il faut répéter
cette recommandation sur chaque menu et non sur le barre de menus :
void addMenu()
{
GestionMenuItem gmi = new GestionMenuItem(this);
JMenuBar jmb = new JMenuBar();
JMenu jm = new JMenu("Fichier");
JMenuItem jmi = new JMenuItem("Nouveau");
jmi.addActionListener(gmi);
jm.add(jmi);
jmi = new JMenuItem("Ouvrir");
jmi.addActionListener(gmi);
jm.add(jmi);
jmb.add(jm);
JPopupMenu popup = jm.getPopupMenu();
popup.setLightWeightPopupEnabled(false);
}
Emmanuel ADAM
setJMenuBar(jmb);
Bloc Note JAVA
Page 35
ISTV
Université de Valenciennes et du Hainaut-Cambrésis
Sujet TP Java – Look story (histoire de regards)
Sujet
Sur une petite chaîne, un nouveau jeu vient de naître : il s’agit de filmer
24/24 des candidats enfermés dans une maison.
Les caméras permettent de suivre le regard des candidats, ainsi, si J-E. re­
garde L., une ligne est tracée entre eux deux.
Il s’agit ici de simuler une étape très importante du jeu : la piscine.
Quatre candidats se trouvent aux quatre coins de la piscine.
Alain est attiré par Bea qui est attirée par Cédric qui est attiré par Doro­
thée qui est attirée par Alain !
Chacun(e) se trouve donc à un coin de la piscine et regarde dans la direc­
tion qui l’attire. A chaque instant, il(elle) avance d’un dixième de la
distance qui le sépare de son élu(e).
Définir la classe Candidat représentant une personne par sa position, son
élu(e) et son comportement.
Les candidats ne sont pas représentés graphiquement, seuls les regards le
sont.
Ecrivez la fonction affichant le regard, c’est-à-dire le chemin séparant
un(e) candidat de son élu(e) pour chaque étape (en utilisant la méthode
drawLine).
Dans la Frame, placer les quatre candidats et faites les se déplacer un
nombre limité de fois.
Guide
Etendez les classes Frame et WindowAdapter en vous basant sur l'exemple
de la fiche "Une application fenêtrée".
Sujet 2
Modifier le programme précédent :
- les candidats sont en nombres variables et placés dans un vecteur (cf. La
fiche correspondante)
- le placement des candidats se fera par clic de souris (pour cela, étendez
la classe MouseAdapter en redéfinissant la méthode MouseClicked).
Exemple de
résultat
Ce sujet continue page suivante
Page 36
Bloc Note JAVA
Emmanuel ADAM
