Introduction à la programmation Java - BFH

Transcription

Haute école spécialisée bernoise
Haute école technique et informatique, HTI
Section Electricité et système de communication
Laboratoire de l’informatique technique
Introduction à la
programmation Java
Programmation GUI & Traitement des évènements
Les applets
Les Thread
Les exceptions
Les entrées et les sorties
 2008, HTI Bienne
E. FIROUZI
Nom de fichier : Manuscrit_Introduction_Java_Partie_2
Crée le: 28. avril 2015
Auteur: E. FIROUZI
Version: 2.0
Tables des matières
Table des matières
4 Programmation GUI & Traitement des évènements
4.1 Structure des applications GUI
4.1.1 Hiérarchie des fenêtres
4.1.2 Hiérarchie des classes des composants GUI
4.1.3 Les éléments de contrôle élémentaires
4.2.1 Positionnement des composants
4.2 Le gestionnaire de position
4.2.2 BorderLayout
4.2.3 FlowLayout
4.2.4 GridLayout
4.2.5 GridBagLayout
4.2.6 CardLayout
4.2.7 Les imbrications de gestionnaire de position
4.3 Le traitement des évènement
4.3.1 Le modèle d’évènement par délégation du paquet AWT 1.1
4.3.2 Les types d’évènements
4.3.3 Les Sources d’évènement
4.3.4 Les observateurs d’évènement
4.3.5 Les adaptateurs
4.4 Les éléments de contrôle élémentaire
4.4.1 La surface de dessin : Canvas
4.4.2 Les boutons
4.4.3 Les listes à choix unique
4.4.4 Les cases à cocher
4.4.6 Les zones de texte
4.4.7 Les barres de défilement
4.4.8 Les menus dans Java
5 Les applets
5.1 Introduction
5.1.1 Les pages HTML
5.1.2 Exemple d’applet
5.2 Mode de fonctionnement des applets
5.2.1 Stockage des applets
5.2.2 Sécurité des applet
5.3 Les fonctions PARAM
5.3.1 Exemple d’applet pour convertir des francs suisses en monnaies étrangères
5.4 Les sons et les images
5.4.1 Les sons
5.4.2 Les images
6 Les Thread
7 Les exceptions
7.1 Introduction
7.1.1 Exemple de code
7.2 Principe de fonctionnement
7.2.1 Une implémentation possible du traitement d’exception
Page 2
4
4
4
5
6
7
7
7
7
9
10
11
13
14
16
16
18
19
19
20
21
21
24
26
27
29
31
33
36
36
36
36
38
40
40
41
42
44
44
45
48
48
51
51
52
52
Tables des matières
7.3 L’avantage des traitements des exceptions de Java
7.4 Les classes et les exceptions
8 Les entrées et les sorties
8.1 Les entrées en Java
8.1.1 Les entrées orientés byte
8.1.2 Les entrées orientés caractères
8.1.3 L’entrée standard
8.2 Les sorties en Java
8.2.1 Les sorties avec les flux orientés bytes
8.2.2 Les sorties avec les flux orientés caractères
8.2.3 La sortie standard
8.3 Exemple d’application
8.3.1 Traitement des données orienté byte
8.3.2 Traitement des données orienté bloque
8.3.3 Traitement des données en format Internet
Page 3
52
52
53
55
55
55
56
58
59
59
60
61
61
61
62
64
4 Programmation GUI & Traitement des
évènements
Le JDK (Java Development Toolkit) contient des nombreuses classes pour la programmation des interfaces
d’utilisateur graphique, abrégé en anglais par GUI (Graphical User Interface). Ces classes sont mis a disposition
dans le paquet « java.awt » (Abstract Windows Toolkit = AWT). Elles permettent de dessiner des objets
graphiques et de programmer l’interaction utilisateur - application, dans le cadre des applets mais également des
applications indépendantes, qui peuvent être exécutées sous différents systèmes d’exploitations.
JDK met à disposition tous les éléments de contrôle standards pour programmer les interfaces
d’utilisateur graphique : les menus, la sourie, les éléments de contrôle et de dialogue. Toutefois, les applications,
qui sont imbriqués dans des pages web, ne devraient pas pouvoir accéder aux données locales. Par conséquent,
les applet ne contiennent pas les éléments de dialogue, qui permettent d’afficher le contenu des répertoires ou de
choisir des fichiers.
Dans la perspective de portabilité des applications, le concept du « gestionnaire de position » (layout manager) a
également été introduit dans Java, afin de pouvoir créer des interfaces d’utilisateur graphique avec des tailles
variables.
4.1 Structure des applications GUI
Avec Java 2, il est également possible de programmer les applications GUI avec le système de classes
« Swing. ». La structure des composants élémentaires de ce paquet est identique à celui d’AWT. Les exemples
des chapitres suivants ont été codés avec le système AWT. Les représentations Swing, associées à ces exemples,
se trouvent dans le livre de Jobst.
4.1.1 Hiérarchie des fenêtres
Les applications graphiques sont toujours composées d’une fenêtre principale. Dans la philosophie Java, cette
fenêtre est un « Container ». Chaque Container peut contenir d’autres Container sous forme de
composant.
La classe « Panel » est le Container le plus simple d’AWT. Il constitue la base pour les « Applet ». Mais
il peut également servir au montage des éléments de contrôle. Dans ce cas il sera ajouté comme un composant
standard dans une autre fenêtre.
La classe « Window » représente une fenêtre indépendante. Une fenêtre est un morceau rectangulaire sur l’écran,
sans titre et sans cadre. La classe « Frame » est une fenêtre avec un titre et un cadre. Frame peut contenir une
barre de menu et est mise à disposition pour la programmation des applications GUI.
Exemple de code
import java.awt.*;
public class MyFrame extends Frame {
MyFrame(String Title) {
super(Title);
add(new Button("AWT Button"));
setSize(300, 100);
setVisible(true);
}
Page 4
}
public static void main(String[] args){
new MyFrame("Java application with AWT");
}
Instruction
Dans l’exemple ci-dessus, la classe « MyFrame » découle de la super classe Frame. Cela s’exprime avec :
public class MyFrame extends Frame
Les propriétés de la fenêtre sont définies dans le constructeur de MyFrame. La fenêtre reçoit un titre avec l’appel
du constructeur de la super classe Frame. Les différents composants de l’interface d’utilisateur doivent être
générés et ajoutés au Container avec la méthode :
public void add(Component oneComponent)
Dans cet exemple, le bouton « AWT Button » est ainsi placé dans la fenêtre principale. Finalement, la taille et
la visibilité de la fenêtre sont définies respectivement avec les méthodes « setSize » et « setVisible ».
Un objet de la classe « MyFrame » est généré dans la méthode principale « main ». La fenêtre apparaît ainsi sur
l’écran.
Exemple d’affichage
4.1.2 Hiérarchie des classes des composants GUI
Les différents composants de l’interface d’utilisateur sont représentés à l’aide d’une hiérarchie de classes, dont la
racine est la classe abstraite « java.awt.Component ». Toutes les classes AWT possèdent ainsi les attributs
et les méthodes de « Component ». Ces derniers permettent de déterminer l’aspect des composants et de
programmer le traitement des évènements à l’aide des méthodes suivantes :

Définition de la taille et de la position : getSize, getX, getY, setSize, setLocation etc.

Définition et enquête sur les propriétés graphiques : getForground, setBackground, setFont,
getCursor etc.

Affichage des composants : setVisible, paint, rePaint etc.

Traitement des évènements.
La classe abstraite « Container » est le sou classe la plus important de Component. Container sert
essentiellement à ajouter les éléments de contrôle dans les fenêtres et les dialogues. Pour cela, elle met à
disposition les méthodes suivantes :

Ajouter un composant au Container : add

Enlever un composant du Container : remove, removeAll etc.

