U.B.S. - I.U.T.

de Vannes
Département Informatique
Cours2 AP/Java – LP-DLIS

Concepts plus avancés

en Java
et
Construction des
Interfaces graphiques
J-F. Kamp

Octobre 2022

1
 Plan du cours2 de java

• Paquetage (p. 3)
• Héritage simple (p. 12)
• Héritage et visibilité (p. 17)
• Héritage et constructeurs (p. 19)
• Classe abstraite (p. 22)
• Redéfinition (p. 28)
• Interface (p. 31)
• Objets graphiques (p. 36)
• Réaction aux événements (p. 49)
• I/O Fichiers (p. 60)

2
Paquetage

3
 Définition

Un paquetage en Java permet de regrouper dans

une même famille, des classes qui collaborent
entre elles de manière plus étroite ou œuvrent
pour la même cause.

Toutes les classes de l’API Java sont regroupées

en paquetages :

• java.lang : classes fondamentales du langage

• java.util : autres classes utiles (Vector, ...)
• java.io : classes gérant les entrées/sorties
• java.net : classes gérant l’interconnexion réseau
• java.awt : classes de l’interface graphique
• etc.

Conséquence :
Deux classes Java peuvent avoir le même nom si
elles appartiennent à des paquetages différents.
Exemple : java.util.List et java.awt.List

4
 Mes propres paquetages

On peut soi-même définir ses propres

paquetages avec l’instruction « package » en
tête de la classe. L’instruction « package »
précise le nom du sous-répertoire qui contiendra
toutes les classes compilées qui appartiennent au
même paquetage.

Exemple :
package pac1;

class Duree {
...
}

/TP_CD

/ws /class
/src
/pac1
/pac1
Duree.class
Duree.java
5
 Paquetage et importations

Règle 1 : sans précision d’appartenance à un

paquetage, une classe appartient au paquetage
« default ».

Règle 2 : toutes les classes appartenant à un

même paquetage se connaissent.

•Conséquence 1 : à l’intérieur d’un même

paquetage, l’importation n’est pas nécessaire.

•Conséquence 2 : si une classe fait appel à une

classe d’un autre paquetage, il faut l’importer
(exception pour les classes du paquetage
java.lang où l’importation est inutile).

6
 Exemples
package pac1;

class Duree {
...
}

package pac1;

class Plage {
...
}

package pac2;

// importation de Plage indispensable !!

import pac1.Plage;

class CD {
...
}

Remarque : l’importation de la classe « String »

n’est pas nécessaire car elle appartient au
paquetage « java.lang ».
7
 CLASSPATH et importations

La variable système « CLASSPATH » donne

les chemins de recherche des classes inconnues.

.../src > echo $CLASSPATH

.../src > .:../class:etc...

/TP_CD

/ws /class
/src
/pac1
/pac2 /pac1
Plage.class
CD.java Plage.java

L’importation « import pac1.Plage; » dans la

classe CD est un complément d’information par
rapport au CLASSPATH pour retrouver les
classes inconnues (compilation & exécution).

8
 Paquetage et visibilité

Rappel : visibilités publique et privée

• membre déclaré « private » d’une classe =

membre accessible qu’à l’intérieur même de
la classe
• membre déclaré « public » d’une classe =
membre accessible de partout (ouvert au
« monde »)

Et si aucune précision de visibilité sur le

membre ?

Le membre a par défaut une visibilité de type

« paquetage » = membre accessible uniquement
par les classes du même paquetage.

9
 Paquetage et visibilité

Les classes elle-même ont deux types de

visibilité : publique et privée (par défaut)

package pac1;

public class MaClasse {

private int var1;

public void meth1() {…}

}

Cette classe a une visibilité publique : elle est

utilisable par toutes les classes, qu’elles
appartiennent ou non au paquetage pac1.

10
 Paquetage et visibilité

package pac1;

class MaClasse {

private int var1;

public void meth1() {…}

}

Cette classe n’a pas de visibilité publique elle a

donc une visibilité privée (par défaut) : elle est
utilisable uniquement par toutes les classes
appartenant au même paquetage pac1.