Définition et enquête sur le gestionnaire de position : setLayout, getLayout, doLayout etc.
La figure suivante montre la hiérarchie des classes AWT :
Page 5
java.awt.Component
java.awt.Button
java.awt.Canvas
java.awt.Checkbox
java.awt.Choice
java.awt.Label
java.awt.List
java.awt.Scrollbar
java.awt.TextComponent
java.awt.TextArea
java.awt.TextField
jawa.awt.Container
java.awt.ScrollPane
java.awt.Panel
java.awt.Applet
java.awt.Window
jawa.awt.Frame
jawa.awt.Dialog
jawa.awt.FileDialog
4.1.3 Les éléments de contrôle élémentaires
Dans Java, une série d’éléments de contrôle se sont imposés pour les interfaces d’utilisateur graphique : bouton,
barre de défilement etc. Le tableau suivant contient ces éléments de contrôle du paquet java.awt. Le chapitre
4.4 (Les éléments de contrôle élémentaires) fournit une description plus détaillée de ces éléments de contrôle.
Classe AWT
Canvas
Component
Panel
Choice
Scrollbar
Checkbox
Button
Label
List
TextComponent
TextArea
TextField
Description
Surface de dessin
Base des composants
Panneau, qui peut utiliser comme élément de contrôle
Liste de choix unique
Barre de défilement
Case à cocher et bouton radio
Bouton
Etiquette
Liste de choix multiple
Classe de base pour les zones de texte
Zone de texte avec plusieurs lignes
Zone de texte avec une seule ligne
La classe « Canvas » permet de générer une surface de dessin. Des éléments de la programmation graphique
« java.awt.Graphics » permettent d’afficher un texte, ou de dessiner des lignes et des figures dans cette
surface de dessin.
La classe « Choice » permet de d’implémenter des listes d’éléments. Ces listes contiennent des éléments du
type String, parmi lesquels un seul peut être choisi.
La classe « Scrollbar » permet d’implémenter des barres de défilement, dans lesquelles la position du chariot
mobile correspond à une valeur entière (int). La course et le déplacement du chariot sont paramétrables.
La classe « Checkbox » permet d’implémenter des cases à cocher. Ces dernières sont composées d’une case de
marquage, qui peut être cochée ou pas, et du texte correspondant à la case.
Page 6
La classe « TextComponent » est la classe de base pour les classes « TextArea » et « TextField ». Elle
contient les méthodes de base pour le traitement des zones de texte. La classe TextArea est une surface de
texte, qui contient plusieurs lignes. La classe TextField est une zone de texte avec une seule ligne.
Les éléments de contrôle dans un cadre
Choice
Button
CheckBox
TextField
CheckBox
as radio
buttons
List
ScrollBar
4.2 Le gestionnaire de position
Les interfaces d’utilisateur, dans lesquelles les composants sont placés de façon fixe, ne sont pas suffisants pour
les applications internent : il existe plusieurs système d’exploitation comme Macintosh, Linux, Microsoft
Windows etc. ainsi que différentes tailles d’écran.
Java permet de placer les composants de façon fixe, mais il permet également de placer ces composants selon des
stratégies divers.
Les fenêtres peuvent être agrandi ou rétréci. Evidemment, cela concerne également les composants placés à
l’intérieur des fenêtres. Java permet de résoudre ce problème à l’aide du gestionnaire de position (layout
manager). Chaque Container possède son propre gestionnaire de position, qui est responsable du placement
des composants à l’intérieur du Container.
Les gestionnaires de positionnement peuvent suivre des stratégies différentes, pour placer les composants dans un
Container. Java propose depuis JDK 1.0 cinq stratégies de placement. Le tableau suivant contient tous les
gestionnaires de position du paquet AWT, qui sont librement attribuable au Container.
Layout manager
BorderLayout
CardLayout
FlowLayout
GridLayout
GridBagLayout
Stratégie de placement
Positionnement des composant à gauche, à droite, en haut, au milieu et en bas
Recouvrement des composants
Positionnement des composants en ligne
Positionnement des composants dans un tableau
Positionnement plus flexible des composants dans un tableau :
Positionner les cellules en fonction des autres cellules
4.2.2 BorderLayout
Dans JDK, Frame, Applet et Dialog possèdent de façon standard le gestionnaire de position
« BorderLayout ». Ce gestionnaire utilise pour qualifier ces quatre bords les termes de la rose des vents.
Page 7
North
West
Center
East
South
Application
BorderLayout résout les problèmes courant de positionnement pour les surfaces de contrôle et de dessin. Les
éléments de contrôle sont montés dans les bords sous forme de barre d’outils. Ces barres d’outils sont des
composants du type « Panel », qui contiennent à leur tour des éléments de contrôle.
Exemple de code
import java.awt.*;
class BorderDemo extends Frame {
BorderDemo (String Title) {
super (Title);
setSize (300, 150);
add (new Button ("North"),
add (new Button ("South"),
add (new Button ("West"),
add (new Button ("East"),
add (new Button ("Center"),
setVisible(true);
}
}
BorderLayout.NORTH);
BorderLayout.SOUTH);
BorderLayout.WEST);
BorderLayout.EAST);
BorderLayout.CENTER);
public static void main (String[] args) {
new BorderDemo("BorderLayout");
}
Instruction
Dans le constructeur, les boutons générés sont ajoutés à la fenêtre à l’aide de la méthode:
public void add(Component oneComponent, Object constraints)
Ces derniers sont enregistrés chez le gestionnaire de position avec une contrainte de position. BorderLayout
utilise ces paramètres afin de positionner les composants. Le tableau suivant contient les différents paramètres de
positionnement de BorderLayout :
Paramètre de positionnement
BorderLayout.NORTH
BorderLayout.SOUTH
BorderLayout.WEST
BorderLayout.EAST
BorderLayout.CENTER
Description
Positionnement du composant en haut de la fenêtre
Positionnement du composant en bas de la fenêtre
Positionnement du composant à gauche de la fenêtre
Positionnement du composant à droite de la fenêtre
Positionnement du composant au milieu de la fenêtre
Page 8
Affichage
4.2.3 FlowLayout
Dans JDK, Panel possède de façon standard le gestionnaire de position « FlowLayout ». Ce gestionnaire
place les composant l’un après l’autre de gauche à droite. Lorsqu’une ligne et plaine, le composant est placé sur
la ligne suivante. Le tableau suivant contient les différents paramètres de positionnement de FlowLayout :
Paramètre de positionnement
FlowLayout.LEFT
FlowLayout.CENTER
FlowLayout.RIGHT
FlowLayout.LEADING
FlowLayout.TRAILING
Description
Alignement des composants à gauche
Alignement des composants au centre (par défaut)
Alignement des composants à droite
Alignement des composants en fonction de la langue.
Avec les langues qui s’écrivent de gauche à droite : comme LEFT.
Alignement des composants en fonction de la langue.
Avec les langues qui écrivent de gauche à droite : comme RIGHT.
Exemple de code
import java.awt.*;
public class FlowDemo extends Frame {
FlowDemo (String Title) {
super (Title);
setLayout (new FlowLayout (FlowLayout.LEFT));
setSize(200, 130);
for (int i = 1; i <= 7; i++) {
String s = "";
for (int j = 0; j < i; j++) {
s += "S";
}
add(new Button (s));
}
setVisible(true);
}
}
new FlowDemo("FlowLayout");
}
Instruction
Comme Frame possède de façon standard un gestionnaire de position BorderLayout, il faut d’abord changer
son gestionnaire de position. Par conséquent, un nouvel objet FlowLayout, avec une contrainte d’alignement à
gauche, est créé dans cet exemple. Ce gestionnaire est en suite attribué à la fenêtre principale à l’aide de la
méthode :
Page 9
public void setLayout(LayoutManager mgr)
Finalement, dans la boucle for, les boutons sont crées et ajouté à la fenêtre principale.
Affichage
FlowLayout.LEFT
FlowLayout.CENTER
FlowLayout.RIGHT
4.2.4 GridLayout
Le gestionnaire de position « GridLayout » permet de placer les composants dans un tableau contenant n
lignes et m colonnes.
Exemple de code
import java.awt.*;
public class GridDemo extends Frame {
GridDemo (String Title) {
super(Title);
setLayout (new GridLayout (2, 4));
setSize(300, 200);
for (int i = 0; i <= 7; i++) {
add(new Button ("Button " + i));
}
setVisible(true);
}
}
new GridDemo ("GridLayout");
}
Instruction
Comme Frame possède de façon standard le gestionnaire de position BorderLayout, il faut également fixer
le nouveau gestionnaire à l’aide de la méthode setLayout. Par conséquent, un objet de la classe
GridLayout est créé dans cet exemple afin d’être attribué au Container de la fenêtre principale.
Les nombres de lignes (en premier) et de colonnes sont fixés à la création de l’objet GridLayout. Des espaces
horizontaux et verticaux en pixel peuvent également être définis à l’aide de deux paramètres entiers
supplémentaires.
Page 10
Affichage
4.2.5 GridBagLayout
La classe « GridBagLayout » permet de disposer les composants de façon quadrillée. Contrairement à
GridLayout, la disposition des composants y peut être influencée à l’aide des attributs de la classe
« GridBagConstraints ».
Attribut de contrôle
gridx, gridy
gridwidth,
gridheight
fill
weightx, weighty
Description
Le coin en haut à gauche du composant peut être introduit à l’aide de ce paramètre.
Le composant qui est le plus haut et le plus à gauche possède les adresses
gridx = 0 et gridy = 0.
La valeur par défaut « GridBagConstraints.RELATIVE » pour gridx (res.
gridy) permet de placer le composant à droite (res. En dessous) du dernier
composant inséré dans le container.
Ces paramètres, qui possèdent la valeur par défaut 1) permettent de définir le nombre
de lignes (gridwidth) et de colonnes (gridheight).
La valeur « GridBagConstraints.REMAINDER » assigne la dernière ligne
(gridwidth) respectivement la dernière colonne (gridheight) au le composant.
GridBagConstraints.RELATIVE fait en sorte que le composant se trouve dans
l’avant dernière ligne (gridwidth) respectivement l’avant dernière colonne
(gridheight).
Le composant est adapté au domaine qui lui est réservé.
GridBagConstraints.NONE
Pas d’adaptation (valeur par défaut)
GridBagConstraints.HORIZONTAL
Uniquement adaptation horizontale
GridBagConstraints.VERTICAL
Uniquement adaptation verticale
GridBagConstraints.BOTH
Adaptation horizontale et verticale
Ce paramètre défini la répartition d’un composant dans les directions x et y.
Exemple de code
import java.awt.*;
public class GridBagDemo extends Frame {
Button b[] = new Button[6];
GridBagDemo (String Title) {
super(Title);
GridBagLayout l = new GridBagLayout();
setLayout(l);
setSize(300,200);
Page 11
for(int i = 0; i < b.length; i++){
b[i] = new Button("Button " + i);
}
GridBagConstraints c = new GridBagConstraints ();
c.fill = GridBagConstraints.BOTH;
/* Button 0 */
c.weightx = 1;
c.weighty = 1;
c.gridheight = 2;
l.setConstraints(b[0], c);
add(b[0]);
/* Button 1 */
c.gridheight = 1;
add(b[1]);
/* Button 2 */
add(b[2]);
/* Button 3 */
c.gridwidth = GridBagConstraints.REMAINDER;
add(b[3]);
/* Button 4 */
c.gridwidth = GridBagConstraints.RELATIVE;
add(b[4]);
/* Button 5 */
c.gridwidth = GridBagConstraints.REMAINDER;
add(b[5]);
setVisible(true);
}
}
new GridBagDemo ("GridBagLayout");
}
Instruction
Comme Frame possède de façon standard le gestionnaire de position BorderLayout, il faut également fixer
le nouveau gestionnaire à l’aide de la méthode setLayout. Par conséquent, un objet de la classe
« GridBagLayout » est créé dans cet exemple afin d’être attribué au Container de la fenêtre principale. Un
objet de la classe « GridBagConstraints » est créé comme contrainte de placement, afin de pouvoir
influencer le placement des composants.
La méthode
public void setConstraints (Component oneComponent,
GridBagConstraints constraints)
relie systématiquement les composants à la contrainte de placement. Une seule contrainte de placement est
utilisée dans l’exemple ci-dessus, car setConstraints travail avec des copies de cet objet.
Page 12
L’attribut gridheight de la contrainte de placement du premier bouton est mis à 2 (bouton avec le texte
« Button 0 »). Par conséquent ce composant sera placé sur deux lignes. gridheight est remis à 1 pour le
placement du second bouton. L’attribut gridwidth reprend par la suite le placement de ligne. Lorsque par
exemple ce dernier est mis à GridBagConstraints.REMAINDER, le composant rempli le reste de la ligne.
Affichage
4.2.6 CardLayout
La classe « CardLayout » permet un de réaliser un placement alternatif, c'est-à-dire un choix entre plusieurs
conteneurs qui sont superposés comme dans un jeu de cartes. Les méthodes « first(Container) »,
« last(Container), » et « next(Container) » permettent de permuter les cartes.
Application
CardLayout permet d’afficher différents jeux d’éléments de contrôle. Ce qui permet de réaliser des choix de
paramètres complexes, comme par exemple les éléments de contrôle tabulaires des systèmes d’exploitation
modernes. Un élément de contrôle supplémentaire est nécessaire afin de pouvoir permuter les cartes.
Exemple de code
import java.awt.*;
public class CardDemo extends Frame {
CardDemo (String Title) {
super (Title);
setLayout (new CardLayout());
setSize(300,150);
for(int i = 0; i <=7; i++) {
add("Button " + i, new Button("Button " + i));
}
setVisible(true);
}
Page 13
}
CardDemo cardDemo = new CardDemo("CardLayout");
/* Definition of a reference variable for CardLayout,
which is initialized with the layout manager of CardDemo */
CardLayout cl = (CardLayout)cardDemo.getLayout();
/* Show the first card */
cl.first (cardDemo);
for(int i = 0; i < 5; i++) {
/* The component of the container can be shown step by step,
with the help of break points */
cl.next (cardDemo);
}
/* Show the last card */
cl.last (cardDemo);
}
Instruction
Comme Frame possède de façon standard le gestionnaire de position BorderLayout, la méthode
« setLayout » doit définir au début le nouveau gestionnaire de position. Par conséquent, un objet de la classe
CardLayout est généré et attribué à ce dernier. La méthode
public void add (String Name, Component oneComponent)
ajoute le nouveau composant au container sous le nom « Name ».
Un objet de la classe « CardDemo » et une référence sur une classe « CardLayout » sont créés dans la méthode
principale. La référence est ensuite initialisée avec la méthode :
public LayoutManager getLayout()
La référence adresse alors le gestionnaire de position de CardDemo et est ainsi en mesure de permuter les cartes
avec les méthodes :
public void first(Container parent)
public void next(Container parent)
public void last(Container parent)
Affichage dans AWT
.....
4.2.7 Les imbrications de gestionnaire de position
Chaque container peut contenir d’autres containers. Du fait que chaque container possède son propre gestionnaire
de position (layout manager), il est possible d’imbriquer ces derniers. Il ainsi possible de créer des placements
complexes d’éléments de contrôle. L’exemple suivant montre comment cinq containers ont été placés dans une
fenêtre principale selon la stratégie BorderLayout. Chaque container possède à son tour un objet de la classe
GridLayout comme gestionnaire de position.
Exemple de code
import java.awt.*;
Page 14
class MyPanel extends Panel {
public MyPanel (String Text, int Lines, int Columns){
setLayout(new GridLayout(Lines, Columns));
for(int i = 0; i < Lines * Columns; i++){
add(new Button(Text + " - " + (i+1)));
}
}
}
public class NestedDemo extends Frame {
NestedDemo (String Title){
super(Title);
setSize(500, 300);
add(BorderLayout.NORTH, new MyPanel("N",
add(BorderLayout.SOUTH, new MyPanel("S",
add(BorderLayout.WEST,
new MyPanel("W",
add(BorderLayout.EAST,
new MyPanel("E",
add(BorderLayout.CENTER, new MyPanel("C",
setVisible(true);
}
}
1,
1,
5,
7,
4,
4));
8));
1));
1));
3));
new NestedDemo ("Imbricates Layouts");
}
Instruction
La classe « MyPanel » a été définie dans l’exemple ci-dessus pour imbriquer les gestionnaires de position.
MyPanel est une sous classe de Panel et contient un objet de la classe comme gestionnaire de position. Dans
Java, Panel est un panneau, qui peut être utilisé comme container pour les éléments de contrôle. La liste de
paramètre du constructeur de MyPanel contient le texte à afficher ainsi que les nombres de lignes et de colonnes
destinés au gestionnaire de position.
Dans le constructeur de « NestedDemo », des objets de la classe MyPanel sont générés et insérés dans la
fenêtre principale selon le modèle de la rose des vents.
Affichage
Page 15
4.3 Le traitement des évènements
Une série d’éléments de contrôle se sont imposés dans les interfaces d’utilisation graphique : bouton, barre de
défilement, cases à cocher, bouton ratio etc. Java met également à disposition ces éléments de contrôle, qui
permettent une interaction complexe entre l’utilisateur et le programme.
Déplacer la sourie
Appuyer le bouton de la sourie
Déplacer la Barre de défilement
Programme
Appuyer une touche du clavier
Appuyer un bouton
Introduire un texte
Rafraîchir l’écran
Les stratégies suivantes sont à disposition pour programmer le traitement des évènements :
a)
Définition d’un point d’entré pour chaque type d’évènement comme par exemple : déplacer de la sourie,
appuyer sur une touche du clavier, déplacer de la barre de défilement, appuyer sur un bouton etc.
b) Définition d’un seul point d’entré et ramification en fonction du type d’évènement.
c)
Concept d’évènement avec source et observateur.
Le désavantage des stratégies a) et b) est la relation préétablie entre le programme et les évènements. Le résultat
est une construction complexe des différentes routines destinées au traitement des évènements. C’est pourquoi, la
stratégie c) a été introduite à partie du JDK 1.1, dans laquelle les évènements sont affectés de façon explicite à
des observateurs. Chaque classe peu ainsi implémenter des interfaces d’observation, qui sont spécifiques au
traitement des évènements. Toutefois, l’affectation des observateurs pour le traitement des évènements doit
s’effectuer de façon explicite.
4.3.1 Le modèle d’évènement par délégation du paquet AWT 1.1
Le modèle d’évènement par délégation a été introduit à partir du JDK 1.1. Dans ce modèle, le contrôleur
d’évènement connaît pour chaque évènement une source et un observateur « Listener ». L’affectation de la
source à l’observateur est libre, mais elle doit être effectuée de façon explicite.
Evènement
Source
Observateur
Il faut distinguer entre la propagation des évènements du type « single-cast » et du type « multi-cast ».
L’observateur d’évènements single-cast est déclaré avec la méthode « setxxListerner », alors que
l’observateur d’évènements multi-cast est déclaré avec la méthode « addxxListerner ».
Les observateurs doivent implémenter les interfaces d’observation « xxListener », qui sont spécifiques au
traitement des évènements. Le contrôleur d’évènement appelle une des méthodes de ces interfaces, en fonction
du type de l’évènement. Un sou classe d’ « EventObject », qui contient la description de l’évènement, sera
transmis comme paramètre à la méthode en question.
Page 16
La source est l’objet, qui génère l’évènement. La source définie le type de l’évènement, en mettant à disposition
des méthodes pour l’enregistrement des observateurs. La source peut être par exemple un composant de
l’interface d’utilisateur graphique. L’observateur est un « Adaptateur », qui implémente une ou plusieurs
interfaces xxListener.
Hiérarchie des évènements
Les différents types d’évènements sont modélisés à l’aide d’une hiérarchie de classes, dont la source est
« java.util.EventObjekt ».
java.util.EventObject
java.awt.AWTEvent
java.awt.event.ActionEvent
java.awt.event.AdjustmentEvent
java.awt.event.HierarchyEvent
java.awt.event.InputMethodEvent
java.awt.event.InvocationEvent
java.awt.event.ItemEvent
java.awt.event.TextEvent
java.awt.event.ComponentEvent
java.awt.event.ContainerEvent
java.awt.event.FocusEvent
java.awt.event.PaintEvent
java.awt.event.WindowEvent
java.awt.event.InputEvent
jawa.awt.event.KeyEvent
jawa.awt.event.MouseEvent
Exemple de code
Un programme qui tourne dans une fenêtre, doit pouvoir être arrêté. La solution la plus répandue est de presser
un bouton, qui se situe dans un coin en haut à droite de la fenêtre. La pression génère un évènement, qui peut être
intercepté par un observateur du paquet AWT.
L’exemple suivant montre une fenêtre, qui peut être fermée à l’aide d’un bouton :
import java.awt.*;
import java.awt.event.*;
class Frame1 extends Frame implements WindowListener {
public Frame1(String Title){
super(Title);
setSize(300, 100);
setVisible(true);
// Explicit attribution of the (window) events to the observer
addWindowListener(this);
}
Page 17
// Responsibilities of the event observer
public void windowClosed(WindowEvent event){}
public void windowDeiconified(WindowEvent event){}
public void windowIconified (WindowEvent event){}
public void windowActivated(WindowEvent event){}
public void windowDeactivated(WindowEvent event){}
public void windowOpened(WindowEvent event){}
public void windowClosing(WindowEvent event){
System.exit(0);
}
}
public static void main(String[] args){
new Frame1("1. Frame");
}
Indication
Dans cet exemple « Frame1 » a été définie explicitement comme source et observateur d’évènement du type
fenêtre (WindowEvent). Cela s’exprime avec :
addWindowListener(this);
En tant qu’observateur d’évènement du type fenêtre, Frame1 doit implémenter toutes les méthodes de
l’interface « WindowListener ». Même si ces dernières ne sont pas utilisées, comme dans l’exemple de cidessus. La méthode « windowClosing » de cette interface est appelée par le contrôleur d’évènement (Event
Handler), lorsque le bouton de fermeture, qui se situe en haut à droite de la fenêtre, est appuyé.
windowClosing contient par conséquent l’instruction « System.exit(0) » afin d’arrêter le programme.
Affichage
close
4.3.2 Les types d’évènements
AWT 1.1 contient deux types d’évènement : les évènements de « bas niveau » et ceux de « niveau sémantique ».
Les évènements de bas niveau modélisent les entrées simples (comme par exemple les touches du clavier, la
souris etc.) ou les évènements du type fenêtre. Le tableau suivant contient les évènements de bas niveau :
Evènement de bas niveau
ComponentEvent
FocusEvent
KeyEvent
MouseEvent
ContainerEvent
WindowEvent
Description
Le composant a été agrandi, réduit ou déplacé.
Le composant a été activé ou désactivé.
Une touche a été appuyée, relâchée ...
Le bouton de la sourie a été appuyée, relâchée ...
Le conteneur a reçu ou a perdu un composant.
Fermeture de la fenêtre.
Les évènements de niveau sémantique sont générés par les composants de l’interface d’utilisateur graphique. Ces
évènements ne sont pas spécifiques aux éléments de contrôle. Par exemple, des évènements du type action
(ActionEvent) peuvent être générés par un bouton, un élément de menu ou une liste. Le tableau suivant
contient les évènements de niveau sémantique :
Page 18
Evènement de niveau sémantique
ActionEvent
AdjustmentEvent
ItemEvent
TextEvent
Description
Exécution d’une commande.
Adaptation d’une valeur.
Modification d’une entrée.
Modification du texte.
4.3.3 Les Sources d’évènements
Les évènements, qui peuvent être générés par un objet, sont définis à l’aide des méthodes setxxListerner
ou addxxListener.
Tous les évènements AWT soutiennent le modèle multi-cast. Il n’existe pas d’information sur l’ordre, avec lequel
les évènements sont envoyés aux différents observateurs. La seule chose, qui est garantie, est que tous les
observateurs reçoivent une copie de l’évènement originale.
Les sources d’évènement de bas niveau
Source d’évènement
Component
Container
Dialog
Frame
Méthode pour la génération des évènements
addComponentListener
addFocusListener
addKeyListener
addMouseListener
addMouseMotionListener
addContainerListener
addWindowListener
addWindowListener
Les sources d’évènement de niveau sémantique
Source d’évènement
Button
Choice
Checkbox
CheckboxMenuItem
List
MenuItem
Scrollbar
TextArea
TextField
Méthode pour la génération des évènements
addActionListener
addItemListener
addItemListener
addItemListener
addActionListener
addItemListener
addActionListener
addAdjustementListener
addTextListener
addActionListener
addTextListener
4.3.4 Les observateurs d’évènements
Les interfaces d’observateur d’évènements possèdent en principe pour le traitement de chaque type d’évènement
une méthode spécifique. Toutefois, afin d’améliorer la vue d’ensemble, certaines méthodes on été rassemblées en
une seule méthode.
La figure suivante représente la hiérarchie des interfaces des observateurs de bas niveau et de niveau sémantique.
Page 19
Les interfaces d’observateur de bas niveau
java.util.EvenListener
java.awt.event.ComponentListener
java.awt.event.ContainerListener
java.awt.event.FocusListener
java.awt.event.KeyListener
java.awt.event.MouseListener
java.awt.event.MouseMotionListener
java.awt.event.WindowListener
Les interfaces d’observateur de niveau sémantique
java.awt.event.ActionListener
java.awt.event.AdjustmentListener
java.awt.event.ItemListener
java.awt.event.TextListener
4.3.5 Les adaptateurs
Les interfaces exigent l’implémentation complète de leurs méthodes, même si tous les types d’évènement ne
doivent pas être forcément traités. Les adaptateurs représentent ici une bonne alternative. Les adaptateurs sont
des classes, qui possèdent pour le traitement de chaque type d’évènement une méthode prédéfinie. Par exemple,
le traitement de tous les évènements du type souris peut être réalisé par l’adaptateur « MouseAdapter ». Dans
ce cas, si l’on veut uniquement traiter l’évènement « presser le bouton de la sourie », il suffit de sur écrire la
méthode « mousePressed ».
Les adaptateurs dans AWT
Il existe seulement des adaptateurs pour les évènements de bas niveau, car les interfaces d’observateur
d’évènements de niveau sémantique ne contiennent qu’une méthode. La liste complète des adaptateurs et leurs
méthodes est fournie dans le livre de Jobst.
La figure suivante représente la hiérarchie des adaptateurs :
java.awt.event.ComponentAdapter
java.awt.event.FocusAdapter
java.awt.event.KeyAdapter
java.awt.event.MouseAdapter
java.awt.event.MouseMotionAdapter
java.awt.event.WindowAdapter
Application pratique
Pour chaque observateur, il faut définir une sous classe de l’adaptateur. La méthode la plus élégante est de définir
cette sous-classe de façon interne. Si par exemple une fenêtre « Frame » doit uniquement traiter les évènements
du type « fermeture de fenêtre », il suffit de sur écrire la méthode « windowClosing ».
Page 20
Exemple de code : traitement des évènements du type fenêtre
import java.awt.*;
public class Frame2 extends Frame {
Frame2 (String Title) {
super(Title);
setSize(300, 200);
setVisible(true);
addWindowListener(new MyWindowAdapter());
}
class MyWindowAdapter extends WindowAdapter {
public void windowClosing(WindowEvent event) {
System.exit(0);
}
}
}
new Frame2("1. Frame");
}
Instruction
L’exemple de ci-dessus contient la classe interne « MyWindowAdapter », qui est une sous classe de
l’adaptateur « WindowAdapter ». Dans cette classe, la méthode « windowClosing », héritée de
WindowAdapter, est sur écrite avec l’instruction « System.exit(0) ». Ainsi l’application peut être arrêtée
à l’aide du bouton fermeture de fenêtre.
« Frame2 » et un exemplaire de MyWindowAdapter sont définis respectivement comme source et
observateur d’évènements du type fenêtre. Cela s’exprime avec :
addWindowListener (new MyWindowAdapter());
Les évènements du type fenêtre sont ainsi générés par Fram2 et envoyés à l’exemplaire de la classe
MyWindowAdapter afin d’y être traités.
4.4 Les éléments de contrôle élémentaires
Ce chapitre décrit les aspects élémentaires et l’implémentation des éléments de contrôle. Ces éléments sont
utilisés pour contrôler le déroulement du programme dans les interfaces d’utilisateur graphique. Ils ont été décrits
brièvement dans le chapitre 4.1.3 (Les éléments de contrôle élémentaires).
Les chapitres suivants traitent la fonctionnalité de base des éléments de contrôle. Cette description est complétée
chaque fois avec un exemple de code ainsi que son affichage sur l’écran.
4.4.1 La surface de dessin : Canvas
La classe « Canvas » est une fenêtre rectangulaire, dans laquelle des objets peuvent être dessinés. Pour dessiner
un objet, il faut sur écrire la méthode « paint » de Canvas. Cette méthode est appelée par le l’environnement
d’exécution (runtime) afin de réafficher le contenu de la fenêtre. La méthode « repaint » a le même effet, mais
cette dernière doit être appelée explicitement dans le programme.
L’environnement d’exécution fournit à la méthode paint un objet du type « Graphics ». Cet objet fournit un
lien au contexte graphique de l’application et permet ainsi d’afficher du texte et des formes géométriques. La
représentation graphique est limitée à la surface de l’écran, qui a été réservée pour le Canvas.
Page 21
La classe Graphics contient de nombreuses méthodes, dont les plus importantes sont représentées dans le
tableau suivant :
Quelques méthodes de la classe Graphics
clearRect (int x, int y, int width, int height)
copyArea (int x, int y, int width, int height, int dx, int dy)
drawChars (char [] data, int offset, int length, int x, int y)
drawLine (int x1, int y1, int x2, int y2)
drawOval (int x, int y, int width, int height)
drawRect (int x, int y, int width, int height)
drawstring(String str, int x, int y)
fillOval (int x, int y, int width, int height)
fillRect (int x, int y, int width, int height)
setColor (Color c)
setFont(Font f)
// and 38 more methods
Les cinq méthodes les plus utilisées sont des méthodes pour dessiner (draw...). Elles permettent d’afficher un
texte ou des formes géométriques. Les paramètres x et y sont définis en pixel et ils sont calculés à partie de
l’angle en haut à gauche de la fenêtre. La largeur et l’hauteur sont également définies en pixel. La méthode
« clearRectangle » efface une partie de la fenêtre. La méthode « copyArea » copie une partie de la
fenêtre et l’affiche à un autre endroit, qui se situe à dx et dy. Les méthodes « setColor » et « setFont »
permettent respectivement de définir la couleur et le type de police.
La classe « Color » contient les 13 couleurs les plus représentatives : noire, bleue, cyan, gris foncé, gris, vert,
vert claire, rouge magenta, orange, rose, rouge, blanc et jaune. Color contient également des méthodes, qui
permettent de créer des nouvelles combinaisons de couleurs.
Toutes les entrées s’effectuent en pixel. Les coordonnées en x vont de gauche à droite, alors que les coordonnées
en y vont de haut en bas. Ce qui est très souvent le cas dans les représentations orientées pixel :
(0, 0)
x
y
Exemple de code
import java.awt.*;
class FlagCanvas extends Canvas {
String country;
Color bar1, bar2, bar3;
Page 22
FlagCanvas(String country, Color bar1, Color bar2, Color bar3) {
this.country = country;
this.bar1 = bar1;
this.bar2 = bar2;
this.bar3 = bar3;
}
}
public void paint (Graphics g) {
// Draw the flag with the filled rectangles
g.setColor (bar1);
g.fillRect (40, 20, 200, 40);
g.setColor (bar2);
g.fillRect (40, 60, 200, 40);
g.setColor (bar3);
g.fillRect (40, 100, 200, 40);
g.setColor (Color.black);
g.drawString(country, 100, 160);
}
public class CanvasDemo extends Frame {
CanvasDemo () {
setSize(300, 200);
add (new FlagCanvas("Germany", Color.black, Color.red,
Color.yellow));
addWindowListener(new MyWindowAdapter());
setVisible(true);
}
class MyWindowAdapter extends WindowAdapter {
System.exit(0);
}
}
}
public static void main (String [] args) {
new CanvasDemo();
}
Instruction
Cet exemple contient la classe « FlagCanvas. », qui découle de la super classe Canvas. Cela s’exprime avec :
class FlagCanvas extends Canvas
Cette classe permet de dessiner des drapeaux, dont le motif est identique à celui de l’Allemagne. A la génération
du drapeau, les couleurs des barres transversales peuvent être transmisses au constructeur de FlagCanvas. La
méthode paint dessine le drapeau en fonction de ces paramètres.
Cet exemple contient également la classe principale « CanvasDemo », qui découle de la super classe Frame.
Une instance de FlagCanvas est générée dans le constructeur de CanvasDemo et est ajoutée à la fenêtre
principale. Cela s’exprime avec :
add (new FlagCanvas("Germany", Color.black, Color.red, Color.yellow));
Finalement un objet de la classe CanvasDemo est crée dans la méthode principale main. Le drapeau allemand
est ainsi affiché sur l’écran.
Page 23
Exemple d’affichage
4.4.2 Les boutons
La classe « Button » est une surface de fenêtre, dont la fonctionnalité correspond à un bouton avec un texte.
Lorsque l’utilisateur presse le bouton, Java fournit à ce dernier un exemplaire d’un évènement du type action
(« ActionEvent »). Tous les observateurs, qui ont été préalablement enregistrés avec la méthode
« addActionListener » du bouton en question, reçoivent alors une copie de cet évènement.
Les méthodes « getActionCommand » et « getSource » de l’évènement fournissent respectivement le
texte et la référence du bouton, qui est à l’origine de l’évènement. getActionCommand est fournie par la
classe « ActionEvent » alors que getSource est héritée de la super classe « EventObject ».
Le traitement des évènements du type action nécessite dans certain cas la détermination de la source de
l’évènement. Pour cela il est possible par exemple d’enregistrer pour chaque bouton un observateur distinct.
Toutefois, si l’on ne veut enregistrer qu’un seul observateur, ce dernier doit être en mesure de localiser le bouton,
qui a généré l’évènement.
Lorsque les textes des boutons sont distincts, ces derniers peuvent être utilisés pour la localisation de la source de
l’événement. Ce qui épargne le stockage des références des boutons.
// Somewhere in the program
add (new Button ("OK"));
// ActionEvent
if ("OK ".equals(event.getActionCommand())) {
// The OK button has been pressed. Code the reaction here.
}
Lorsque les textes des boutons ne sont pas distincts, il faut stocker leur référence à l’aide d’attributs. Dans la
partie traitement de l’évènement, il faut comparer pas par pas la source de l’évènement avec ces références.
// In the class, which treats the events
Button OKButton = new Button ("OK");
add (OKButton); // Not for BorderLayout
// ActionEvent
if (OKButton == event.getSource()) {
// The OK button has been pressed. Code the reaction here.
}
Page 24
Exemple de code
import java.awt.*;
public class ButtonDemo extends Frame implements ActionListener {
ButtonDemo (String Title) {
super (Title);
setLayout (new FlowLayout());
setSize (250, 160);
for (int i = 1; i <= 5; i++) {
Button b = null;
add (b = new Button ("Button " + i));
b.addActionListener(this);
}
addWindowListener (new WindowAdapter () {
public void windowClosing (WindowEvent event) {
System.exit(0);
};
});
setVisible(true);
}
public void actionPerformed(ActionEvent event) {
System.out.println("Button \"" + event.getActionCommand()
+ "\" has been pressed !");
}
}
new ButtonDemo ("Button-Demo");
}
Instruction
Dans la boucle for du constructeur, cinq boutons avec des textes distincts sont générés et ajoutées dans la fenêtre
principale. Ces cinq boutons et la classe « ButtonDemo » sont respectivement définis comme sources et
observateur d’évènement du type action (ActionEvent). Cela s’exprime avec :
add (b = new Button ("Button " + i));
b.addActionListener(this);
En tant qu’observateur d’évènements du type action, la classe ButtonDemo doit implémenter la méthode
« actionPerformed » de l’interface « ActionListener ». Dans cette méthode de texte du bouton, qui a
été appuyé, est affiché sur l’écran.
Dans cet exemple ButtonDemo et un exemplaire de l’adaptateur WindowAdapter ont été définis
respectivement comme source et observateur d’évènements du type fenêtre. Cela s’exprime avec :
System.exit(0);
};
});
Ici la méthode windowClosing de l’adaptateur WindowAdapter est d’abord sur écrite. Ensuite un
exemplaire de l’adaptateur modifié est généré et défini comme observateur d’évènement fenêtres.
Page 25
Affichage dans AWT
Affichage après avoir appuyé les boutons 1, 2, 3, 4, 5
Button
Button
Button
Button
Button
"Button
"Button
"Button
"Button
"Button
1"
2"
3"
4"
5"
has
has
has
has
has
been
been
been
been
been
pressed
pressed
pressed
pressed
pressed
4.4.3 Les listes à choix unique
La classe « Choice » d’AWT permet de programmer des listes d’éléments, dont un seul ne peut être
sélectionné. La méthode « addItem » permet d’ajouter des nouveaux éléments dans la liste. La méthode
« select » permet de sélectionner l’élément par défaut. Ce dernier sera affiché dans la partie supérieure de la
liste.
Lorsque l’utilisateur sélectionne un nouvel élément, un évènement du type « ItemEvent » est généré et envoyé
aux observateurs. La méthode « getItem » de l’évènement fournit le texte de cet élément.
Exemple de code
import java.awt.*;
public class ChoiceDemo extends Frame implements ItemListener{
ChoiceDemo (String Title) {
super (Title);
Choice choice = new Choice();
for(int i = 1; i <= 5; i++){
choice.addItem("Choice " + i);
}
choice.select(1);
choice.addItemListener(this);
add(choice, BorderLayout.NORTH);
addWindowListener(new WindowAdapter(){
System.exit(0);
}
});
setSize(400, 200);
setVisible(true);
}
// Responsibility as Item-Listener
public void itemStateChanged(ItemEvent event){
System.out.println("Choice: " + event.getItem());
}
Page 26
}
new ChoiceDemo("Choice-Demo");
}
Instruction
Dans le constructeur de « ChoiceDemo », un exemplaire de Choice est généré et ajouté à la fenêtre principale.
Dans la boucle for, les éléments sont ajoutés à la liste avec la méthode addItem. La méthode select permet
de sélection l’élément par défaut.
La liste d’élément et la classe ChoiceDemo sont définies respectivement comme source et observateur
d’évènements de type sélection (« ItemEvent »). Cela s’exprimé par :
choice.addItemListener(this);
En tant qu’observateur d’évènements de type sélection, ChoiceDemo doit implémenter la méthode
« itemStateChanged » de l’interface « ItemListener ». Cette méthode affiche le texte de l’élément, qui
a été sélectionné.
Affichage dans AWT
Affichage après avoir choisi les élément de choix 1, 2, 3, 4, 5
Choice:
Choice:
Choice:
Choice:
Choice:
Choice
Choice
Choice
Choice
Choice
1
2
3
4
5
4.4.4 Les cases à cocher et les boutons radio
La classe « Checkbox » d’AWT permet d’implémenter les cases à cocher ou les boutons radio.
La case à cocher dans AWT
add (new Checkbox ("Display title", null, true));
Un rassemblement de cases à cocher en boutons ratio dans AWT
CheckboxGroup group = new CheckboxGroup();
add (new Checkbox ("Red", group, true));
add (new Checkbox ("Green", group, false));
add (new Checkbox ("Blue", group, false));
Le système Java marque systématiquement la case à cocher ou le bouton radio, qui a été sélectionné. Dans le
cadre des boutons ratio, les marques de toutes les autres cases à cocher du groupe sont effacées. Tous les
observateurs, qui ont été enregistrés avec la méthode « addItemListener », reçoivent un évènement du type
« ItemEvent ».
Page 27
Exemple de code
import java.awt.*;
public class CheckboxDemo extends Frame implements ItemListener {
private final static int N = 5;
CheckboxDemo (String Title){
super (Title);
// GridLayout: 2 lines 5 column
setLayout(new GridLayout(2,N));
setSize(560, 100);
Checkbox c = null;
// Independent Checkbox
for(int i = 1; i <= N; i++){
add(c = new Checkbox("Check Box " + i));
c.addItemListener(this);
}
// Grouped Checkbox,
// which furnishes Radiobuttons
CheckboxGroup group = new CheckboxGroup();
for(int i = 1; i <= N; i++){
add(c = new Checkbox("Radio Button " + i, group, (i==2)));
}
System.exit(0);
}
});
setVisible(true);
}
public void itemStateChanged(ItemEvent event){
System.out.println("Choice: " + event.getItem());
}
}
new CheckboxDemo("Checkbox-Demo");
}
Instruction
Dans la première boucle for du constructeur « CheckboxDemo », cinq cases à cocher indépendante sont
générées et ajoutées à la fenêtre principale. Ces cases à cocher et la classe CheckboxDemo sont respectivement
définies comme sources et observateur d’évènements du type sélection (« ItemEvent »). Cela s’exprimé par :
for (int i = 1; i <= N; i++) {
add(c = new Checkbox("Button" + i));
}
Dans la deuxième boucle for du constructeur, la même chose est réalisée pour cinq cases à cocher rassemblées en
boutons radio.
Page 28
En tant qu’observateur d’évènement du type sélection, la classe CheckboxDemo doit implémenter la méthode
« itemStateChanged » de l’interface « ItemListener ». Cette méthode affiche sur la console la case à
cocher ou le bouton radio, qui a été sélectionné
Affichage dans AWT
Affichage après avoir coché dans les cases à cocher 2 et 4 ainsi que le bouton radio 4
Choice: Check Box 2
Choice: Check Box 4
Choice: Radio Button 4
4.4.5 Les étiquettes
La classe « Label » permet de définir une étiquette. Une étiquette est un texte, qui ne peut pas être modifié par
l’utilisateur.
Label number;
add (number = new Label ("Number..."));
number.setText("1234");
4.4.6 Les zones de texte
La classe « TextComponent » est la classe de base pour les composants textuels. TextComponent contient
les méthodes „void setText(String text)“ et „String getText()“ pour respectivement écrire et
lire un texte. Les méthodes « int getSelectionEnd() » et « int getSelectionStart() » sont
également à disposition, pour déterminer les limites de la zone sélectionnée par l’utilisateur.
TextField
La classe « TextField » permet d’éditer des textes sur une seule ligne. Ces éléments de contrôle sont générés
de la façon suivante :
new TextField("blue");
new TextField("green", 20);
La définition de la largeur en colonnes est en option. Lorsque l’utilisateur modifie le contenu de TextField, ce
dernier génère des évènements du type modification du texte (« TextEvent »). L’observateur de tels
évènements
doit
implanter
l’interface
« TextListener »,
qui
contient
la
méthode
« textValueChanged(TextEvent event) ».
Le gestionnaire d’évènement n’informe pas le programme, lorsque l’utilisateur sélectionne un morceau du texte,
sans en modifier le contenu.
TextArea
La classe « TextArea » permet d’éditer des textes sur plusieurs lignes. Un tel élément de contrôle contient
deux barres de défilement, qui permettent à l’utilisateur de se positionner horizontalement et verticalement.
Page 29
Exemple de code
import java.awt.*;
public class TextDemo extends Frame implements TextListener {
TextField tf;
// Text field, with only one line
TextArea ta;
// Text area, with several lines
TextDemo (String Title) {
super (Title);
setSize (250, 300);
add (new Label("Please enter your text:"), BorderLayout.NORTH);
add (tf = new TextField ("Text line......"), BorderLayout.SOUTH);
add (ta = new TextArea ("1\n2\n3\n4\n5\n6\n7\n"),
BorderLayout.CENTER);
tf.addTextListener(this);
ta.addTextListener(this);
System.exit(0);
}
});
setVisible(true);
}
public void textValueChanged(TextEvent event) {
// The source is in all cases an object of TextComponent
TextComponent t = (TextComponent)event.getSource();
System.out.println ("New content: " + t.getText());
}
}
public static void main (String [] args){
new TextDemo ("Text-Demo");
}
Instruction
Dans le constructeur de « TextDemo », des exemplaires de TextField (tf) et TextArea (ta) sont
générés et ajoutés à la fenêtre principale. Cela s’exprimé par :
add (tf = new TextField ("Text line......"), BorderLayout.SOUTH);
add (ta = new TextArea ("1\n2\n3\n4\n5\n6\n7\n"), BorderLayout.CENTER);
Ces éléments de contrôle et TextDemo sont définis respectivement en tant que sources et observateur
d'évènements de type modification du texte (TextEvent). Cela est exprimé par :
tf.addTextListener(this);
ta.addTextListener(this);
La classe TextDemo doit, en tant qu’observateur d'évènements de type modification du texte, implémenter la
méthode textValueChanged de l’interface TextListener. Cette méthode affiche le nouveau contenu de
la zone de texte, qui a été modifié.
Page 30
Affichage dans AWT
4.4.7 Les barres de défilement
Une barre de défilement permet de choisir une valeur entière dans un domaine prédéfini. La classe
« Scrollbar » permet de générer des barres de défilement, qui peuvent être placés soit horizontalement ou
verticalement.
L’utilisateur a trois possibilités pour interagir avec la barre de défilement : Il peut déplacer le chariot de la barre
de défilement (Track), il peut cliquer sur les barres, qui se situent de part et d’autre du chariot (block increment),
et il peut appuyer sur les marques de la barre de défilement (unit increment). Les observateurs sont enregistrés
avec la méthode « addAdjustmentListener » et ils reçoivent des évènements du type ajustement
(AdjustmentEvent).
Exemple de code
import java.awt.*;
public class ScrollbarDemo extends Frame implements AdjustmentListener {
private Scrollbar h = null, v = null;
ScrollbarDemo (String Title){
super (Title);
setSize(300, 300);
setLayout(null);
h = new Scrollbar(Scrollbar.HORIZONTAL, 50, 20, 0, 100);
v = new Scrollbar(Scrollbar.VERTICAL, 50, 20, 0, 100);
h.setBounds(50, 50, 150, 30);
v.setBounds(50, 100, 30, 150);
add(h);
add(v);
h.addAdjustmentListener(this);
v.addAdjustmentListener(this);
System.exit(0);
}
});
setVisible(true);
}
Page 31
// Task of the Item-Listener
public void adjustmentValueChanged(AdjustmentEvent event){
switch(event.getAdjustmentType()){
case AdjustmentEvent.UNIT_INCREMENT:
case AdjustmentEvent.UNIT_DECREMENT:
case AdjustmentEvent.BLOCK_INCREMENT:
case AdjustmentEvent.BLOCK_DECREMENT:
case AdjustmentEvent.TRACK:
if(event.getSource() == h){
System.out.println("h " + event.getValue());
}else if (event.getSource() == v){
System.out.println("v " + event.getValue());
}
break;
}
}
}
new ScrollbarDemo("Scrollbar-Demo");
}
Instruction
Dans le constructeur de « ScrollbarDemo », deux exemplaires de barres de défilement sont générés et ajoutés
à la fenêtre principale. Cela s’exprime avec :
h = new Scrollbar(Scrollbar.HORIZONTAL, 50, 20, 0, 100);
v = new Scrollbar(Scrollbar.VERTICAL, 50, 20, 0, 100);
h.setBounds(50, 50, 150, 30);
v.setBounds(50, 100, 30, 150);
add(h);
add(v);
L’orientation, la valeur par défaut, la taille du chariot, la valeur minimale et la valeur maximale sont spécifiées à
la génération de la barre de défilement. La méthode « setBounds » permet de définir la position et la taille de
la barre de défilement (unité pixel).
Dans cet exemple, les barres de défilement et la classe ScrollbarDemo sont définies respectivement comme
sources et observateur d’évènements du type ajustement (AdjustmentEvent). Cela s’exprime par :
h.addAdjustmentListener(this);
v.addAdjustmentListener(this);
En tant qu’observateur d’évènements du type ajustement, ScrollbarDemo doit implémenter la méthode
« adjustmentValueChanged » de l’interface « AdjustmentListener ». Cette méthode affiche la
nouvelle valeur de la barre de défilement.
Page 32
Affichage dans AWT
TRACK
UNIT_INCREMENT
BLOCK_INCREMENT
4.4.8 Les menus dans Java
Frame peut également contenir une barre de menu de type « MenuBar ». Cette barre peut à son tour contenir des
menus du type « Menu ». La barre de menu reçoit de Frame tous les évènements, qui la concernent. Lorsque
l’utilisateur choisit une des commandes du menu, le programme lance un évènement du type ActionEvent.
Chaque menu peut contenir à son tour d’autres menus. Dans ce cas, chaque entrée menue peut être une
commende, une commande avec une case à cocher ou un sous menu. La figure suivante illustre tous les cas :
Exemple de menu
La construction de la barre de menu dans Frame
La méthode « setMenuBar » permet d’ajouter la barre de menu dans Frame. De nombreux menus (Menu)
peuvent être ajoutées à cette barre de menu. Ces derniers contiendront les différentes entrées menues, comme par
exemple les commandes (MenuItem), les commandes avec case à cocher (CheckboxMenuItem) et les sousmenus.
MenuBar mMenuBar = new MenuBar();
SetMenuBar (mMenuBar);
Menu mMenu = new Menu ("File");
mMenuBar.add (mMenu);
mMenu.add (m_Save = new MenuItem ("Save));
Page 33
// Only possible in Frame
Le traitement des évènements
Le traitement des évènements nécessite la localisation de l’entrée menue, qui a été sélectionnée par l’utilisateur.
Lorsque les textes des entrées menues sont univoques, ils peuvent être utilisés pour cette localisation. Dans ce
cas, il faut utiliser la méthode « getActionCommand » de l’évènement, qui retourne le texte de l’entrée menue
sélectionnée.
Lorsque les textes des entrées menues ne sont pas univoques, il faut utiliser les références des entrées menues. La
source de l’évènement peut alors être déterminée avec sa méthode « getSource ». Cette dernière doit alors être
comparée systématiquement avec toutes les références des entrées menues. Ce procédé est illustré dans le
programme suivant :
Exemple de code
import java.awt.*;
public class FrameMenu extends Frame implements ActionListener,
ItemListener {
// Reference variables fort the event treatments
private MenuItem m_Save, m_Open;
private MenuItem m_Red, m_Light_Blue, m_Blue, m_Dark_Blue;
private CheckboxMenuItem m_Pink;
FrameMenu (String Title){
super(Title);
initializeMenu();
setSize(300, 200);
addWindowListener(new WindowAdapter () {
System.exit(0);
}
});
setVisible(true);
}
// Search the menu item, which has generated the event
// All possible sources are tested here
public void actionPerformed (ActionEvent event) {
if (event.getSource() == m_Save) {
System.out.println("Activation of m_Save");
} else if (event.getSource() == m_Open) {
System.out.println("Activation of m_Open");
} else if (event.getSource() == m_Red) {
System.out.println("Activation of m_Red");
} else if (event.getSource() == m_Light_Blue) {
System.out.println("Activation of m_Light_Blue");
} else if (event.getSource() == m_Blue) {
System.out.println("Activation of m_Blue");
} else if (event.getSource() == m_Dark_Blue) {
System.out.println("Activation of m_Dark_Blue");
}
}
public void itemStateChanged (ItemEvent event) {
String sel = (event.getStateChange() == ItemEvent.DESELECTED) ?
"SELECTED" : "DESELECTED";
System.out.println("m_Pink " + sel);
}
Page 34
public void initializeMenu () {
MenuBar mMenuBar = new MenuBar ();
setMenuBar (mMenuBar);
Menu mMenu;
// 1. Under menu :
mMenuBar.add(mMenu
mMenu.add(m_Save =
mMenu.add(m_Open =
File menu
= new Menu ("File"));
new MenuItem ("Save"));
new MenuItem ("Open"));
// 2. Under menu : Option menu
mMenuBar.add (mMenu = new Menu ("Option"));
mMenu.add (m_Red = new MenuItem ("Red"));
mMenu.add (m_Pink = new CheckboxMenuItem ("Pink"));
Menu mSubMenu = new Menu ("Blue tone");
mMenu.add(mSubMenu);
mSubMenu.add(m_Light_Blue = new MenuItem ("Light blue"));
mSubMenu.add(m_Blue = new MenuItem ("Blue"));
mSubMenu.add(m_Dark_Blue = new MenuItem ("Dark blue"));
// Register this class for the treatment of all events
m_Save.addActionListener(this);
m_Open.addActionListener(this);
m_Red.addActionListener (this);
m_Light_Blue.addActionListener(this);
m_Blue.addActionListener(this);
m_Dark_Blue.addActionListener (this);
m_Pink.addActionListener(this);
m_Pink.addItemListener (this);
}
}
new FrameMenu ("Menu-Demo");
}
Page 35
5 Applets
5 Les applets
5.1 Introduction
Un applet est un programme Java, qui est imbriqué dans une page Web et qui, par conséquent, est exécuté par un
navigateur Internet (web browser). Un applet est toujours exécuté par l’ordinateur de l’utilisateur, même si ce
dernier a été téléchargé. Cette manière de travailler est essentiellement due aux propriétés suivantes du langage
de programmation Java :

Les programmes Java ne sont pas traduits en des codes exécutables mais en des codes intermédiaires,
qui sont interprétés.

La machine virtuelle, qui interprète le code intermédiaire, existe sur tous les navigateurs internet.
Comme le mentionne le nom, les applets sont en générale des petits programmes, qui n’exécutent qu’une seule
tâche dans une seule page internet. L’intégration des applets dans la page Internet présente les avantages
suivants :

La tâche est exécutée sur la machine, qui utilise directement les résultats. Dans ce cas les résultats ne
doivent pas être renvoyés à l’utilisateur, ce qui permet de réduire les accès réseaux.

L’ordinateur de l’utilisateur est entièrement dédicacé à l’applet. Par conséquent, il peut l’exécuter
beaucoup plus rapidement qu’une partition sur le serveur.

Toutes les possibilités du langage de programmation Java sont à disposition pour programmer les
applets. Ce qui n’est pas le cas pour certains langages de programmation, qui ont été spécialement
développés pour internet.
5.1.1 Les pages HTML
HTML est l’abréviation d’Hyper Text Markup Language. L’exécution d’un applet ne demande que des
connaissances de base du HTML. En réalité, l’activation d’un applet dans une page Internet ne nécessite qu’un
seul Tag.
HTML-Tags für ein Applet
<APPLET code = "Name" width = n height = m>
</APPLET>
HTML est enseigné plus en détail dans le module « Technologie de l’Internet/serveur embarqué ».
5.1.2 Exemple d’applet
Une fenêtre, qui averti contre les attaques de virus informatiques, doit être affichée sur l’écran:
Exemple de code
import java.applet.Applet;
import java.awt.*;
public class DemoForApplet extends Applet {
static private final int xCoordinate[] = {50, 110, 170};
static private final int yCoordinate[] = {95, 15, 95};
static private final int line = 18;
static private final int letter = 8;
Page 36
5 Applets
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillPolygon(xCoordinate ,yCoordinate ,3);
g.setColor(Color.white);
g.setFont (new Font("Helvetica", Font.BOLD, 60));
g.drawString("!", 102, 80);
}
}
g.setColor(Color.black);
g.drawString("W A R N I N G",
8*letter, 7*line);
g.drawString("Possible virus detected", 3*letter, 8*line);
g.drawString("Reboot and run virus",
4*letter, 9*line);
g.drawString("remover software",
6*letter, 10*line);
Instruction
Ce Programme es un applet. Cela est exprimé par :
public class DemoForApplet extends Applet
Les applets peuvent posséder des surfaces graphiques, identiques à celles des Canvas. Pour cela il faut
programmer la méthode « paint(Graphics g) ». Cette méthode est appelée automatiquement par
l’environnement d’exécution du programme, lorsque la surface graphique doit être redessinée (par exemple au
début du programme ou lorsque la taille de la fenêtre est modifiée).
Le paramètre « Graphics g » est un lien à l’environnement graphique. Graphics se limite à la surface de
l’écran, qui a été réservée pour l’applet. L’applet peut se renseigner sur la taille de cette surface à l’aide des
méthodes « getWidth » et « getHeight ».
La classe Graphics est très vaste. Un bref aperçu en a été introduit au chapitre 4.4.1.
Imbrication de l’applet dans un document HTML
Le Tag, qui appelle l’applet, peut être défini de la manière suivante dans le document HTML :
<title>Demo For Applet </title>
<hr>
<applet code = "DemoForApplet.class" width = 200 height = 100>
<hr>
Dans cet exemple, le document HTML s’appelle « example.htlm ».
Exécution du programme
Le document HTML peut être ouvert à l’aide d’un navigateur Internet, qui soutient Java. Dans ce cas le
navigateur doit charger le fichier « example.htlm ». Une autre possibilité est de travailler avec un afficheur
d’applet « appletviewer », qui permet d’afficher l’applet de la manière suivant :
appletviewer DemoForApplet.class
Page 37
5 Applets
Affichage
5.2 Mode de fonctionnement des applets
Comment est ce qu’un applet, qui ne possède pas de programme principale, est démarré ou stoppé ? C’est
l’environnement d’exécution qui démarre l’applet depuis un navigateur Internet ou avec l’afficheur d’applet. La
machine virtuelle appel à des instants appropriés une des quatre méthodes, qui ont été décrites dans le tableau
suivant. Les sous classes de la classe Applet, doivent implémenter ces méthodes en fonction de leurs besoins.
Méthode de la
classe Applet
init()
destroy()
start()
stop()
Description
init initialise l’interface d’utilisateur graphique de l’applet et démarre tous les
Threads
destroy détruit l’interface d’utilisateur graphique et termine l’applet
start est appelé à chaque démarrage de l’applet. Son rôle est de déclencher les actions
d’animation.
Stop interrompt les actions, qui ont été démarrées par start.
La figure suivante montre les différents états de l’applet, qui est exécuté par le navigateur Internet. La méthode
« init » de l’applet est appelée au démarrage (au lieu du constructeur), lorsque le navigateur rencontre la
première fois le Tag contenant l’appel de l’applet. init est responsable de la mis en place de toute l’interface
d’utilisateur graphique de l’applet : comme par exemple les boutons, les barre de défilement et tous les autres
éléments de contrôle. La méthode « start » de l’applet est appelée à chaque réactivation de la page Internet,
qui contient l’applet. start peut par exemple démarrer des animations graphiques, qui ont été momentanément
stoppées.
Page 38
5 Applets
Constructor
init()
destroyApp()
startApp()
startApp()
destroy()
Garbage collection
start()
stopApp()
stop()
destroyApp()
L’environnement d’exécution appel la méthode « paint », lorsque la surface de l’écran réservée à l’applet doit
être redessinée, comme par exemple après start. L’applet retourne alors dans un état passif et attend jusqu’à ce
qu’une des deux actions suivantes ait lieu.