11
Héritage en Java

12
 Héritage : 1ère notion

Définition : si une classe A hérite d’une classe

B, chaque objet instance de la classe A aura
accès aux champs d’instance de la classe A et de
la classe B (à nuancer ultérieurement !).

Exemple (notation UML) :

Personne

-nom : String

+getNom() : String
+setNom(String unNom)

Etudiant Enseignant

-annee : int -statut : String

+getAnnee () : int +getStatut () : String

+setAnnee(int uneAnnee) +setStatut(String unStatut)

13
 Héritage : 1ère notion

En Java :

public class Personne {

private String nom;

// Accesseur
public String getNom() {…}

// Modificateur
public void setNom( String unNom ) {…}
}

public class Etudiant extends Personne {

private int annee;

// Accesseur
public int getAnnee() {…}

// Modificateur
public void setAnnee( int uneAnnee ) {…}
}
14
 Héritage : 1ère notion

Etudiant var1;
Personne var2;

var1 = new Etudiant();

var1.setNom ( " Dupont " );
// setNom(…) est une méthode de la classe Personne
// ET de la classe Etudiant !!

var2 = new Personne();

var2.setAnnee ( 2 );
!! FAUX : var2 n’est pas une instance de la classe
Etudiant

La classe Etudiant est un sous-type de la classe

Personne : un Etudiant « est une sorte de »
Personne (l’inverse n’est pas vrai). Personne est
facteur commun à toutes ses sous-classes.

En langage orienté objet, on dira que :

•Etudiant hérite de Personne
•Personne est la super-classe de Etudiant
•Etudiant est une sous-classe de Personne
•Etudiant est une spécialisation de Personne
•Personne est une généralisation de Etudiant 15
 Héritage : 1ère notion

Toute l’API de Java est organisée en une

arborescence d’héritage entre classes (à ne pas
confondre avec l’organisation en paquetage !).

Object

Component

Button Container

Window Panel

La classe « Object » se trouve au sommet de

l’arbre => toute classe Java hérite au minimum
de la classe « Object » (méthodes clone(),
equals(…) etc.)
16
 Héritage et visibilité

Définition : si une classe A hérite d’une classe

B, chaque objet instance de la classe A aura
accès aux champs d’instance de la classe A et de
la classe B.

Ce n’est pas aussi simple :

• les constructeurs sont chaînés (pas hérités)

• les champs avec la visibilité private ne
s’héritent pas

Il existe un nouveau type de visibilité protected

pour les champs d’une classe. Elle est
équivalente à la visibilité paquetage (visibilité
par défaut) mais en plus le champ peut être
hérité par toutes les classes (y compris celles qui
n’appartiennent pas au paquetage !).

17
 Accès et héritage : les différentes visibilités en
Java

18
 Héritage et constructeurs

public class Personne {

private String nom;

// Constructeur
public Personne (String unNom) {…}
...
}

public class Etudiant extends Personne {

private int annee;

// Constructeur
public Etudiant (int uneAnnee) {…}
...
}

…
Etudiant var1;
var1 = new Etudiant ( 2 );
// Qu’en est-il de l’initialisation de l’attribut « nom » de la
// classe Personne ?
// remarque : var1.Personne ("Dupont") NON !!
19
 Héritage et constructeurs

Pour invoquer le constructeur de la super-classe,

il faut utiliser le mot-clé super(...).

public class Etudiant extends Personne {

private int annee;

// Constructeur
public Etudiant (int uneAnnee, String unNom) {

// Appel du constructeur
// Personne(String unNom) de la super-
// classe.
super ( unNom );
this.annee = uneAnnee;
}
...
}

20
 Héritage et constructeurs

!! Restriction lors de l’utilisation de « super(…) »

pour invoquer un constructeur de la super-classe :

• super(…) s’utilise exclusivement à l’intérieur

des constructeurs d’une sous-classe,
• super(…) doit apparaître comme toute première
instruction dans le constructeur d’une sous-
classe.

Si aucun super(…) n’est prévu dans un

constructeur de la sous-classe, que se passe-t-il ?

=> Java insère lui-même l’instruction « super() »

au début du constructeur ce qui signifie : appel du
constructeur sans arguments de la super-classe.

21
 Classe abstraite

• Une classe abstraite n’a pas d’instance, elle n’a

pas de sens concrètement pour l’application.

• Son rôle est de regrouper (factoriser) des

attributs et fonctionnalités communes à des
sous-classes (qui elles sont souvent concrètes !).

Exemple :

public abstract class Figure {

protected Point orig;

protected String nom;

protected void deplacer ( Point newP ) {

this.orig = new Point ( newP );
}
}

22
 Classe abstraite

Figure (abstract)

# orig : Point
# nom : String

# deplacer() : void

Rectangle
Cercle
- rayon : double -longueur : double
-largeur : double

Seuls des objets de type Polygone

Cercle, Rectangle et - points : Vector
Polygone peuvent être
créés. Ils hériteront tous
des champs « orig »,
« nom » et « deplacer() »
de la classe abstraite.
23
 Méthode abstraite
• Une méthode abstraite factorise une
fonctionnalité commune à toutes les sous-
classes.

• Une méthode abstraite impose seulement une

signature et laisse une sous-classe préciser le
code de la classe.

Exemple :
public abstract class Figure {
protected Point orig;
protected String nom;

public Figure ( Point unPoint, String unNom ) {

this.orig = unPoint;
this.nom = new String ( unNom );
}

protected void deplacer ( Point newP ) {

this.orig = new Point ( newP );
}

public abstract double perimetre();

} 24
 Méthode abstraite
Figure (abstract)

# orig : Point
# nom : String

# deplacer() : void
# perimetre() : double

Rectangle
Cercle - longueur : double
- rayon: double - largeur : double

+ perimetre(): double + perimetre(): double

Les classes Cercle etc.

héritent des champs orig, Polygone
nom, deplacer(). - points: Vector
Ces classes doivent
+ perimetre(): double
redéfinir la méthode
« perimetre() » et donner
le code de la méthode.
25
 Méthode abstraite

public class Cercle extends Figure {

// Attributs
private double rayon;

// Constructeur
public Cercle ( double unRayon, Point orig,
String unNom ) {

super ( orig, unNom );

this.rayon = unRayon;
}

// Implémentation de « perimetre() »
public double perimetre () {
double tmp;

tmp = 2 * Math.PI * this.rayon;

return tmp;
}
}

26
 Classe et méthode abstraite

Règles à propos des classes et méthodes abstraites :

• une classe abstraite ne peut jamais s’instancier,

• toute classe qui possède une méthode abstraite

doit être déclarée elle-même comme abstraite,

• toute sous-classe d’une classe abstraite ne peut

être instanciée que si elle redéfinit toutes les
méthodes abstraites de la classe abstraite sinon
elle est elle-même abstraite,

• les méthodes déclarées « static », « private » et

« final » (« final » = interdiction d’hériter) ne
peuvent être abstraites.

27
 Redéfinition d’une méthode héritée

Rectangle
# longueur : double
# largeur : double

+perimetre(): double

Carre

+perimetre(): double

Lorsqu’une classe (Carre) définit une méthode

d’instance en respectant la même signature (nom,
paramètres, type retour) qu’une méthode de sa
super-classe, cette méthode redéfinit la méthode de
la super-classe (Rectangle).

Note : la méthode redéfinie ne peut jamais

restreindre la visibilité définie dans la super-classe.
28
 Redéfinition d’une méthode héritée
public class Rectangle {
protected double longueur;
protected double largeur;

public Rectangle ( double lngr, double larg ) {

this.longueur = lngr;
this.largeur = larg;
}

public double perimetre ( ) {

return ((2*this.largeur)+(2*this.longueur));
}
}
public class Carre extends Rectangle {

public Carre ( double côté ) {

super ( côté, côté );
}

// Méthode qui masque « perimetre » de la

// classe Rectangle
public double perimetre ( ) {
return (4*this.largeur);
}
} 29
 Redéfinition n’est pas surcharge
Paramètres Paramètres
identiques différents

Noms identiques
Types retour Redéfinition Surcharge
identiques