L’applet devient transparent, lorsque l’utilisateur déplace la page Internet dans le navigateur.

Un évènement en relation avec l’interface graphique a lieu, comme par exemple l’appuie d’un bouton ou
de la touche de la sourie.
La méthode « stop » est appelée, lorsque l’applet devient transparent. Les éventuelles animations sont ainsi
stoppées. La méthode start est appelée, lorsque l’applet devient de nouveau visible. Tous les autres
évènements seront traités par les méthodes des interfaces d’observation AWT.
La méthode « destroy » est mise à disposition pour que l’applet puisse libérer ses ressources, lorsque que
l’afficheur d’applet est stoppé ou que le navigateur charge une autre page Internet.
Exemple de code
import java.awt.*;
public class DemoAppletFunctionality extends Applet {
static private final int xCoordinate[] = {50, 110, 170};
static private final int yCoordinate[] = {95, 15, 95};
static private final int line = 18;
static private final int letter = 8;
public void init() {
System.out.println("init");
}
public void start() {
System.out.println("start");
}
System.out.println("paint");
g.setColor(Color.red);
g.fillPolygon(xCoordinate ,yCoordinate ,3);
g.setColor(Color.white);
g.drawString("!", 102, 80);
Page 39
5 Applets
}
g.setColor(Color.black);
g.drawString("W A R N I N G",
8*letter, 7*line);
g.drawString("Possible virus detected", 3*letter, 8*line);
g.drawString("Reboot and run virus",
4*letter, 9*line);
g.drawString("remover software",
6*letter, 10*line);
public void stop() {
System.out.println("stop");
}
}
public void destroy() {
System.out.println("destroy");
}
Affichage après démarrage de l’applet :
init
start
paint
Affichage après désactivation de l’applet :
stop
Affichage après réactivation de l’applet :
start
paint
Affichage après l’arrêt de l’applet :
stop
destroy
5.2.1 Stockage des applets
Un applet, qui est stocké sur un serveur, peut être téléchargé par une autre ordinateur connecté à Internet, à l’aide
du protocole de transfert WWW et de son localisateur universel de ressource (URL). Le localisateur universel du
ressource pour l’exemple de ci-dessus pourrait être de la forme :
https://prof.hti.bfh.ch/fue1/java/example.html
Dans cet exemple, le fichier HTML est stocké dans un répertoire, qui est accessible à travers Internet. Lorsque le
fichier classe de l’applet est disponible dans le même répertoire, son appel s’effectue simplement de la manière
suivante dans le Tag.
<applet code = "DemoForApplet.class" width = 200 height = 100>
Lorsque le fichier classe de l’applet n’est pas disponible dans le même répertoire, son appel doit être spécifié
avec son localisateur universel de ressource.
5.2.2 Sécurité des applet
Des doutes peuvent apparaître avec l’utilisation des applets, qui ont été téléchargés depuis Internet. Les
programmes, qui ont été téléchargés, pourraient par exemple être infecté et endommager le système. Java met à
disposition de nombreux moyens pour éviter ces problèmes. En premier, le code byte de l’application téléchargé
est testé par rapport à sa validité. La machine virtuelle n’exécute pas de programmes, qui ont été falsifiés.
Deuxièmement, la machine virtuelle n’exécute aucune opération, qui pourrait endommager le système. Par
Page 40
5 Applets
conséquent, un applet téléchargé n’est pas en mesure de trouver un mot de passe ou d’effacer le contenu d’un
fichier. Le tableau suivant fournit un aperçu de ces limitations, qui ont été introduites pour les applets.
Opération
Accès aux fichiers locaux
Effacer les fichiers locaux
Exécuter d’autres
programmes
Recherche son propre
nom
Créer une nouvelle
communication ave le
serveur
Créer une communication
avec un autre serveur
Charger des bibliothèques
Java
Appeler exit
Créer des fenêtres Pop-Up
Application
Java