Noms identiques
Types retour Erreur Surcharge
différents

public class Carre extends Rectangle {

public Carre ( double côté ) {

super ( côté, côté );
}

// Surcharge dans la même classe

public Carre ( ) { super ( 5, 5 ); }

// Redéfinition de la super-classe
public double perimetre ( ) {
return (4*this.largeur);
}
}
30
Interface

31
 Définition

Une interface (mot-clé « interface ») en Java est

une classe abstraite particulière : il n’y a pas
d’attributs et toutes les méthodes sont abstraites.

Conséquences :

• Une interface ne s’instancie pas. Elle s’hérite

(s’implémente) avec le mot-clé « implements ».

• Toutes les méthodes d’une interface sont

forcément abstraites (mot-clé « abstract ») et
publiques (private et protected interdits).

• Il n’y a pas d’attributs, seules les constantes

(mots-clé « static final ») sont autorisées.

• Une classe peut implémenter plusieurs

interfaces : c’est l’héritage multiple.

32
 Exemple

Figure (abstract) Plein (interface)

# orig : Point
# nom : String + getCouleur() : Color
+ getEpaiss() : double
# deplacer() : void
# perimetre() : double

Rectangle RectanglePlein
-longueur : double
-largeur : double -couleur : Color
-épaissTrait : double
+perimetre(): double
+getCouleur() : Color
+getEpaiss() : double

« RectanglePlein » hérite de la classe

« Rectangle » et de l’interface « Plein ». Elle doit
re-définir « getCouleur() » et « getEpaiss() ».

33
 Exemple
public interface Plein {
public abstract Color getCouleur();
public abstract double getEpaiss();
}
public class RectanglePlein extends Rectangle
implements Plein {
// Attributs
private Color couleur;
private double épaissTrait;

// Constructeur
public RectanglePlein ( Color col, double épaiss,
double long, double larg, Point orig, String nom ) {
super ( long, larg, orig, nom );
this.couleur = col;
this.épaissTrait = épaiss;
}
// Implémentation des méthodes de l’interface
public Color getCouleur() {
return this.couleur;
}
public double getEpaiss() {
return this.épaissTrait;
}
}
34
 Interface ou classe abstraite ?

Si une classe doit hériter de plusieurs « super-

classes », il y aura forcément 1 ou +sieurs
interfaces et une seule classe mère.

Si une méthode et son implémentation et/ou des

attributs sont facteurs communs à plusieurs sous-
classes, alors seule la classe (abstraite) est
possible.

Si une interface définit beaucoup de méthodes il

sera fastidieux de donner une implémentation
dans chacune des sous-classes.

Il est facile d’implémenter une nouvelle méthode

dans une classe abstraite ça ne perturbe pas le
code des sous-classe. Ce n’est pas le cas pour une
interface (c’est l’inverse !).

Une bonne utilisation d’une interface, c’est d’y

regrouper toutes les constantes d’une application.
35
Interface graphique :
objets graphiques

36
 Introduction

Une interface graphique, c’est :

Un système de fenêtrage qui permet une

interaction plus riche entre l’application et
l’utilisateur (GUI : Graphical User Interface).

Une interface graphique (IG) permet :

• de spécifier la taille, la position des fenêtres,

• d’afficher, rentrer des données textuelles,

• de présenter les informations dans des listes, des

menus,

• d’afficher des images, de les modifier,

• une interaction avec la souris, le clavier, une

surface tactile,

• une présentation riche agréable et ergonomique

de l’information (texte, image, son, vidéo).
37
 Introduction

Construire une application Java avec une interface

graphique, c’est découpler au maximum les
classes de l’IG de celles qui gèrent les données.
IG1 IHM IG2

IG3 IG4

Moteur

C1 Datas C2

38
 Paquetage java.awt

Depuis ses premières versions, Java a inclus

dans son API un paquetage connu sous le nom
de « java.awt » (Abstract Windowing Toolkit).

La bibliothèque « awt » contient de nombreuses

classes utiles pour construire des applications
graphiques.

Ces éléments graphiques (souvent visuels) sont

aussi appelés « Widgets » dans le vocabulaire
des informaticiens.
Exemples :
• bouton de commande
• case à cocher
• liste de sélection
• menu déroulant
• barre de défilement
• zone de saisie de texte
• etc.

39
 Paquetage java.awt

Les classes du paquetage sont organisées suivant

une arborescence d’héritage entre classes :

Object

Component (abstract)

Container Button Label TextComponent

Window Panel
TextArea TextField

Frame Dialog

MenuComponent (abstract)

MenuBar MenuItem

Menu
40
 Paquetage javax.swing

Depuis Java2, une nouvelle bibliothèque graphique

est apparue « javax.swing ».

Avantages :
• choix « swing » / « awt »
• bibliothèque + fournie
• widgets plus « design »
• meilleur portabilité du graphique
• certains composants « swing » héritent de
« java.awt » (JFrame sous-classe Frame,
JDialog sous-classe Dialog)
• mécanisme de réaction aux événements reste
le même (valable pour « awt » et « swing »)

L’utilisation de « swing » est préférable.

41
 Classe javax.swing.JFrame

• Les interfaces graphiques sont présentées à

l’utilisateur par l’intermédiaire de fenêtres.

• Java possède une classe awt.Window, mais en

pratique on utilise ses sous-classes comme
awt.Frame et swing.JFrame
(extends awt.Frame).

• Le widget JFrame est le composant de base (de

type awt.Container !) dans lequel on vient
ajouter tous les autres composants graphiques.

42
 Classe JFrame

Il y a 2 façons d’exploiter le type JFrame : par

utilisation ou par héritage.
// Version utilisation du type JFrame

import javax.swing.*;
public class Cadre {
// Attribut
private JFrame demo;
// Constructeur
public Cadre ( String titre ) {
demo = new JFrame(titre);
demo.setSize(100,100);
demo.setVisible(true);
}
}
// Version héritage du type JFrame

import javax.swing.*;
public class Cadre extends JFrame {
// Constructeur
public Cadre ( String titre ) {
super(titre);
this.setSize(100,100);
this.setVisible(true);
}
}
43
 Les classes « Container »

Object

Component

Container

Window Panel JComponent (abstract)

Frame Dialog JPanel JLabel

JFrame JDialog

Les objets de type « Container » sont les seuls à

pouvoir contenir d’autres objets graphiques.

=> construction de l’interface graphique par

emboîtement de « poupées russes ».

44
 Les classes « Container »
Comment disposer les objets graphiques à
l’intérieur des objets « Container » ?
Soit en précisant les coordonnées et la taille de
chaque objet graphique :
setBounds (int x, int y, int
width, int height);
classe « Component ».
!! Mais c’est fastidieux et figé (cf. re-
dimensionnement de la fenêtre).

Soit en utilisant un gestionnaire de placement

(LayoutManager) => avantages :

• placement automatique dans des zones pré-

définies,
• adaptation automatique en cas de re-
dimensionnement.

Tout composant graphique de type Container

dispose de la méthode
setLayout(LayoutManager mgr)
45
 Gestionnaires de placement
Trois principaux gestionnaires (mais il y en a
d’autres !) :
1. BorderLayout

NORTH

W E
E CENTER A
S S
T T

SOUTH

…
// Définition du gestionnaire de placement « BorderLayout »
// pour l’objet « Container ».

setLayout ( new BorderLayout() );

add( unComposant, BorderLayout.NORTH );
add( unComposant, BorderLayout.SOUTH );
add( unComposant, BorderLayout.EAST );
add( unComposant, BorderLayout.WEST );
add( unComposant, BorderLayout.CENTER );
46
 Gestionnaires de placement

2. FlowLayout

Composant1 Composant2 Composant3

Composant4

…
// Définition du gestionnaire de placement « FlowLayout »
// pour l’objet « Container ».
// Disposition des composants de gauche à droite.

setLayout ( new FlowLayout() );

add( composant1 );
add( composant2 );
add( composant3 );
add( composant4 );

47
 Gestionnaires de placement

3. GridLayout

Composant1 Composant2 Composant3

Composant4 Composant5