Applet local
dans afficheur
d’applet

Applet local
dans navigateur
Internet



















Applet téléchargé
dans navigateur
Internet


Ce tableau montre qu’un programme Java est un programme complet, qui est en mesure d’exécuter toutes les
tâches demandées par l’ordinateur. Un applet est quelque chose de différent : Il est soumis à un contrôle et des
règles mentionnées ci-dessus. Un applet, qui est exécuté par un afficheur d’applet, peut pratiquement tout faire.
Toutefois, l’exécution de ce dernier par un navigateur limite considérablement ses activités.
L’applet ne peut pas être stoppé dans un navigateur Internet : il se s’arrête que lorsque la page HTML qui
contient son appel et remplacée par une autre. Par conséquent un applet ne contient pas l’instruction exit et ne
possède pas de case d’arrêt. Les applets sont en quelque sorte intégrés à la page Internet. Le fait qu’un applet ne
puisse pas lire à partir d’un fichier peut constituer un désavantage. L’utilisateur peur éliminer cette limitation, en
spécifiant son propre gestionnaire de sécurité. Finalement, la dernière colonne du tableau montre qu’il existe des
limitations supplémentaires pour les applets téléchargés depuis Internet.
5.3 Les fonctions PARAM
Les fonctions PARAM permettent une interaction entre l’applet et la page Internet. PARAM met a disposition une
liste de paramètres dans un document HTML, qui peuvent être lues par l’applet à l’aide de la méthode
« getParameter ». Les paramètres doivent être définies entre les tags <APPLET> et </APPLET> sous la
forme suivante :
HTML-Parameter
<PARAM NAME = "formal" VALUE = "actual">
Name indique que la chaîne de caractère suivante est le nom du paramètre. La paire de parenthèse contient
également une valeur, VALUE, qui est assignée à ce paramètre. VALUE est également un chaîne de caractère,
mais elle peut également être lue comme un valeur entière ou à virgule flottante. Une application possible de
fonctions PARAM est le stockage des prix des produits d’un super marché sur une page Internet. Ces derniers
pourraient être spécifiés de la manière suivante :
<PARAM NAME = "garlic" VALUE = "12">
La méthode getParameter permet d’accéder à ces paramètres de la manière suivante :
unitCosts[i] = Integer.parseInt(getParamter(items[i]));
Dans cet exemple items[i] est une chaîne de caractère comme « garlic ». La méthode getParameter
Page 41
5 Applets
va chercher le paramètre du même nom dans la liste des paramètres et retourner sa valeur (ici la chaîne de
caractère "12").
5.3.1 Exemple d’applet pour convertir des francs suisses en monnaies
étrangères
Il faut développer une petite application, qui converti une somme en francs suisses dans une autre devises. Ce
changement devrait être possible avec les devises suivantes: Dollar américain, Dollar australien, Dollar canadien,
l'Euro européen, du yen japonais et le Rouble russe.
Solution
La figure suivante montre la disposition requise pour l’interface d’utilisateur graphique. La zone de texte
« Input amount (CHF) » (tout en haut) permet d’entrer le montant en francs suisses. La boîte de sélection
« Currency » (deuxième ligne) permet de sélectionner la monnaie, dans laquelle on aimerait convertir. La zone
de texte « Output amount » (troisième rangée) permet d’afficher le résultat de la conversion. Le bouton
« Convert » (en bas) permet de démarrer la conversion et d’afficher le résultat dans le champ texte
« Output amount ». Le bouton « Reset » efface les deux zones de texte.
Input amount (CH)
0
Currency
American Dollar
Output amount
0
Convert
Reset
Code source
import java.applet.*;
import java.awt.*;
public class CurrencyConversion extends Applet implements ActionListener {
// Attribute
private String currency[] = {"American Dollars", "Australia Dollars",
"Canadian Dollars", "European Euro",
"Japanese Yen",
"Russian Rubbles"};
private double conversionRate[] = new double [currency.length];
private TextField inputTextField;
private TextField outputTextField;
private Choice
currencyChoice;
public void init () {
// Read the conversion rates with the PARAM-Functions
for (int i = 0; i < currency.length; i++) {
conversionRate[i] = Double.parseDouble(getParameter(currency[i]));
}
// Set the properties of the application window
setLayout (new GridLayout (4,2));
add(new Label ("Input amount (CHF)"));
inputTextField = new TextField("0");
add(inputTextField);
Page 42
5 Applets
add(new Label ("Conversion currency"));
currencyChoice = new Choice();
currencyChoice.addItem(currency[i]);
}
add(currencyChoice);
add(new Label ("Output amount"));
outputTextField = new TextField("0");
add(outputTextField);
Button button = new Button("Convert");
button.addActionListener(this);
add(button);
}
}
button = new Button("Reset");
button.addActionListener(this);
add(button);
public void actionPerformed (ActionEvent event) {
if ("Convert".equals (event.getActionCommand())) {
// Read the amount and convert it in to a foreign monney
double amount = Double.parseDouble (inputTextField.getText());
double rate
= conversioRate[currencyChoice.getSelectedIndex()];
double output = amount * rate;
outputTextField.setText(Double.toString(output));
}
else {
// Clear all text fields
inputTextField.setText("0");
outputTextField.setText("0");
}
}
Instruction
Les propriétés de l’applet sont définies dans la méthode init de l’applet. Les différents éléments de contrôle
sont générés et insérés dans l’applet « CurrencyConversion ». Des plus, les boutons « Convert » et
« Reset » sont définis comme sources ainsi que CurrencyConversion comme observateur d’évènements du
type action (ActionEvent).
L’applet CurrencyConversion doit, en tant qu’observateur d’évènements ActionEvent, implémenter la
méthode actionPerformed de l’interface ActionListener. Cette méthode recherche le texte du bouton,
qui a été appuyé par l’utilisateur, et réalise la tâche requise.
La méthode getParameter a été utilisée de la manière suivante, pour la transmission des paramètres entre
l’applet et la page Internet :
conversionRate[i] = Double.parseDouble(getParameter(currency[i]));
}
Dans l’exemple ci-dessus, le paramètre currency[i] est une chaîne de caractères, qui correspond au nom de
la marchandise (comme par exemple "American Dollars"). La méthode getParameter recherche le
nom de ce paramètre dans la page Internet et retourne sa valeur, qui est également une chaîne de caractères
(comme par exemple "0.80414").
Page 43
5 Applets
Imbrication de l’applet CurrencyConversion dans un document HTML
Le nom de la classe et les fonctions PARAM peuvent être définis dans le document HTML de la manière
suivante :
<title>
Demo for Currency Conversion
</title>
<APPLET code="CurrencyConversion.class" width = 300 height = 150>
<PARAM NAME="American Dollars" VALUE="0.80414">
<PARAM NAME="Australia Dollars" VALUE="1.15197">
<PARAM NAME="Canadian Dollars" VALUE="1.09099">
<PARAM NAME="European Euro"
VALUE="0.66428">
<PARAM NAME="Japanese Yen"
VALUE="87.8662">
<PARAM NAME="Russian Rubbles"
VALUE="23.3402">
</APPLET>
Affichage
5.4 Les sons et les images
Les sons et les images peuvent être intégrés dans Java de façon simple et efficace.
5.4.1 Les sons
Le paquet « applet » continent l’interface « AudioClip », qui possède les méthodes : play, stop et
loop. La méthode « getAudioClip » de l’applet retourne un objet, qui implémente cet interface et qui
permet de jouer les ficher sons de la manière suivante :
Audioclip: Déclaration et exécution
AudioClip name;
name = getAudioClip(getCodeBase(), Filename);
name.play();
Page 44
5 Applets
La méthode getCodeBase retourne le localisateur universel de ressource (URL) de l’applet. Actuellement seul
les fichiers sons du type « .au » peuvent être exécutés par les applets.
Le fichier « ouch.au » peut être exécuté de la manière suivante :
AudioClip ouch;
ouch = getAudioClip(getCodeBase(), "ouch.au");
ouch.play();
// Or the shorter version with anonymous getAudioClip
play(getCodeBase(), "ouch.au");
5.4.2 Les images
Les images sont des fichiers, qui contiennent des données sous forme de pixel. Ces derniers peuvent être
téléchargés ou généré en temps réels par un ordinateur graphique ou une caméra vidéo.
Java possède pour les images une interface identique à celui des clips audio. Par conséquent, pour afficher une
image il faut suivre le même schéma que celui pour jouer les fichiers sons. Dans ce cas, il suffit de remplacer
AudioClip par « Image ». Une image peut être obtenue de la manière suivante :
Image me;
me = getImage(getCodeBase(), "bfh.gif");
La classe „Toolkit“ est une super classe abstraite pour toutes les implémentations possibles de la boite à outils
AWT. Toolkit ou Toolbox (traduction anglaise « pour boite à outils ») est un terme, qui est issu du traitement de
signal électronique. Il se réfère généralement à une collection de bibliothèques, de classes et d’interfaces, qui
permettent de simplifier l'écriture de programmes informatiques. La méthode « getDefaultToolkit() »
appel la boite à outils standard et implémente ainsi la classe abstraite Toolkit. La méthode „getImage“ livre
une image, qui a été sauvée sous format « gif ».
L’image peut être dessinée sur l’écran à l’aide de la méthode « drawImage » de la classe « Graphics » de la
manière suivante :
Afficher une image
g.drawImage (Image Filename, int x, int y, ImageObserver Observer);
Les coordonnées x et y définissent le coin en haut à gauche de la fenêtre, où l’image doit être affichée.
L’observateur est en général le navigateur Internet. Dans ce cas, il faut transmettre le quatrième paramètre this
à drawImage. Exemple d’appel de drawImage :
g.drawImage(me, 0, 0, this);
Exemple de code
import java.awt.*;
public class ImageDemo extends Applet implements ItemListener {
Image image, imageRohr, imageKaufmann, imageFirouzi;
public void init() {
// Layout
setLayout(null);
// Generate the Choice control element
Choice myChoice;
myChoice = new Choice();
Page 45
5 Applets
// Java supports TIFF, GIF, JPEG, BMP and PNG formats
myChoice.addItem("Rohr.jpg");
myChoice.addItem("Kaufmann.png");
myChoice.addItem("Firouzi.gif");
myChoice.addItemListener(this);
myChoice.select(0);
// Fix the size of Choice and add it into the container
myChoice.setBounds(0, 0, 300, 20);
add(myChoice);
/* Read the image files */
imageRohr
= Toolkit.getDefaultToolkit().getImage("Rohr.jpg");
imageKaufmann = Toolkit.getDefaultToolkit().getImage("Kaufmann.png");
imageFirouzi = Toolkit.getDefaultToolkit().getImage("Firouzi.gif");
// Choose the default image
image = imageRohr;
}
setSize(300, 180);
public void itemStateChanged (ItemEvent event) {
System.out.println(event.getItem().toString());
if (event.getItem().equals("Beerli.jpg")) {
image = imageRohr;
}
else if (event.getItem().equals("Kaufmann.png")) {
image = imageKaufmann;
}
else {
image = imageFirouzi;
}
repaint();
}
}
g.drawImage(image, 0, 20, this);
}
Instruction
Les propriétés de l'applet sont spécifiées dans la méthode init. Cette méthode désactive d'abord le gestionnaire
de positionnement par défaut de l’applet. Par la suite, la liste de choix « myChoice » est créée et introduite dans
le haut de l'applet. myCoice et de imageDemo sont définis respectivement comme source et observateur
d’évènement du type choix (ItemEvent). Finalement, les images sont lues à partir de leur fichier avec la
méthode getImage dans les différents formats possibles.
En tant qu’observateur d’évènement du type choix, la classe ImageDemo doit implémenter la méthode
itemStateChanged de l’interface ItemListener. Cette méthode recherche le texte du point sélectionné
par l’utilisateur et fixe l’image à afficher.
La méthode paint affiche l’image par défaut sur l’écran.
Page 46
5 Applets
Affichage
Page 47
6 Les Thread
6 Les Thread
Les threads permettent d’exécuter plusieurs choses à la fois (ou presque à la fois). Un bon exemple pour cela est
la lecture des données à travers Internet, qui peut être réalisé avec un thread. Ainsi le programme principal est en
mesure de réagir aux évènements de l’interface utilisateur. Même si le processus de lecture est bloqué, par
manque de données.
Les applets ne sont pas des objets statiques. Toutefois, seuls les threads apportent du mouvement dans les
applets. En tant qu’élément actif, les threads peuvent faire en sorte que les figures apprennent à marcher. Par
exemple, dans l’exemple de ci-dessus un texte est amené à danser. Pour cela il réafficher de façon périodique.
Chaque lettre peut se déplacer en hauteur et sa couleur varie également.
En Java, les threads peuvent être définis de deux manières :