…
// Définition du gestionnaire de placement « GridLayout »
// pour l’objet « Container ».
// Disposition des composants de gauche à droite et de haut
// en bas.

setLayout ( new GridLayout(2, 3) );

add( composant1 );
add( composant2 );
add( composant3 );
add( composant4 );
add( composant5 );

48
 Interface graphique :
réaction aux événements

49
 Programmation réactive

L’utilisateur doit pouvoir intervenir sur l’interface

graphique (IG) par l’intermédiaire de la souris et
du clavier (principalement).

Exemples :
• cliquer sur un bouton,

• sélectionner un élément dans une liste,

• fermer une fenêtre,

• écrire du texte,

• dessiner des formes,

• cocher une option,

• etc.

50
 Notion d’événement

L’utilisateur agit sur des éléments de l’interface

graphique (widgets) => des événements sont
générés et éventuellement capturés par
l’application.

Types d’événements :

• enfoncement ou relâchement d’un bouton de la

souris,

• enfoncement ou relâchement d’une touche du

clavier,

• irruption ou sortie du pointeur de souris dans le

champs d’une fenêtre,

• déplacement ou re-dimensionnement ou dés-

occultation d’une fenêtre.

51
 Notion d’événement

Un événement est un objet instance d’une classe

du paquetage « java.awt.event ».

Exemples :
• la classe « KeyEvent » définit les événements
qui concernent les touches du clavier,

• la classe « MouseEvent » définit les événements

qui concernent les mouvements et clics de
souris.

Dès qu’un widget subit une action de l’utilisateur,

un objet « xxxEvent » (MouseEvent par ex.) est
automatiquement instancié et envoyé à tous les
objets qui sont à l’écoute de « xxxEvent ».

52
 Notion d’événement

!! Important :

1. Tous les événements ne peuvent pas être

capturés par tous les widgets.
=> voir la liste des écouteurs d’événements
dans la classe du widget (ou une super-classe)

2. Si on veut qu’un widget réagisse à un

événement autorisé (cf. ci-dessus), il faut lui
attacher explicitement un objet écouteur de ce
type d’événement (xxxListener) sinon il ne se
passe rien !
=> méthode « addxxxListener(xxxListener o) »

Exemple : récupérer l’événement « clic souris »

sur le bouton « monB » de la fenêtre « demo ».

53
 Notion d’événement
public class Comptage extends JFrame {
// Attribut
private JButton monB;
// Constructeur
public Comptage() {
this.super ("demo");
this.setSize(250, 110);
this.monB = new JButton ("Cliquez ici");
this.add(monB);
this.capturerClic();
this.setVisible(true);
}
private void capturerClic() {
// Je veux capturer « MouseEvent » sur
// « monB ». L’objet écouteur
// (MouseListener) existe dans la classe
// « Component » (super-classe de la
// classe « JButton »). La méthode
// addMouseListener(…) attache l’objet
// écouteur au widget JButton (monB).
monB.addMouseListener ( new
Ecouteur(this.monB) );
}
...
}
54
 Notion d’événement

Qu’en est-il du paramètre « new

Ecouteur(monB) » de la méthode
« addMouseListener(MouseListener ml) » ?

« new Ecouteur(monB) » est l’objet qui va

recevoir l’événement « MouseEvent » et
permettre une réaction par rapport à cet
événement.

!! Le type « MouseListener » est une interface !!

=> le paramètre « ml » doit être l’instance d’une

classe qui implémente l’interface MouseListener.

55
 Notion de réaction

Exemple précédent : récupérer l’événement « clic

souris » sur le bouton « monB » de la fenêtre
« demo » ET en réaction à ce clic écrire le
message « Vous avez cliqué X fois ».

=> Il faut écrire le code de la classe « Ecouteur »

qui implémente « MouseListener ».

56
 Notion de réaction