Comme sous classe de « Thread »

Par implémentation de l’interface « Runnable »
Les classes, qui contiennent les propriétés principales d’un thread, peuvent être définies comme sous classes de
Thread. Au contraire, les interfaces d’utilisateur, qui sont en générale définies comme des sous classes AWT,
doivent implémenter l’interface Runnable. Cela provient du fait que Java ne supporte pas l’héritage multiple.
Les méthodes principales de Thread sont start, run et sleep. La méthode start peut être appelée, une
fois que le thread a été généré. L’appel de start génère l’appel de run. Le système d’exploitation introduit
ainsi le thread dans la liste d’attente des threads à exécuter. Après un certain temps, ce dernier aura sa chance
auprès du processeur et sera exécuté de façon indépendante.
La méthode run est la routine principale du thread et doit par conséquence être sur écrite. Elle est composée en
générale d’une boucle, qui est exécutée tant que certaines conditions sont remplies. La méthode sleep est une
méthode statique, qui permet de réaliser les pauses en milliseconde.
Exemple de code
import java.awt.*;
public class DancingText extends Frame {
DancingText (String title) {
super (title);
add(new DancingTextCanvas());
setSize(300, 200);
setVisible(true);
System.exit(0);
}
});
setVisible(true);
}
}
public static void main (String argv[]) {
new DancingText("DancingText");
}
Page 48
6 Les Thread
class DancingTextCanvas extends Canvas implements Runnable {
private Thread thread;
private boolean stopThread = false;
private static final Color [] Palette = {
Color.black, Color.blue, Color.cyan, Color.darkGray,
Color.gray, Color.green, Color.magenta, Color.orange,
Color.pink, Color.red, Color.white, Color.yellow
};
DancingTextCanvas() {
System.out.println("DancingTextCanvas");
thread = new Thread (this);
thread.start();
}
public void run () {
for (;;){
repaint();
try {
Thread.sleep (200);
}
catch (InterruptedException e) {}
}
}
System.out.println("paint");
char text[] = {'D','a','n','c','i','n','g',' ','T','e','x','t'};
int height = 40;
int width = 20;
}
for (int i = 0; i < text.length; i++) {
int start = (int)Math.round (20 * Math.random ());
g.setColor (Palette[start % Palette.length]);
g.drawChars (text, i, 1, i * width, height + start);
}
public void finalize () {
System.out.println("stop");
thread = null;
}
}Instruction
La fenêtre principale contient un Canvas, qui implémente un Thread. Cela est exprimé avec :
public class DancingTextCanvas extends Canvas implements Runnable
Dans l’exemple de ci-dessus, DancingTextCanvas se comporte comme un thread, en implémentant
l’interface Runnable. DancingTextCanvas n’est cependant pas un thread et il doit, par conséquent,
générer une instance de Thread. C’est la raison pour laquelle, qu’une instance de Thread est générée dans le
contructeur de DancingTextCanvas. Ce thread est relié ensuite au Canvas à l’aide de son propre
constructeur :
thread = new Thread (this);
La méthode run du thread peu ainsi fonction comme un thread indépendant et il peut accéder à tous les
Page 49
6 Les Thread
composants de DancingTextCanvas.
Du fait que Java ne connaisse pas l’héritage multiple, la technique du rattachement de la méthode run à
DancingTexT est nécessaire pour toutes les classes, qui découlent d’une super classe. Cette technique de
transmission de tâches à d’autres classes est également qualifiée de « Délégation ».
La méthode run de l’exemple de ci-dessus contient un boucle while, dans laquelle la méthode repaint est
appelée à des intervalles de temps réguliers. Le contenu de la fenêtre est ainsi réaffiché périodiquement.
Esquisse du déroulement
Arrêt du thread
Démarrage du thread dans start
DancingText
thread
Axe du temps
Les threads DancingText et myThread sont représentés à l’aide de traits tillés dans la figure de ci-dessus.
Au démarrage de l’application principale, le constructeur de la sous fenêtre (DancingTextCanvas) génère
une instance de Thread et le démarre. Ce qui déclanche l’animation avec le texte dansant.
Affichage
Page 50
7 Les exceptions
7 Les exceptions
7.1 Introduction
Un programme, qui n’est pas en mesure de réagir aux exceptions, peut se bloquer. Les programmes, qui ne sont
pas en mesure de réagir aux exceptions, ne sont pas acceptables dans des applications distribuées à travers les
réseaux.
Le traitement des exceptions à l’aide d’éléments de programmation standard ne s’est pas imposé. Par exemple,
des instructions if aurait pu être envisagé pour traiter ces erreurs. Dans ce cas, chaque routine aurait du fournir
une information supplémentaire par rapport à l’état de son fonctionnement. Les imbrications supplémentaires,
nécessaires aux traitements des erreurs en rapport avec les appels de ces sous routines, aurait détériorer la vue
d’ensemble du programme.
La première stratégie pour le traitement des exceptions a été introduite avec le concept setjmp / longjmp
d’ANSI-C. A cause d’un certain nombre de déficits, cette stratégie a été remplacée par un traitement d’exception
structurée dans C++.
Le traitement des erreurs a été introduit depuis le début dans Java. Ce dernier permet de traiter les erreurs de
façon différenciée. Le concept de base de ce traitement est basé sur le schéma suivant :

Essayer avec try

Attraper avec catch

Générer avec throw
import java.lang.ArithmeticException;
public class Test {
for (int i = -3; i < 3; i++) {
try {
System.out.println(1 / i);
} catch (java.lang.ArithmeticException e) {
System.err.println(e);
}
}
}
}
Affichage
0
0
-1
java.lang.ArithmeticException: / by zero
1
0
La division par zéro a été pêchée par la structure try-catch. L’exception n’a pas arrêté l’exécution du
programme. Ce dernier a continué de fonctionner de façon contrôlée.
Page 51
7 Les exceptions
7.2 Principe de fonctionnement
Le mécanisme du traitement des exceptions est basé sur des redémarrages de programme. try enregistre l’état
momentané de l’environnement du programme. Ce qui inclut le contenu de la pile et des registres internes ; mais
dans aucun cas le contenu des fichiers et les connexions avec les autres ordinateurs. Ensuite l’ordinateur exécute
le code, qui a été défini dans le bloque try { ... }. Si une exception est générée de façon explicit ou
implicite lors du traitement de ce morceau de code, l’ordinateur recherchera la routine catch correspondant à
cette exception. Cette recherche s’effectue également dans les routines appelantes par déroulement de la pile. Les
points suivants sont à remarquer :

Le retour n’est possible que dans des méthodes, qui se situent sur le chemin throw et qui n’ont pas été
terminées. Car try/catch ne peut que dérouler la pile et reconstituer les contenus des registres.

Les actions du programme ne peuvent pas être annulées, comme par exemple l’effacement d’un fichier,
le trie d’une commande ou la mise à feu d’une fusée.
7.2.1 Une implémentation possible du traitement d’exception
Stack
main
Retour en arrière à la
suite d’une exception
Chaîne des appels de sous-routines
7.3 L’avantage des traitements des exceptions de Java
Le mécanisme du traitement des exceptions de Java permet de définir des programmes, sans devoir se soucier
d’insérer systématiquement des structures de code pour l’identification des éventuelles erreurs. De plus il existe
une distinction claire entre les structures de code conventionnelles (if étant prévu pour le contrôle du
déroulement du programme) et de code pour le traitement des erreurs (try-catch étant prévu pour le traitement
des erreurs).
Un avantage supplémentaire du langage de programmation, concernant le traitement des exceptions, se situe dans
la sécurité. Contrairement à C et C++, tous les objets, qui ont été générés, sont automatiquement éliminé par le
« Garbage Collection ».
Les programmes Java doivent être capables de gérer toutes les situations exceptionnelles. Les blocages de
programme ne sont pas acceptables dans le cadre des applications Internet. Un programme, qui n’est capable de
fonctionner que dans « des atmosphères sympathiques », n’est pas suffisant. Par conséquent, tous les
programmes Java doivent être en mesure de traiter les exceptions. Un « atterrissage mou » est ainsi assuré
lorsque apparaissent des erreurs de programmation ou d’utilisateur.
7.4 Les classes et les exceptions
En java, tous les types d’exceptions ont été reproduits dans une hiérarchie de classes, dont la racine est
« java.lang ». Dans cette structure, les différents types d’exception ont été modélisés à l’aide de classe.
Les programmes Java peuvent se rattacher à cette classification des exceptions. Le traitement des exceptions est
alors réalisé à l’aide de classe. L’exemple suivant contient la déclaration de la classe de base « Exception1 ».
Page 52
7 Les exceptions
La classe « Exception2 » y figure comme un cas spécial de Exception1. Le rôle de la méthode « demo »
est de générer les différents types d’exception.
import java.lang.Exception;
class Exception1 extends Exception {
Exception1 (String text) {
super(text);
}
}
class Exception2 extends Exception1 {
Exception2 (String text) {
super(text);
}
}
public class ExceptionDemo {
void demo (int i) throws Exception1, Exception2, Exception {
if (i == 1) {
throw new Exception1 ("Extra 1");
(b)
} else if (i == 2) {
throw new Exception2 ("Extra 2");
(a)
} else if (i == 3) {
throw new Exception ("Extra 3");
}
}
}
public static void main (String [] args){
ExceptionDemo e = new ExceptionDemo ();
for(int i = 1; i <= 4; i++){
try {
e.demo (i);
} catch (Exception2 ex) {
System.out.println (ex);
} catch (Exception1 ex) {
} catch (Exception ex) {
} finally {
System.out.println("Final handling " + i);
}
}
}
Affichage
1.
2.
3.
4.
5.
6.
7.
Exception1: Extra 1
Final handling 1
Exception2: Extra 2
Final handling 2
java.lang.Exception: Extra 3
Final handling 3
Final handling 4
Page 53
7 Les exceptions
Instruction
Dans l’exemple de ci-dessus, les instructions du corps de la boucle for sont exécutées 3 fois, malgré les
exceptions générées par le programme. Cela n’est possible que par l’interception de ces derniers à l’aide des
ramifications catch.
La première ligne de la console montre que l’exception Exception1 est intercepté correctement par la
ramification catch du point (b). La deuxième ligne montre le traitement finale le l’exception avec finally.
Cette instruction permet de rassembler le code en commun des différentes ramifications catch. Cependant, les
instructions de catch sont toujours exécutées, même en absence d’exceptions.
La troisième ligne montre le traitement de la deuxième exception. Exception2 est un cas spécial de
Exception1. Exception2 peut ainsi être traitée comme Execption1. La ligne 4 contient le traitement
final de Exception2.
L’échange des bloques (a) et (b) fournirait la situation la suivante :
catch (Exception1 ex)
System.out.println
}
catch (Exception2 ex)
System.out.println
}
{
(ex);
(b)
{
(ex);
(a)
Cette modification n’est pas supportée par le compilateur Java, car le traitement d’Exception1 masque ainsi
celui d’Exception2. Le premier traitement adéquat est choisi pour traiter l’exception.
La cinquième ligne montre que finally ne traite pas les exceptions, mais qu’il ne sert qu’au traitement final
des exceptions. Lorsque l’on veut traiter une somme d’exceptions, on intercepte ces derniers à l’aide de la super
classe Exception. Les ne seraient ainsi pas traitées de façons différenciées. La ligne 6 montre le traitement
final de cette exception.
L’affichage de la ligne 7 a lieu, même s’il n’y a pas eu d’exceptions.
Page 54
Java contient le paquet « java.io » pour les entrées et les sorties. Du fait que Java est un langage de
programmation prévu pour Internet, il doit pouvoir fonctionner avec différents sources d’entrées et de sorties
comme par exemple : les fichiers locaux, le clavier et les données fournies par Internet. Les classes abstraites
« java.io.InputStream » et « java.io.OutputStream » sont mises à dispositions respectivement
pour la lecture et l’écriture des données. Ces classes contiennent la déclaration de toutes les méthodes, qui sont
nécessaires pour les entrées et les sorties élémentaires. Toutefois, les instances ne peuvent être générées qu’à
partir de leurs sous classes, comme par exemple la classe « java.io.FileInputStream ».
Les caractères sont représentés dans Java à l’aide du format unicode. En revanche, les fichiers ou les flux de
données Internet sont toujours codé en format ASCII. Par conséquent, un pont a été construit entre les deux
mondes dans Java. De plus à partir de Java 1.1, les nouvelles classes Reader et Writer, qui sont orientées
caractères, sont à disposition en supplément des anciennes classes, qui sont orientées byte.
8.1 Les entrées en Java
Le schéma suivant montre les différents chemins, qui sont mis à disposition pour les entrées en Java.
P
r
o
g
r
a
m
m
Bytes
InputStream: Bytes
Reader: char
InputStreamReader
Internet
Daten
DataInput: Daten
L’interface InputStream permet de lire les données en format ASCII, alors que l’interface Reader permet de
lire ces dernières en format unicode. La classe InputStreamReader constitue un pont entre les deux mondes.
Finalement, l’interface DataInput permet de lire les données en format binaire.
8.1.1 Les entrées orientés bytes
La classe (abstraite) de base pour les entrées est « InputStream ». Cette dernière ne contient que des
méthodes destinées à la lecture séquentielle des bytes ou des bloques de bytes. Il n’existe pas de méthode pour
changer le format des données.
Les méthodes les plus importantes de la classe InputStream sont les suivantes :
void close();
int read();
int read(
byte[] cbuf,
int off,
int len);
Fermeture du flux de byte et libération des ressources
Lecture d’un byte. Le résultat est retourné sous forme de valeur entière, qui est
comprise entre 0 et 255 (hexadécimal de 0x00 à 0xff).
La valeur -1 signale la fin du fichier.
read lit len bytes à partir du flux d’entrée. Ces derniers sont stockés dans le
tampon cbuf à partir de la position off.
La valeur -1 signale la fin du fichier.
La figure suivante montre la hiérarchie des classes de InputStream. Pour les applications de lecture, il faut
créer une instance d’une de ces sous classes, qui travaillera avec un flux de données concret.
Page 55
java.io.InputStream
java.io.ByteArrayInputStream
java.io.FileInputStream
java.io.ObjectInputStream
java.io.PipedInputStream
java.io.SequenceInputStream
java.io.StringBufferInputStream
javax.sound.sampled.AudioInputStream
java.io.FilterInputStream
java.io.BufferedInputStream
java.io.DataInputStream
java.io.LineNumberInputStream
java.io.PuschbackInputStream
java.security.DigestInputStream
java.util.zip.ChekedInputStream
javas.swing.ProgressMonitorInputStream
java.util.zip.InflaterInputStream
java.util.zip.GZIPInputStream
java.util.zip.ZipInputStream
java.util.zip.jarInputStream
Le tableau suivant continent la description des constructeurs des sous classes les plus importantes
de InputStream :
ByteArrayInputStream(byte[] buf)
FileInputStream(File file)
PipedInputStream()
StringBufferInputStream(String s)
La classe « ByteArrayInputStream » permet
d’accéder à un tableau contenant des bytes, comme si ce
dernier était un flux d’entrée.
Cette classe fournit un flux, avec lequel le contenu d’un
fichier peut être lu.
Les classes « PipedInputStream » et
« PipedOutputStream » permettent d’échanger les
données entre deux threads. Pour cela il faut enchaîner les
exemplaires de ces classes.
La classe « StringBufferInputStream » permet
accéder à une chaîne de caractères, comme si ce dernier
était un flux d’entrée.
Les listes des paramètres des constructeurs de ci-dessus montrent les différents flux d’entrées, qui peuvent être
utilisés pour la création des instances de ces sous classes. Par exemple, le nom d’un fichier peut être utilisé pour
la création d’un objet de la classe « FileInputStream » :
FileInputStream fis = new FileInputStream ("FileName");
8.1.2 Les entrées orientés caractères
JDK recommande les classes « Reader » pour la lecture de texte. Dans ce cas, les bytes du flux d’entrée sont
convertis dans des caractères locaux du type unicode. La vitesse de la lecture peut être également améliorée avec
les tampons. Par conséquent, les méthodes de la classe « BufferedReader » sont particulièrement
intéressantes :
Page 56
void close();
int read();
int read(
char[] cbuf,
int off,
int len);
String readLine();
boolean ready();
Fermeture du flux
Lecture d’un caractère.
Le résultat est une valeur entière entre 0 et 65535 (0x0000 et 0xffff).
La valeur -1 représente la fin du fichier.
Cette méthode lit len caractères du flux d’entrée et dépose ces dernier dans le
tampon cbuf à partir du caractère d’indexe off.
La méthode retourne le nombre de caractères lus.
La valeur -1 représente la fin du fichier.
Lecture d’une ligne.
La valeur null représente la fin du fichier.
Permet de définir si le flux d’entrée est prêt pour la lecture ou pas.
Cela est le cas lorsque le tampon est vide ou si le flux de caractère d’entrée est
prêt
La figure suivante montre la hiérarchie des classes Reader :
java.io.Reader
java.io.CharArrayReader
java.io.PipedReader
java.io.StringReader
java.io.BufferedReader
java.io.LineNumberReader
java.io.FilterReader
java.io.PushbackReader
java.io.InputStreamReader
java.io.FileReader
Le tableau suivant contient la description des constructeurs des classes les plus importante, qui découle de
Reader :
CharArrayReader(char[] buf)
La classe CharArrayReader permet de lire à partir d’un
tableau char comme à partir d’un flux de données.
PipedReader()
Cette classe est équivalent Reader de
PipedInputStream
La classe StringReader permet de lire à partir d’un
String comme à partir d’un flux de données.
La classe BufferedReader est un tampon d’entrée pour
les flux de caractères uni codes. Cette classe travail reçoit les
données à partir d’un objet Reader.
La classe InputStreamReader permet de connecter
les classes Reader, orientées caractères, aux classes
InputStream, orientées bytes.
Cette classe fournit un flux de données, avec lequel le
contenu d’un fichier peut être lu. A cet égard, les bytes sont
convertis automatiquement en caractères uni codes.
StringReader(String s)
BufferedReader(Reader in)
InputStreamReader(InputStream in)
FileReader(String fileName)
Exemple de code
L’extrait de code suivant montre la création d’un objet de la classe Reader, destiné à la lecture de fichiers.
Remarque : ce morceau de code peut générer des exceptions du type « java.io.IOException ».
// Generation in the standard form
FileInputStream fis = new FileInputStream("name");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
Page 57
/* or in the imbricate standard form
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream("name")));
*/
/* or directly with a FileReader
BufferedReader br = new BufferedReader (
new FileReader("name"));
*/
String s;
while((s = br.readLine()) != null){
// Treat the line s
}
Instruction
Les instances « fis », « isr » et « br » sont générées dans l’exemple de ci-dessus. fis est un objet de la
classe « FileInputStream », qui utilise le fichier « name » comme flux d’entrée. fis fournit un flux, avec
lequel il est possible de lire à partir name. isr est un objet de la classe « InputStreamReader », qui utilise
fis comme flux d’entrée. isr permet de convertir les bytes d’entrée en caractères unicode. br est un objet de
la classe « BufferedReader », qui utilise isr comme flux d’entrée. br permet de stocker les données dans
un tampon intermédiaire. Les opérations de lecture peuvent ainsi extraire les données à partir de ce tampon, ce
qui augmente la vitesse d’exécution du code.
L’imbrication des instances de ci-dessus permet de générer un flux de données, dont la source est le fichier name.
Ce flux possède tous les attributs et les méthodes de la classe BufferedReader (comme par exemple :
readLine). Ce qui permet de lire le contenu du fichier ligne par ligne.
8.1.3 L’entrée standard
UNIX et Windows prévoient une entrée standard pour les applications. Cette dernière est souvent caractérisée
avec stdin. Les programmes Java peuvent accéder à ce flux d’entrée, du type InputStream, avec l’attribut
statique « System.in ».
Exemple de code
La lecture à partir du clavier peut être réalisé à l’aide d’un objet « InputStreamReader », qui possède
System.in comme flux d’entrées. La lecture est en générale plus efficace avec un tampon intermédiaire.
L’exemple suivant montre une structure imbriquée pour la lecture à partir du clavier. Cette dernière est
recommandée à cause de la complexité de la lecture à partir du clavier.
import java.io.*;
public class MyReadLine{
static BufferedReader b = null;
public static String readln() throws java.io.IOException {
if(b == null){
b = new BufferedReader(
new InputStreamReader(System.in));
}
return b.readLine();
}
Page 58
}
public static void main (String[] args)
throws java.io.IOException{
String s;
while((s = MyReadLine.readln()) != null){
System.out.println(">" + s + "<");
}
}
8.2 Les sorties en Java
Le schéma suivant montre les différents chemins, qui sont mis à disposition pour les sorties en Java.
P
r
o
g
r
a
m
m
Bytes
OutputStream: Bytes
Writer: char
OutputStreamWriter
Internet
Daten
DataOutput: Daten
L’interface OutputStream permet d’écrire les données en format ASCII, alors que l’interface Writer permet
d’écrire ces dernières en format unicode. La classe OutputStreamReader constitue un pont entre les deux
mondes. Finalement, l’interface DataOutput permet d’écrire les données en format binaire.
8.2.1 Les sorties avec les flux orientés bytes
La classe de base pour les sorties Java est « java.io.OutputStream ». Cette classe abstraite ne réalise que
des transferts de données. Par conséquent, elle ne permet pas de transformer le format des données.
« PrintStream » est la sous classe la plus important de OutputStream. PrintStream contient les
méthodes « print » et « println » pour afficher les types de données élémentaire ou des objets. Cette classe
est particulièrement utile pour afficher les données sous forme texte sur la console. La classe « PrintWriter »
peut être utilisée à la place de PrintStream, lorsque le codage standard des caractères est insuffisant. Les
deux classes contiennent les méthodes suivantes :
void close();
void write(int c);
int write (
char[] cbuf,
int off,
int len);
void flush();
void print(xx d);
void println(xx d);
Fermeture du flux et libération des ressources.
Affiche un caractère, dont le codage est donné par les 16 bits de poids plus faible
de c. Les 16 bits de poids plus fort sont ignorés.
Ecrit les len caractère du tableau (array) cbuf à partir de l’index off.
flush force le système à terminer l’écriture des bytes dans le flux de sortie.
flush est recommandé, lorsque les données, qui ont été sauvées dans un
fichier, sont perdues.
xx est un type de donnée élémentaire, une chaîne de caractère ou un objet. Les
types de données élémentaires sont convertis en un texte avant d’être transmis à
la méthode. Un objet est converti en un texte, à l’aide de la méthode
« String.valueOf(Object) ».
Comme « print(xx d) ». Mais dans ce cas on passe à la ligne suivante.
La figure suivante montre la hiérarchie des classes OutputStream :
Page 59
java.io.OutputStream
java.io.ByteArrayOutputStream
java.io.FileOutputStream
java.io.ObjektOutputStream
java.io.PipedOutputStream
java.io.FilterOutputStream
java.io.BufferedOutputStream
java.io.DataOutputStream
java.security.DigestOutputStream
java.util.zip.CheckedOutputStream
java.io.PrintStream
java.rmi.server.LogStream
java.util.zip.DeflaterOutputStream
java.util.zip.GZIPOutputStream
java.util.zip.ZipOutputStream
java.util.jar.JarOutputStream
Le tableau suivant contient la description des constructeurs des classes les plus importantes, qui découlent de
OutputStream.
ByteArrayOutputStream()
FileOutputStream(File file)
PipedOutputStream()
La classe ByteArrayOutputStream permet d’accéder à un
tableau composé d’éléments bytes, de la même manière qu’à un flux
de données.
Cette classe fournit un flux de données, avec lequel il est possible
d’écrire dans un fichier.
Deux threads peuvent échanger leurs données avec les classes
« PipedInputStream » et « PipedOutputStream ». Pour cela
il faut enchaîner les exemplaires de ces classes.
8.2.2 Les sorties avec les flux orientés caractères
La figure suivante montre la hiérarchie des classes Writer :
java.io.Writer
java.io.BufferedWriter
java.io.CharArrayWriter
java.io.FilterWriter
java.io.PipedWriter
java.io.PrintWriter
java.io.StringWriter
java.io.OutputStreamWriter
java.io.FileWriter
Le tableau suivant contient la description des constructeurs des classes les plus importante, qui découle de
Writer :
Page 60
BufferedWriter(Writer out)
CharArrayWriter()
PipedWriter()
StringWriter()
OutputStreamWriter(OutputStream out)
FileWriter(String fileName)
La classe « BufferedWriter » est un tampon de
sortie destiné aux caractères unicode. Elle est toujours
combinée avec un autre objet Writer, qui permet
d’écrit dans le fichier.
La classe « CharArrayWriter » permet d’écrire
dans un tableau composé d’éléments char, comme si
ce dernier était un flux de sortie.
La classe « PipedWriter » est l’équivalent Writer
de « PipedOutputStream ».
La classe « StringWriter » permet d’écrire dans
une chaîne de caractères, comme si cette dernière était
un flux de données de sortie.
OutputStreamWriter est la classe de base pour
les classe « Writer », qui traitent les flux de données
de sortie « OutputStreams ».
La classe « FileWriter » met à disposition un flux
de sortie, avec lequel des caractères uni codes peuvent
être écrits dans un fichier.
8.2.3 La sortie standard
UNIX et Windows prévoient une sortie standard pour les applications. Cette dernière est souvent caractérisée
avec « stdout ». Les programmes Java peuvent accéder à ce flux de sortie, de type PrintStream, avec
l’attribut statique « System.out ». Pour les message d’erreurs, il est recommandé d’utiliser la sortie
« sdterr », qui est accessible dans Java avec « System.err ». En effet la déviation
java Program > FileName
dévie uniquement la sortie standard stdout sur le fichier en question. Par conséquent, cette dernière n’affect
pas la sortie stderr.
8.3 Exemple d’application
Ce chapitre décrit des situations typiques, qui peuvent être rencontrées dans des applications qui traitent les
fichiers. Ces derniers sont résolus avec les moyens mis à disposition par la bibliothèque java.io.
8.3.1 Traitement des données orienté byte
Le nom d’un fichier doit être lu à partir de l’entrée standard System.in. Il faut ensuite ouvrir le fichier en
question, afin de lire et d’afficher son contenu de façon byte.
Principe
D’abord il faut lire le nom du fichier. Après il faut essayer d’ouvrir le fichier en question. Pour cela il faut traiter
l’exception « java.io.FileNotFoundException », parce que le fichier n’est pas forcément disponible.
Finalement le contenu du fichier peut être traité à l’aide d’une boucle de la manière suivante :
while (!End of the file(inputFile)) {
Read the Byte as int;
Write the Byte;
}
Chaque byte doit être lu sous forme entière, afin de pouvoir traiter la valeur de fin de fichier (EOF = -1). Cela
est nécessaire, car dans Java un byte peut avoir les valeurs 0 jusqu’à 255. Ce qui ne permet pas de coder la valeur
de fin de fichier. Le code doit également traiter toutes les exception du type « java.io.IOException », qui
pourraient être générées à la lecture et à la fermeture du fichier.
Le programme affiche toutes les demande à travers le canal System.err. Ce qui permet d’utiliser ce
Page 61
programme pour copier le contenu d’un fichier dans un autre. Pour cela il suffit de dévier la sortie System.out
de la manière suivante :
java ReadFileBytes > DestinationFile
Dans ce cas, le programme demande à l’utilisateur d’introduire le nom du fichier source. Le contenu de ce
dernier sera copier dans le fichier « DestinationFile ».
Exemple de code
import java.io.*;
public class ReadFileBytes {
public static void main (String args[]) {
// Read the file name
System.err.print("File name?: ");
String Filename = null;
try {
Filename = MyReadLine.readln();
} catch (IOException e) {
return;
}
System.err.println("File name " + Filename);
// Open the file.
// Be careful, the given file could not exist!
FileInputStream f = null;
try {
f = new FileInputStream(Filename);
} catch (FileNotFoundException e) {
System.err.println("File " + Filename + " has not been found!");
return;
}
}
}
// Read the file contains
int ch;
try {
while ((ch = f.read()) != -1) {
System.out.write(ch);
}
f.close();
return;
}
8.3.2 Traitement des données orienté bloque
Il faut transférer le contenu d’un fichier dans un autre fichier de façon binaire. Toutefois, il faut faire attention à
ce que les deux fichiers soient distincts. Car l’ouverture d’un fichier en écriture efface son contenu. De plus,
l’utilisateur doit pouvoir confirmer, s’il veut vraiment sur écrire un fichier déjà existant. Pour des raison de
sécurité, tous les exceptions, qui peuvent être générés durant les opérations de lecture et d’écriture, doivent être
attrapés.
Principe
Dans cet exemple il faut utiliser respectivement des objets « FileInputStream » et
« FileOutputStream ». Le contenu des fichiers peut être copié ainsi de façon binaire. De plus, le traitement
du fichier en bloque est beaucoup plus efficace. L’utilisateur doit pouvoir introduire les nom des fichiers source
Page 62
et destination à l’aide de la ligne de commande. Dans la plupart des systèmes, le contenu du fichier est perdu
lorsque ce dernier est copié dans le même fichier. Afin d’éliminer ce problème, il faut compare les noms des
fichiers source et destination. Certains systèmes d’exploitation ne distinguent pas les majuscules des minuscules.
Java permet de comparer les chaînes de caractères en ignorant cela.
La classe « File » permet de contrôler si un fichier destination existe ou pas. Si ce dernier existe, le programme
doit demander à l’utilisateur s’il veut vraiment le sur écrire. De plus, cela empêche l’écriture automatique dans un
fichier, lorsque l’utilisateur confond les arguments source et destination.
Après cette longue préparation, le programme peut commencer avec le transfert de données à l’aide d’une boucle
read-write.
Exemple de code
import java.io.*;
public class TreatFileBlock {
final public int BUFSIZE = 80;
public void copy (String source, String destination) {
FileInputStream input
= null;
FileOutputStream output = null;
if(source.equalsIgnoreCase(destination)) {
System.err.println("Error: file will be copy in to himself");
// Windows needs ignore case
return;
}
File file = new File (destination);
if(file.exists()) {
System.out.print("File " + destination +
" exists. Over write? (J/N)");
System.out.flush();
try {
char ch = (char)System.in.read();
if(Character.toUpperCase(ch) != 'J') {
return; // Break in case of doubt
}
} catch(IOException e) {
return;
}
}
try {
input = new FileInputStream(source);
} catch(FileNotFoundException e) {
System.err.println("Source : File " + source +
" does not exist");
}
try {
output = new FileOutputStream(destination);
} catch(FileNotFoundException e) {
try {
input.close();
} catch(IOException e1) {
System.err.println("Error : can not close the file " +
destination);
return;
}
System.err.println("Error : can not open the file " + source);
return;
}
Page 63
}
}
int nbytes = -1;
byte b[] = new byte[BUFSIZE];
try {
while((nbytes = input.read(b, 0, BUFSIZE)) != -1) {
output.write(b, 0, BUFSIZE);
}
} catch(IOException e) {
System.err.println("Error while copying");
return;
}
public static void main(String[] args) {
if(args.length != 2) {
System.err.println("Call java TreatFileBlock. source
destination");
System.exit(1);
}
TreatFileBlock d = new TreatFileBlock ();
d.copy(args[0], args[1]);
}
8.3.3 Traitement des données en format Internet
Ce chapitre traite le format des données Internet. Les plus importantes routines, destinées à la lecture et à la
l’écriture de données en format Internet, y sont traitées. Attention : l’exemple de ce chapitre ne peut pas servir
pour la lecture et l’écriture en format texte.
Principe
La classe « DataInputStream » implémente l’interface « DataInput », pour la lecture de données avec
modification de format. Par conséquent, le fichiers doivent contenir des données dans le format Internet. Ce qui
permet d’encharger également les données avec des programme, qui ont été définies avec un autre langage de
programmation (par exemple C), pourvu que les fichiers possèdent des données en format Internet.
Exemple de code
import java.io.*;
public class IODemo {
// Writing the binary data into the file xx
void testOutput() {
try {
DataOutputStream out = new DataOutputStream(
new FileOutputStream("xx"));
out.writeBoolean (true);
out.writeByte
(1);
out.writeChar
('a');
out.writeDouble (1.0);
out.writeFloat
(1.0f);
out.writeInt
(1000);
out.writeLong
(2000l); // not 20001 but 2000l
out.writeShort
(300);
out.writeBytes
("writeBytes");
}
}
Page 64
// Writing the binary data into the file xx with the data type name
void testOutputText() {
try {
DataOutputStream out = new DataOutputStream(
new FileOutputStream("xx"));
out.writeBytes ("Boolean") ; out.writeBoolean (true);
out.writeBytes ("Byte")
; out.writeByte
(1);
out.writeBytes ("Char")
; out.writeChar
('a');
out.writeBytes ("Double") ; out.writeDouble (1.0);
out.writeBytes ("Float")
; out.writeFloat
(1.0f);
out.writeBytes ("Int")
; out.writeInt
(0x12345678 );
out.writeBytes ("Long")
; out.writeLong
(2000l);
out.writeBytes ("Short")
; out.writeShort
(300);
}
}
// Read the xx file and print its contents on the screen
void testInput () {
try {
DataInputStream in = new DataInputStream(
new FileInputStream("xx"));
System.out.println (in.readBoolean());
System.out.println (in.readByte());
System.out.println (in.readChar());
System.out.println (in.readDouble());
System.out.println (in.readFloat());
System.out.println (in.readInt());
System.out.println (in.readLong());
System.out.println (in.readShort());
byte [] Bytes = new byte [100];
int ibytes = in.read(Bytes, 0, Bytes.length -1);
System.out.println(ibytes + ">" +
new String (Bytes, 0, ibytes -1) + "<");
}
}
if (args.length == 0) {
System.err.println ("Call : java IODemo (read|bin|text)");
System.exit(1);
}
IODemo iodemo = new IODemo ();
if (args[0].equalsIgnoreCase ("bin"))
iodemo.testOutput ();
if (args[0].equalsIgnoreCase ("text"))
iodemo.testOutputText ();
if (args[0].equalsIgnoreCase ("read"))
iodemo.testInput ();
}
}
Page 65
Indexe
Indexe
A
Abstract Windows Toolkit ..... 4
ActionEvent........ 24, 33, 44
ActionListener ...... 25, 44
actionPerformed .... 25, 44
add............................... 5, 8, 14
addActionListener ..... 24
addAdjustmentListener
.......................................... 31
addItem ............................. 26
addItemListener .... 27, 28
addxxListerner ............ 17
AdjustmentEvent .......... 31
AdjustmentListener ... 33
adjustmentValueChange
d ....................................... 33
afficheur d’applet ................. 37
applet .................................... 36
Applet ................................. 4
Appletviewer ................. 37
AudioClip ........................ 46
AWT ....................................... 4
B
barre de défilement ............... 31
barre de menu ....................... 33
BorderLayout ................... 8
BorderLayout.CENTER .. 9
BorderLayout.EAST ....... 9
BorderLayout.NORTH ..... 9
BorderLayout.SOUTH ..... 9
BorderLayout.WEST ....... 9
bouton radio.......................... 28
BufferedReader ...... 56, 57
BufferedWriter ............ 60
Button ............................... 24
C
Canvas ........................... 6, 22
CardLayout .................. 8, 14
case à cocher......................... 28
catch ............................ 50, 51
Checkbox ....................... 7, 28
CheckboxGroup ............... 28
CheckboxMenuItem ........ 34
Choice ........................... 6, 26
code intermédiaire ................ 36
Color .................................. 22
Component .......................... 5
Container ...................... 4, 5
contrôleur d’évènement ........ 18
D
DataInput ........................ 54
DataOutput ...................... 54
destroy ............................. 39
drawImage ........................ 46
drawLine ........................... 22
drawOval ........................... 22
drawRect ........................... 22
drawString ...................... 22
E
élément de contrôle ...... 4, 6, 16
enregistrement de l’observateur
.......................................... 17
entrée orienté byte ................ 54
entrée orienté caractère ......... 56
environnement d’exécution .. 22
étiquette ................................ 29
évènement............................. 17
évènement de bas niveau ...... 19
évènement de niveau
sémantique ........................ 19
évènements du type ajustement
.......................................... 32
Event Handler ....................... 18
EventObject.................... 17
exception .............................. 50
Exception ........................ 53
F
FileInputStream ... 55, 57,
61
FileNotFoundException
.......................................... 60
FileOutputStream .. 59, 61
FileReader ...................... 56
FileWriter ...................... 60
fillOval ........................... 22
fillRect ........................... 22
finally ............................. 53
first(Container) ........ 14
FlowLayout .................... 8, 9
FlowLayout.CENTER ....... 9
FlowLayout.LEADING ..... 9
FlowLayout.LEFT ............ 9
FlowLayout.RIGHT .......... 9
FlowLayout.TRAILING... 9
format ASCII ........................ 54
format unicode...................... 54
Frame .................................... 4
G
Garbage Collection ............... 51
gestionnaire de position ...... 4, 7
getActionCommand .. 24, 34
getAudioClip ................. 46
getCodeBase.................... 46
getHeight ........................ 37
getItem ............................. 26
getParameter ................. 41
Page 66
getSource .................. 24, 34
getText ............................. 29
getWidth ........................... 37
Graphics ............... 22, 37, 46
GridBagConstraints ... 11
GridBagConstraints.RE
MAINDER ......................... 13
GridBagLayout ........... 8, 11
gridheight ...................... 13
GridLayout ...................... 10
gridwidth ........................ 13
GUI ......................................... 4
H
hiérarchie des adaptateurs..... 21
hiérarchie des classes
InputStream................ 55
hiérarchie des classes
OutputStream ............. 58
hiérarchie des classes Reader
.......................................... 56
hiérarchie des classes Writer
.......................................... 59
hiérarchie des évènements .... 17
hiérarchie des interfaces
d’observateur .................... 20
I
Image .................................. 46
imbrication des gestionnaire de
position ............................. 15
init .............................. 38, 44
InputStream.............. 54, 57
InputStreamReader .... 54,
56, 57
interface d’observation ......... 17
interface d’utilisateur
graphique ............................ 4
ItemEvent .................. 26, 28
ItemListener ........... 27, 29
itemStateChanged .. 27, 29
J
java.awt ............................. 4
java.io ............................. 54
java.io.InputStream. 54
java.io.OutputStream
.......................................... 54
JDK ........................................ 4
L
Label .................................. 29
last(Container) .......... 14
layout manager ............. 4, 7, 15
les adaptateurs ...................... 20
Listener ................................. 17
Indexe
localisateur universel de
ressource ........................... 40
longjmp ............................. 50
loop .................................... 46
M
machine virtuelle ............ 36, 40
main ...................................... 5
Menu .................................... 33
MenuBar ............................... 33
MenuItem ........................... 34
méthode principale ................. 5
MouseAdapter ................. 20
mousePressed ................. 20
multi-cast .............................. 17
N
navigateur Internet................ 36
next(Container) .......... 14
O
observateur d’évènement ..... 17,
18, 20, 21
OutputStream ................. 58
OutputStreamReader ... 54
OutputStreamWriter ... 60
P
page Web .............................. 36
paint .................. 5, 22, 37, 39
Panel .................................... 4
PARAM .................................. 41
play .................................... 46
print .................................. 58
println ............................. 58
PrintStream.............. 58, 60
PrintWriter.................... 58
protocole de transfert WWW 40
R
Reader ......................... 54, 56
readLine ........................... 56
remove ................................. 6
repaint ............................. 22
rePaint ............................... 5
run....................................... 47
Runnable ........................... 47
runtime ................................. 22
S
Scrollbar .................... 7, 31
select ............................... 26
setColor ........................... 22
setConstraints ............ 13
setFont ............................. 22
setjmp ............................... 50
setLayout .................... 6, 10
setMenuBar ...................... 33
setSize ............................... 5
setText ............................. 29
setVisible ........................ 5
setxxListerner ............ 17
single-cast ............................. 17
sleep .................................. 47
sortie orienté byte ................. 58
sortie orienté caractère.......... 59
source d’évènement . 17, 18, 19,
21
start ............................ 38, 47
stop .............................. 39, 46
Page 67
streams .................................. 54
Swing .................................... 4
System.err ...................... 60
System.exit(0) ...... 18, 21
System.in ........................ 57
System.out ...................... 60
T
TextArea ....................... 7, 30
TextComponent ........... 7, 29
TextEvent ........................ 30
TextField .................... 7, 29
TextListener ........... 30, 31
textValueChanged .. 30, 31
Thread ............................... 47
throw ............................ 50, 51
try................................. 50, 51
type d’évènement ................. 19
U
URL ...................................... 40
W
web browser ......................... 36
Window ................................. 4
WindowAdapter ......... 21, 26
windowClosing ... 18, 21, 26
WindowEvent.................... 18
WindowListener ............ 18
Writer ............................... 54
X
xxListener ...................... 17

Introduction à la programmation Java - BFH

Transcription

Documents pareils

Vérification et installation de JAVA

Si l`Applet Java ne démarre pas :

Offres d`emploi de Jobingé - Forum Entreprises JAVA DEVELOPER

procédure d`installation de java jdk

Alice Champagne Ardenne FORUM JOBS 2004

Ingénieur d`étude et développement JAVA J2EE H/F

Aide à l`installation de GeTax sur Ubuntu

Stage Ingénieur Informatique Java (HF) Conception et

Entreprise : ANTYAS, est un acteur de Sophia Antipolis dans le