public class Ecouteur implements MouseListener {
// Attributs
private int compteur = 0;
private JButton leBouton;

// Constructeur
public Ecouteur ( JButton unBouton ) {
this.leBouton = unBouton;
}

// Implémentation de TOUTES les méthodes

// de l’interface = méthodes de réaction au
// clic.
// Seule la méthode « mouseClicked(…) » est
// exploitée pour la réaction.
public void mouseClicked ( MouseEvent e ) {
this.compteur++;
leBouton.setLabel( "Vous avez cliqué " +
compteur + " fois" );
}
// Aucune réaction dans les autres.
public void mousePressed(MouseEvent e) {;}
public void mouseReleased(MouseEvent e) {;}
public void mouseEntered(MouseEvent e) {;}
public void mouseExited(MouseEvent e) {;}
} 57
 Marche à suivre
Je veux créer une réaction à un événement
agissant sur un widget :
1. Quelles sont les événements que peut capturer
mon widget ? Réponse : voir tableau p.60.
Supposons l’événement « TrucEvent ».

2. Créer un objet à l’écoute de cet événement

(objetEcouteur). Cet objet est obligatoirement
une instance de la classe qui implémente toutes
les méthodes de l’interface qui porte le nom
« TrucListener ».

3. Attacher l’objet (objetEcouteur) au widget à

l’aide de la méthode
« addTrucListener(objetEcouteur) ».

4. Le code qui réalise la réaction à l’événement

« TrucEvent » doit être écrit à l’intérieur d’une
(ou +sieurs) des méthodes de la classe qui
implémente l’interface « TrucListener ».
58
 Récapitulatif : événements, écouteurs, widgets
Evénements Ecouteurs Méthodes Widgets
JButton
ActionEvent ActionListener actionPerformed JTextField
JMenu
JMenuItem
List
mouseClicked
mouseEntered
MouseEvent MouseListener mouseExited (J)Component
mousePressed JList
mouseReleased
keyPressed
KeyEvent KeyListener keyTyped (J)Component
keyReleased

focusGained
FocusEvent FocusListener (J)Component
focusLost

InputMethodEvent InputMethodListener inputMethodTextChangedJTextComponent

JTextField
JTextArea

ItemEvent ItemListener itemStateChanged JCheckBox

Choice
List
windowActivated
WindowEvent WindowListener JWindow
windowClosing
59
Entrée/Sortie

60
 Lecture d’un fichier texte

Un fichier texte = suite de caractères ASCII dont

:
• des caractères de fin de ligne < CR >
• un seul caractère de fin de fichier < EOF >

Exemple :
Le petit chat.<CR>
Encore le petit chat,<CR>
etc.etc.<CR>
etc.etc.<CR>
Finalement le petit chat.<EOF>

Le but de la lecture est de récupérer les lignes

une par une :
• Le petit chat.
• Encore le petit chat,
• …
• Finalement le petit chat.

61
 Lecture d’un fichier texte

Sur le disque, on ne trouve que du binaire :

01001100011001010000100001110000 …

Pour lire une ligne, il faut donc :

• faire un découpage par paquets de 8 bits

(octets)
01001100/01100101/00001000/01110000

• faire la transformation octet -> caractère

L/e/’\b’/p

• assembler les caractères pour former la ligne

jusqu’à rencontrer le caractère <CR>

62
 Le format Stream

• Exceptés les entrées-sorties graphiques, toutes

les autres entrées/sorties s’effectuent en Java
avec des Stream.

• Un « Stream » (flot de données) en Java c’est

une séquence d’octets.

63
 Le format Stream

• Un « InputStream » ou flot d’entrée peut

venir d’un fichier, du clavier ou d’un réseau.

Programme
Ecran System.out --------
OutputStream -------
-------
System.in
Clavier InputStream

• Un « OutputStream » ou flot de sortie peut

aller vers un fichier, l’écran ou vers le réseau.

• Le paquetage « java.io » traite des entrées-

sorties de type « Stream ».

64
 Lecture en Java

Une lecture efficace de lignes de texte dans un

fichier en Java nécessite l’utilisation de 2 objets
: FileReader et BufferedReader.

• rôle de l’objet FileReader : lit les octets un par

un et les transforme en caractères

• rôle de l’objet BufferedReader : regroupe les

caractères pour former une ligne de texte

zone
String tampon Octets fichier physique

65
 Lecture en Java

Arbre d’héritage entre quelques classes de

lecture du paquetage « java.io ».

Object

Reader

InputStreamReader
BufferedReader
BufferedReader (Reader in)

FileReader
FileReader (String fileName)

66
 Lecture en Java

public void lecture ( String nomFichier ) {

boolean eof = false;
String tmp;
BufferedReader tampon;
FileReader file;

file = new FileReader ( nomFichier );

tampon = new BufferedReader ( file );

while ( ! eof ) {
tmp = tampon.readLine();
if ( tmp == null ) {
eof = true;
}
else {
System.out.println( tmp );
}
}

tampon.close();
}

!! Le constructeur FileReader(…) et la méthode

readLine() peuvent lancer des exceptions => il
faut dire ce qu’on en fait. 67
 Lecture en Java
public void lecture ( String nomFichier ) {
boolean eof = false;
String tmp;
BufferedReader tampon;

try {
tampon = new BufferedReader ( new
FileReader ( nomFichier ) );

while ( ! eof ) {
tmp = tampon.readLine();

if ( tmp == null ) { eof = true; }

else {
System.out.println( tmp );
}
}
tampon.close();
}
catch (FileNotFoundException e) {
System.out.println ( e.getMessage() );
}
catch (IOException e) {
System.out.println ( e.getMessage() );
}
} 68
 Ecriture en Java

Pour l’écriture, on procède à l’inverse de la

lecture.

1. Codage de l’information en caractères ASCII.

Exemple : entier 23 = "2""3"
Gestion : objet « PrintWriter »

2. Regroupement des caractères pour former des

lignes.
Gestion : objet « BufferedWriter »

3. Transformation de chaque caractère en

octet(s) (par ex. 8 bits / caractère).
Gestion : objet « FileWriter »

69
 Ecriture en Java

Arbre d’héritage entre quelques classes

d’écriture du paquetage « java.io ».

Object

Writer

OutputStreamWriter
BufferedWriter
BufferedWriter (Writer out)

PrintWriter FileWriter
PrintWriter (Writer out) FileWriter (String fileName)

70
 Ecriture en Java

public void écriture(String nomFichier,String uneLigne) {

FileWriter file;
BufferedWriter tampon;
PrintWriter out;

try {
file = new FileWriter ( nomFichier );
tampon = new BufferedWriter ( file );
out = new PrintWriter ( tampon );

out.println ( ligne );
out.close();
}

catch (IOException e) {
System.out.println ( e.getMessage() );
}
}

!! Le constructeur FileWriter(…) peut lancer

une exception.

71
 Décodage des infos dans une chaîne

But : on récupère une chaîne de caractères et on

voudrait extraire un par un les blocs qui
composent la chaîne.

Exemples :
17/An Dro/Trad./Gr/danse-celt/5/22
séparateur = "/" =>

17
An Dro
Trad.
Gr
danse-celt
5
22

72
 Décodage des infos dans une chaîne

La classe String possède une méthode qui extrait

les informations et les renvoie sous forme d’un
tableau de String en UNE SEULE opération.
…
String[] lesInfos;
// lecture d’une ligne de texte du fichier
String ligne = in.readLine();
// on suppose ici que «ligne» contient
// "17/An Dro/Trad./Gr/danse-celt/5/22"

// Extraction des éléments en UNE SEULE opération

lesInfos = ligne.split ( "/" );

// «lesInfos» est un tableau de String qui contient :

// en 0 : "17"
// en 1 : "An Dro"
// en 2 : "Trad."
// en 3 : "Gr"
// en 4 : "danse-celt"
// en 5 : "5"
// en 6 : "22"

// et ensuite convertir chaque String dans le type

// qui convient en utilisant les classes wrapper...
73
 Les classes Wrapper

Il faut maintenant transformer String en int, double,

boolean, ...

Utilisation des classes wrapper du paquetage

java.lang.

• classe Integer
méthode : static int parseInt ( String s )

• classe Double
méthode : static double parseDouble ( String s )

• classe Boolean
méthode : static boolean parseBoolean ( String s )

!! exceptions éventuellement à gérer

74