Vous êtes sur la page 1sur 303

Java & la POO

1
Plan
1. Java & la POO
2. Héritage & Règles de visibilité
3. Polymorphisme
4. Classes abstraites & Interfaces
5. Exceptions
6. Programmation graphique
7. Les Threads
8. Gestion de fichiers 2
Plan détaillé
1. Java & la POO
1.1. Principes généraux
1.2. Notion de classe
1.3. Cycle de vie d’un objet
1.4. Affectation&comparaison d’objets
1.5. Attributs, Méthodes et Classes
1.6. Programmation de base
1.7. Classes enveloppe

3
Plan détaillé
2. Héritage & Règles de visibilité
2.1. Héritage
2.2 Règles de visibilité
3. Polymorphisme
4. Classes abstraites & Interfaces
4.1. Classes abstraites
4.2. Interfaces
5. Exceptions
6. Programmation graphique
6.1. Gestionnaires de présentation
6.2. Mise en oeuvre des traitements 4
1.1. Principes généraux

• Java est né à l’intersection de +ieurs tendances:


– évolution des ordinateurs
– évolution des langages
– réseaux et communications
• Historique:
– Situation de Sun en 90
– 1990: 1er projet de langage
– 1992: OAK, 1ère version du projet
– 1993: envol du Web
– 1995: OAK rebaptisé Java
– 1998-1999: optimisation des compilateurs Java pour
arriver à concurrencer C++ sur les performances
5
5
1.1. Principes généraux

• Caractéristiques du langage
– Langage de programmation && plateforme
– Orienté Objet -> à Objets
– Contrôle statique stricte
– Multithread
– Liaison dynamique
– Gestion mémoire
– Sécurisé: vérification du code avant exécution

6
1.1. Principes généraux

• Java vs C++
– Pas de pointeur
– Pas de structure ou d'union struct, defstruct
– Pas de macros #define
– Pas de gestion de la mémoire laissée à
l'utilisateur malloc(), free(), new(), delete()
– Pas d'héritage multiple(direct: de structure)
– Pas de redéfinition d'opérateur
– Vérification à l'exécution des dépassements
de bornes de tableaux 7
1.1. Principes généraux

• La plate-forme Java
– Définition
– Caractéristiques
Application Application
Application
Langage de // Librairies
Langage de Langage de
Langage de //
// Librairies
Librairies
dévelopmt // Système dévelopmt //
dévelopmt // Système
Système
développement
Système Machine virtuelle
Système
Système d’// Librairies
d’exploitation
exploitation// Système Système d’exploitation
d’exploitation
Processeur
Processeur Processeur
Insertion de la technologie
Remontée de la machine
des fonctionnalités virtuelle
des OS 8
1.1. Principes généraux

• Architecture de la plate-forme (J2SE, v1.4):

9
1.1. Principes généraux
• Principales composantes:
– Le compilateur
– L’interpréteur
– La machine virtuelle: “write once, run anywhere...”
– Le ramasse miette:
• Gestion de la mémoire « automatique » 
• Une destruction manuelle des objets reste possible par appel
explicite du ramasse miette. Classe Runtime
– Le chargeur de classe:
• Fait partie du système de sécurité de java: sépare les classes
locales et les classes venant du réseau
• Recherche de classe effectuée en priorité parmi les classes locales.
Usurpation de nom de classe locale très difficile par une classe
réseau
• Le chemin de recherche des classes: CLASSPATH
10
– Le vérificateur de code
1.1. Principes généraux

• Structure des fichiers SDK:


– [Solaris] [Linux] [Windows]
• Configuration du Classpath
– [Solaris et Linux] [Windows]
• Comment les classes sont localisées
– [Solaris, Linux et Windows]

11
1.2. Notion de classe
• Programmation structurée:
– Programme = réunion de :
• Plusieurs structures de données et types de base
• Plusieurs procédures
• P. O. O. :
– Classe :
• Généralisation de la notion de type connue dans la
programmation classique
– Objet = Instance d’une classe :
• Généralisation de la notion de variable connue dans la
programmation classique
– Programme = mise en œuvre de :
• Plusieurs objets
12
1.2. Notion de classe
• Classe :
– Prototype décrivant une famille d’objets partageant:
• Même structure: des attributs communs (i. e. structure de
données rattachée à la classe)
• Même comportement: des méthodes communes (i. e.
procédure ou fonction rattachée à la classe)
• Représentation abstraite
• Objet:
– Variable d’un tel type de classe:
• instance de la classe (représentation concrète)
• Les valeurs des champs sont intuitivement propres à
chaque objet
• Les méthodes sont intuitivement communes à chaque
13
instance de la classe
1.2. Notion de classe
• Encapsulation:
• objet: regroupement de données et procédures
• cacher les détails d’implantation au monde
extérieur (champs privés)

Structure
Objets Structure

Méthodes Méthodes

Encapsulation totale Encapsulation contrôlée 14


1.2. Notion de classe
• Exemple 1 : Définition d’une classe Point
– Définition du corps de la classe Point :
class Point {
// instructions de définition des champs et des méthodes
de la classe
}
– Définition des champs de la classe :
Un point est représenté par 2 coordonnées:
class Point {
int x;
int y;
} 15
1.2. Notion de classe
• Exemple 1 : Définition d’une classe Point
– Définition des méthodes de la classe :
Un point peut être manipulé à l’aide de 3 opérations:
initialise, déplace, et affiche.
• La méthode initialise:
– attribut des valeurs aux coordonnées d’un point
class Point {

void initialise(int abs, int ord) {
x=abs; y=ord;
}

16
}
1.2. Notion de classe
• Exemple 1 : Définition d’une classe Point
– Définition des méthodes de la classe :
• La méthode déplace: modifie les coordonnées d’un point

class Point {

void deplace(int dx, int dy) {
x+=dx; y+=dy;
}

}
17
1.2. Notion de classe
• Exemple 1 : Définition d’une classe Point
– Définition des méthodes de la classe :
• La méthode affiche(): affiche les coordonnées d’un point

class Point {

void affiche() {
System.out.println(“Abscisse:”+x);
System.out.println(“Ordonnée:”+y);
}

}
18
1.2. Notion de classe
• Exemple 1 : Définition d’une classe Point
– La classe Point:
class Point {
void initialise(int abs, int ord) {
x=abs; y=ord;
}
void deplace(int dx, int dy) {
x+=dx; y+=dy;
}
void affiche() {
System.out.println(“Abscisse:”+x);
System.out.println(“Ordonnée:”+y);
}
int x; // abscisse
int y; // ordonnée 19
1.2. Notion de classe
• Exemple 2 : Utilisation de la classe Point
– La classe Point va permettre d’instancier des objets
de type Point, et de leur appliquer à volonté les
méthodes de la classe Point.
– Cette utilisation ne peut se faire en dehors d’une
autre méthode: la méthode main()
– La démarche:
• Point a = new Point();
– Déclaration de l’objet: Point a;
– Réservation de l’emplacement: new Point()
– Quelles valeurs pour l’abscisse et l’ordonnée de a?
• a.initialise(3,5); a.deplace(2,0); a.affiche(); 20
1.2. Notion de classe
• Exemple 2 : Utilisation de la classe Point
– La classe principale, la méthode main():
public class PremierProgramme {
public static void main(String [] args) {
Point a1;
a1 = new Point();
a1.initialise(3,5); a1.affiche();
a1.deplace(2,0); a1.affiche();
Point a2 = new Point();
a2.initialise(6,8); a2.affiche();
}
}
21
1.2. Notion de classe
• Exercices :
– Exercice 1: PourFeliciter
– Exercice 2: Bonjour, Bonjour2

22
1.3. Cycle de vie d’un objet
• 3 phases:
– Création
– Utilisation
– Nettoyage

23
1.3. Cycle de vie d’un objet
• Création:
– Syntaxe:
nom_classe nom_objet=new
appel_constructeur( paramètres);
exemple: Rectangle R = new Rectangle();

Classe Déclaration Instanciation Initialisation


– Choix du constructeur parmi ceux définis dans la
classe
24
1.3. Cycle de vie d’un objet
• Utilisation:
– Syntaxe:
nom_objet.nom_attribut=valeur_attribut;
nom_objet.nom_méthode(paramètres);
exemples: Rectangle R = new Rectangle();
R.x=4;
R.origine=new Point(4,5);
la=new Rectangle().largeur;

R.move(40,45);

25
1.3. Cycle de vie d’un objet
• Destruction:
– La méthode finalize():
• Destructeur qui libère l’espace mémoire par un mécanisme
de ramasse miettes
• Automatique dès que l’objet n’est plus utilisé
• Méthode membre de la classe Object, racine de la
hiérarchie des classes
• Elle peut-être surchargée au sein d’une classe: toutes les
opérations de “nettoyage” qui concernent l’objet sont
insérées dans le corps de la méthode “finalyze()”

26
1.3. Cycle de vie d’un objet
• Constructeur: Définition
– moyen d’initialiser les attributs des instances lors de
leur création
– diffère des méthodes ordinaires par:
• porte toujours le même nom que sa classe
• n’a pas de type de valeur de retour
– appel du constructeur nécessaire à toute instanciation
– compilateur ajoute un constructeur vide sans argument
en cas d’absence de constructeur
– toute classe possède au moins un constructeur
– si +ieurs constructeurs, alors surcharge
– un constructeur peut appeler un autre 27
1.3. Cycle de vie d’un objet
• Le mot-clé this:
– permet de référencer l'objet courant dans le corps
d'une de ses méthodes (exemple:préfixer attribut pour
accéder à ses variables d'instance)
– this permet de désigner l'objet courant
– emploi de this dans l'écriture des méthodes n'est pas
obligatoire
– Souvent this est inutile: variables d'instances et les
appels de méthodes de la classe courante
implicitement référencées par leur nom this

28
1.3. Cycle de vie d’un objet
• Le mot-clé this:
– Exemple : la classe Point

class Point {
public int x=0;
public int y=0;
public Point(int x,int y) {
this.x=x;
this.y=y;
}
}

29
1.3. Cycle de vie d’un objet
– Exemple complet:

public class Rectangle {


public int largeur=0; public Rectangle(int a, int b) {
public int longueur=0; this(new Point(0,0), a, b);
public Point origine }
public Rectangle() { public Rectangle(Point p,int a,int b) {
origine=new Point(0,0); largeur=a;
} longueur=b;
origine=p;
public Rectangle(Point p) {
}
origine=p; }
}

30
1.3. Cycle de vie d’un objet
–Exercices:
• Exercice1:
Ecrire un programme Java calculant la somme des n
premiers termes de la série harmonique, c’est à dire
la somme 1+1/2+1/3+1/4+…+1/n. La valeur de n
sera saisie comme argument.
• Exercice 2 :
Ecrire un programme Java qui décompose une
somme d’argent saisie en argument en une
combinaison de billets de 200, 100, 50, 20 et 10
DH, ainsi que de pièces de 5, et 1 DH.
31
1.4. Affectation&comparaison
d’objets
• Généralités:
– Un opérateur prend 1 ou plusieurs
arguments et produit une valeur.
– Les arguments des opérateurs sont les types
de base
– Les objets acceptent seulement les
opérateurs suivant : "=", "==", "!="
– Seuls les objets String ont aussi les opérateurs
"+", "+="
– Pas de surcharge des opérateurs.

32
1.4. Affectation&comparaison
d’objets
• Affectation:
– si A et B sont de type primitif alors
A = B signifie: A reçoit une copie de la valeur de B

A
A 47 B 47 47
B

– si A et B sont des objets alors


A = B signifie: A et B pointent sur le même objet B
A et B sont des "ALIAS " 33
1.4. Affectation&comparaison
d’objets
• Exemple:
class Number {int i;}
public class Assignment {
public static void main(String args[]) {
Number n1 = new Number(); Number n2 = new Number();
n1.i = 9; n2.i = 47;
System.out.println("1: n1.i: " + n1.i + ",n2.i: " + n2.i);
n1 = n2;
System.out.println("2: n1.i: " + n1.i + ",n2.i: " + n2.i);
n1.i = 27;
System.out.println("3: n1.i: " + n1.i + ",n2.i: " + n2.i);
}}
Trace: 1: n1.i: 9, n2.i: 47
2: n1.i: 47, n2.i: 47
3: n1.i: 27, n2.i: 27

34
1.4. Affectation&comparaison
d’objets
• La méthode equals():
– Pour comparer l'égalité du contenu de deux
objets complexes on utilisera la méthode
equals():
– à redéfinir pour les nouveaux objets
public class EqualsMethod {
public static void main(String args[]) {
String s1 = new String(« 47 »);
String s2 = new String(« 47 »);
System.out.println(s1.equals(s2));
}}
true
– Exercice: implémenter les 2 programmes précédents
35
1.5. Attributs, Méthodes et Classes
• Attributs
– Caractéristiques individuelles qui différencient un objet
d'un autre, et définissent l'état d'un objet.
– Deux types d'attributs:
• attributs d’instance, ou variables d'instance.
Exemple : int carte = TREFFLE;
• attributs de classe, ou variables de classe: L'état d'un tel
attribut sera le même pour toutes les instances de la classe.
Exemple : static int vclasse;
– Attribut statique ne nécessite pas d’instanciation de la
classe
Exemples: Math.PI, System.out

36
1.5. Attributs, Méthodes et Classes
• Attributs
– Exercices:
• Exercice 1:
Ecrire un programme Java qui compte puis affiche le
nombre d’instances d’une classe Employe donnée.
• Exercice 2:
Etendre ce programme afin de calculer l’IGR de
chaque instance de la classe Employe.

37
1.5. Attributs, Méthodes et Classes
• Attributs:
– Syntaxe : Modificateurs de création de variable
niveau d’accès définit la visibilité de la variable
(private, protected, package ou public)
static variable de classe ou statique
(par défaut, variable d’instance)
final constante
<type>
<nom_variable>

38
1.5. Attributs, Méthodes et Classes
• Méthodes
– déterminent les actions sur ses instances
– Deux types de méthodes:
• Méthodes d ’instance: opère sur un objet particulier
• Méthodes de classe (statique)
– Méthode de classe peut être utilisée partout avec ou
sans l ’existence d ’une instance de la classe
Exemples:
static Math.random(), Math.cos()
– Exemple: classe Motorcycle:
– démarrer le moteur - arrêter le moteur - accélérer
– changer de vitesse - caler
– A l'inverse de C++ Java ne possède pas de fonctions
définies en dehors des classes
39
1.5. Attributs, Méthodes et Classes
• Méthodes
– Exercices:
• Exercice 3:
Reprendre le programme Harmonique afin de pouvoir appeler
la méthode harmonique sans instancier la classe Hamonique.
• Exercice 4:
Ecrire un programme Java qui affiche la valeur du cosinus et
du sinus d’un angle.
• Exercice 5:
Ecrire un programme Java qui affiche la valeur de la factrielle
d’un nombre entier saisi en argument.

40
1.5. Attributs, Méthodes et Classes
• Méthodes:
– Syntaxe : Modificateurs de création de méthode
niveau d’accès définit la visibilité de la méthode (idem attribut)
static méthode de classe ou statique peut être invoquée sans
instancier la classe (par défaut, méthode d’instance)
abstract seul son prototype figure
volatile peut être changée par un périphérique ou de manière
asynchrone (le compilateur ne doit pas stocker les valeurs
dans les registres)
final ne peut être surchargée
native écrite dans un autre langage
synchronized nécessite un moniteur (verrou, section critique)
<type_de_retour><nom_méthode>(<arguments>) throws <exception> {
// args. par valeur
<corps>
return <valeur>;} 41
1.5. Attributs, Méthodes et Classes
• Méthodes:
– Typologie des méthodes d’une classe:
• Méthodes d’accès: get…()
• Méthodes d’altération: set...()
– Redéfinition:
• Réutiliser le même nom avec la même signature pour
+ieurs implémentations dans une hiérarchie de classes
– Surcharge:
• Réutiliser le même nom avec des signatures différentes
• Surcharge des opérateurs impossible en java

42
1.5. Attributs, Méthodes et Classes
• Déclaration d’une classe:
– Syntaxe: Modificateurs de création de classe

public accessible par tout le monde


abstract classe abstraite (ne peut être instanciée)
final ne peut être sous classée
class <nom_classe> nom de la classe
extends <super> la classe super : classe mère de la classe
en cours
implements <interface> interface implémentée par cette classe
{
<corps de la classe>
}

43
1.5. Attributs, Méthodes et Classes
• Attributs et Méthodes finaux:
– Modificateur final extrêmement polyvalent:
• L ’appliquer à une classe signifie interdire son sous-
classement (interdit l ’héritage)
• L ’appliquer à une variable la rend constante (interdit la
modification)
• L ’appliquer à une méthode interdit aux sous-classes d ’en
créer un polymorphe (interdit la surcharge)
– Remarque:
• Les variables locales (dans les blocs d ’instruction entre {})
ne peuvent être déclarées final

44
1.5. Attributs, Méthodes et Classes
• Attributs et Méthodes finaux:
– Pourquoi des classes final ?
• Pour la Sécurité, afin que les caractéristiques de ses
instances ne soient pas modifiables. Cela interdit leur sous-
classement et la création d ’instance différentes

• Pour des raisons d ’efficacité, le fait d ’avoir seulement


des instances de cette classe (et non de ses sous classes)
dans le système permet de les optimiser

45
1.5. Attributs, Méthodes et Classes
• Attributs et Méthodes finaux:
– Les méthodes sont déclarées final pour optimiser les
performances.
– Le code des méthodes déclarées final est placé
directement au milieu du code de la méthode qui
l'appelle (le compilateur "sait" que ce code ne pourra
ni être "sous-classé" ni dupliqué: polymorphisme) :
i.e. commande "inline" de C++
– final est très utile pour les méthodes d'accès aux
attributs (recommandé en POO)

46
1.6. Programmation de base
• Structure lexicale:
– Identificateurs:
• une lettre puis combinaison alphanumérique "_","$"
– lettre=caractère unicode (Exemple : int µ = 10;)
– Java distingue majuscules et minuscules.
• Exemple: V différent de v
– Terminateur ";"
– Commentaires
• // pour une ligne de commentaire
• /* commentaires */ pour plusieurs lignes
• /** Documentation de classe et méthodes */ 47
(javadoc)
1.6. Programmation de base
• Conventions de codage:
– Nommage des variables, champs et
méthodes
• En Java, un identificateur commence par des
lettres minuscules.
– Exemple: get()
• Si l'identificateur contient plus qu'un mot, le
premier sera en minuscule, les suivants
commencent par une majuscule
– Exemple: getString()

48
1.6. Programmation de base
• Conventions de codage:
– Nommage des constantes
• une constante doit être en lettre capitales
– class ConstClass { final int MAXSIZE = 100; }
– Nommage des classes
• Le nom des classes commence toujours par
une lettre majuscule
– class ConstClass { final int MAXSIZE = 100; }
– class IndexOutOfBoundsException {…}

49
1.6. Programmation de base
• Types de données:
– Les types de base:
Type Taille (bit) Valeurs Par défaut Exemples
boolean 1 true, false false boolean b=true;
byte 8 -27 à + 27-1 0 byte nbDec=127;
char 16 '\u0000' à '\uffff’ ‘\u0000’ char c1=‘d’;
char c2=‘\u0023’;
short 16 -215 à + 215-1 0
int 32 -231 à + 231-1 0 int nbHex=0x5ec;
long 64 -263 à + 263-1 OL long nbOct=0346;
float 32 1.40e-45 à 3.40e38 0.0f float nbf=58.385f;
double 64 4.94e-324 à 1.79e308 0.0d float nbd=58.385d;
50
1.6. Programmation de base
• Types de données:
– Les tableaux:
• Syntaxes:
– typeTab nomTab[]; ou bien typeTab[] nomTab;
nomTab[]=new typeTab[nb_elements];
– typeTab nomTab[]= new typeTab[nb_elements];
– typeTab nomTab[]= {liste éléments};

• Propriétés:
– Si le type est une classe, ses filles sont admises
– 1er élément d ’un tableau à l ’indice 0
– Dimension fixe d ’un tableau; Propriété ‘ length ’
– Tableaux mono dimensionnels par définition
– Tableaux multidimensionnels supportés
– Les classes 51
1.6. Programmation de base
• Les constantes:
– Pour déclarer une constante, utiliser le mot clé
final à l ’intérieur d ’une classe
– Exemple:
public class test {
final int MAX = 20;
}

52
1.6. Programmation de base
• Les opérateurs:
– Supportés par les objets: "=", "==", "!="
– Cas particulier de la classe String: "+", "+="
– Pas de surcharge des opérateurs
– Affectation: types primitifs et objets
– Opérateurs arith., de décalage et relationnels: C
– Opérateurs logiques:
• Méthode equals() : compare l'égalité de deux objets
• Pour l’égalité de contenu:
– À surcharger pour les classes <> String
– Conversion implicite: promotion numérique 53
1.6. Programmation de base
• Les instructions:
– Instructions de test
– Instructions répétitives
– Instructions continue et break
• i.e. langage C

54
1.6. Programmation de base
• Les instructions:
– Instructions de test
– Instructions répétitives
– Instructions continue et break
• i.e. langage C

55
1.7. Classes enveloppes
• Classes utilitaires de données, Classes
enveloppes, Classes d’emballage:
– Java distingue les types de classes (objets) et les
types élémentaires (nombres, caractères et valeurs
booléennes), pour des raisons de souplesse,
d’efficacité et de complexité
– si une valeur nécessite d’être traitée comme objet,
alors java fournit une classe d’emballage (wrapper)
pour chaque type élémentaire
– Ne sert pas à implémenter des méthodes capables de
modifier le arguments numériques (erreur courante,
arguments passés par valeur)
56
1.7. Classes enveloppes
• Classes enveloppes, classes d’emballage:
type élémentaire: classe d’emballage:
boolean java.lang.Boolean
char java.lang.Char
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double
57
1.7. Classes enveloppes
• Classes enveloppes, classes d’emballage:
– Tous les wrappers disposent des méthodes
suivantes:
• doubleValue();
• intValue();
• floatValue();
• longValue();
– Elles convertissent la valeur stockée dans
l’objet en fonction du type mentionné dans la
méthode
– Elles retournent une valeur et non un objet58
1.7. Classes enveloppes
• Classes enveloppes, classes d’emballage:
– Exemple: la classe Integer
• Constantes:
– Integer.MAX_VALUE
– Integer.MIN_VALUE
• Constructeurs:
– public Integer(int i)
– public Integer(String s)
• Exemple:
– Integer I=new Integer(10);
– int i; float j;
– i=I.intalue();
– j=I.floatValue(); 59
1.7. Classes enveloppes
• Classes enveloppes, classes d’emballage:
– Conversions de String en nombres:
• la méthode valueOf(): convertit une chaîne et
retourne un objet
• exemple:
String s= “159”;
Integer I = Integer.valueOf(s);
Integer I = Integer.valueOf(s,16); // par défaut base 10

60
1.7. Classes enveloppes
• Classes enveloppes, classes d’emballage:
– Conversions de String en nombres:
• la méthode parseInt(): retourne un entier
• exemple:
String s= “16”; int n;
Integer I = new Integer(s);
System.out.println(I.toString());
n=Integer.parseInt(s);
System.out.println(n);

61
1.7. Classes enveloppes
• La classe StringBuffer:
– manipule les chaînes de caractères variables
– méthodes:
• charAt(): retourne un caractère
• length(): nombre de caractères dans la chaîne
• capacity(): espace mémoire total alloué
• append(): concatène en fin de chaîne
• insert(): insère une chaîne
– Opérateur de concaténation de chaînes: +

62
1.7. Classes enveloppes
• La classe StringBuffer:
– exemple: inversion de chaîne
class ReverseString {
public static String reverseIt(String source){
int i;
int len = source.length();
StringBuffer dest = new StringBuffer(len);
for (i=len-1; i>=0; i--) {
dest.append (source.charAt(i));
}
return dest.toString();
}
}
63
1.7. Classes enveloppes
• La classe StringBuffer:
– la méthode toString():
• toString(): convertit l’objet en son équivalent String
– exemple: insertion de chaîne

StringBuffer sb = new StringBuffer(“Drink Java!”);


sb.insert (6,”Hot “);
System.out.println(sb.toString());
affiche la chaîne: “Drink Hot Java!”

64
1.7. Classes enveloppes
• Les vecteurs:
– Classe de la bibliothèque Java: java.util.Vector
– Tableau extensible d’objets (éléments de type Object)
– Transtypage pour récupérer un élément du
vecteur
– Constructeurs:
new Vector() //capacité 10, taille *2 à chaque dépassement
new Vector(int capacité) // capacité potentielle initiale n
new Vector(int capacité; int incr)// capacité potentielle capacité,
// +incr à chaque dépassement
Remarque: Estimation correcte, pour une bonne
performance 65
1.7. Classes enveloppes
• Les vecteurs:
– Méthodes:
0 33 33 33
Exemple: 1 34 s 34
Vector MyNumber=new Vector(); 34
2
Integer ThirtyThree = new Integer(33);
MyNumber.addElement(ThirtyThree);
Integer ThirtyFour = new Integer(34);
String s = “chaine”; MyNumber.addElement(ThirtyFour);
MyNumber.insertElementAt(s,1);
int i = MyNumber.indexOf(ThirtyFour); //i==2; -1 sinon
MyNumber.removeElement(s); i=MyNumber.size(); //taille du vecteur

66
1.7. Classes enveloppes
 Les vecteurs:
 Test de performance:
Pentium 200 MHx, 96 Mo, 100000 éléments

Allocation des éléments d’un vecteur: 17910 msec


Allocation des éléments d’un tableau: 4220 msec
Accès aux éléments d’un vecteur: 18130 msec
Accès aux éléments d’un tableau: 10110 msec

67
1.7. Classes enveloppes
• La classe Date (version 1.1):
– constructeurs:
• Date now = new Date;
• Date d1=new Date(year, month, day);
• Date d2=new Date(year, month, day,hour,min,sec);
• Date bigBang=new Date(OL); // 1er Janvier 1970
– méthodes:
• getYear();setYear();getMonth();setMonth();getDay();setDay();
• getHour();setHour();getMinutes();setMinutes();getSeconds();
setSeconds();before(); after(); equals();

• Autre classe: GregorianCalendar 68


1.7. Classes enveloppes
• La classe java.util.Random:
– Générateur de nombres aléatoires
– Utilise une valeur initiale (seed) de 48 bits
– Exemple:
• long seed = myseed;
• Random rnums=new Random(seed);
• Méthodes:
– nextInt(): -2147483648 et +2147483647
– nextLong(): -9.2. 10^18 et + 9.2. 10^18
– nextFloat(): entre -1.0 et +1.0
– nextDouble(): entre -1.0 et +1.0
69
2. Héritage & Règles de visiblité

2.1. Héritage
2.2. Règles de visibilité

70
2.1. Héritage

• Définition:
– classe peut-être définie en terme d’autres classes
– sous-classe hérite attributs et méthodes de sa/ses
super-classes
– sous-classes peuvent ajouter d’autres attributs et
méthodes à ceux déjà hérités
– sous-classe peut surcharger des méthodes héritées
– instance d’une classe fille peut être déclarée comme
de type “classe mère”

71
2.1. Héritage

• Syntaxe:
– Se définit avec le mot clé : extends
• Les constructeurs ne sont pas hérités
• Appel du constructeur de la classe héritée super()
obligatoire
• Restriction au niveau des accès
– Exemple: class Bateaux {
String nomb ;
Bateaux(String nom){
nomb=nom; } }
public class Voiliers extends Bateaux {
Voiliers(String s){super(s);}
72
}
2.1. Héritage
• Activation des méthodes de la classe mère
– Redéfinition de méthode héritée: ajout du
comportement à la définition initiale et non la masquer
: évite de dupliquer un comportement.
– L'appel de la méthode initiale utilise le mot clé super
qui transmet l'appel à la hiérarchie des classes
• Exemple: dans une classe fille
void myMethode (String a, String b) {
// faire quelque chose ici
super.myMethode(a,b); // appel du comportement déjà défini
// faire quelque chose de plus ici
}
NomClassDerivee(){super (...);//doit être la 1ère ligne
}
73
2.1. Héritage

• Redéfinition & Surcharge de méthodes:


– Surcharge de méthodes:
• Nouvelle définition des méthodes dans les classes dérivées
– concept de "is a" :
• héritage et redéfinition de méthodes
– concept de "is like a" :
• héritage, redéfinition, class Bateaux {
String nomB ;
surcharge et Bateaux(String nom){nomB=nom;}
ajout de méthodes String getNomBateau(){return nomB;}

• Exemple
}
class Voiliers extends Bateaux {
class P{ String typeVoilier = "Trimarron";
public static void main(String argv[]){ Voiliers(String s){super(s);}
Voiliers v = new Voiliers("Gramma"); String getNomBateau(){
String s = v.getNomBateau(); System.out.println(nomB+ " "+typeVoilier);
} String s = super.nomB+typeVoilier; return
74 s;}
} }
2.1. Héritage
• Exemple 1: La superclasse cosmique
(java.lang.Object)
– L’ancêtre ultime de toutes les classes Java
– Méthodes associées:
public boolean equals(Object obj)
Class getClass()
Object clone()
String toString()
etc.

75
2.1. Héritage
• Exemple 2: la classe Class
– Identification de type à l’exécution: mémorise la classe
à laquelle chaque objet appartient
– Employée par Java afin de sélectionner les méthodes
correctes lors des appels de méthodes
– Valeur de retour de la méthode: getClass()
– Méthodes associées:
String getName() String toString()
Class getSuperclass() boolean isInterface()
Class[] getInterfaces() Object newInstance() *
static Class forName(String className)
– Exercice 1: Ecrire un programme Java qui affiche les propriétés
d’une classe dont le nom est lu au clavier
76
2.2. Règles de visibilité
• Encapsulation:
– Quatre modificateurs ou niveaux de contrôle
de l'encapsulation (de protection):
• private : visibilité limitée à la classe
• protected : visibilité limitée aux sous-classes et
aux membres d'un même package
• package : visibilité limitée aux membres d'un
(friendly) même package
• public : visible par toutes les classes et
packages

77
2.2. Règles de visibilité
• Règle de visibilité:
“private” (limité à une classe)
– Restriction de la visibilité d'un champ ou d'une
méthode d'une classe aux méthodes de la
classe elle-même
– Manipulation d’une variable/méthode de la
classe fille, déclarée privée dans la classe
mère, n ’est pas toléré
– Mode de protection le plus restrictif en Java
– Si tout les champs d'une classe sont privés, on
parle aussi d'encapsultation totale 78
2.2. Règles de visibilité
• Règle de visibilité:
“private” (limité à une classe)
– exemple 1:
class alpha {
private int iamprivate;
private void private_methode(){
System.out.println(“Private Method”);}}
class beta {
void access_methode(){
alpha a = new Alpha();
a.iamprivate = 10; // illegal
a.private_methode(); // illegal
System.out.println(“Private Method”);}} 79
2.2. Règles de visibilité
• Règle de visibilité:
“private” (limité à une classe)
– exemple 2:
class alpha {
private int iamprivate;
boolean isEqualTo(alpha Anotheralpha){
if (this.iamprivate == anotheralpha.iamprivate)
return true
else
return false;
}
} 80
2.2. Règles de visibilité
• Règle de visibilité:
“protected” (limité à une hiérarchie de classe)
– Restriction de la visibilité d'un champ ou d'une
méthode d'une classe aux méthodes de la
classe elle-même et à ses descendantes
– Manipulation de variable/méthode de la classe
fille, protégée ds la classe mère: toléré
– Manipulation de variable/méthode de la classe
mère, déclarée protégée ds celle-ci: inhibé
– Les classes d'un même package voient les
champs/méthodes protégées d'autres classes 81
2.2. Règles de visibilité
• Règle de visibilité:
“protected” (limité à une hiérarchie de classe)
– exemple:
package Greek;
class alpha{
protected int iamprotected;
protected void protected_Method(){
System.out.println(“Protected Method”);
}
}
package Greek;
class gamma{
void access_Method(){
alpha a = new alpha();
a.iamprotected = 10; // legal
a.protected_Method(); // legal
} 82
}
2.2. Règles de visibilité
• Règle de visibilité:
“protected” (limité à une hiérarchie de classe)
– exemple (suite):
import Greek.*;
package Latin;
class delta extends alpha{
void access_Method(alpha a, delta d){
a.iamprotected = 10; //illegal
d.iamprotected = 10; // legal
a.protected_Method(); // illegal
d.protected_Method(); // legal
}
}

83
2.2. Règles de visibilité
• Règle de visibilité:
“package”/ “friendly”
(limitée aux classes du même package)
– Regroupe en une seule unité un ensemble de
classes résolvant un même problème
– Chaque fichier appartenant à un même
package doit posséder dans son entête le nom
du package
exemple:
// Fichier 1 //Fichier 2
84
package myPackage; package myPackage;
2.2. Règles de visibilité
• Règle de visibilité:
“package” / “friendly”
(limitée aux classes du même package)
– Les fichiers d'un même package sont
regroupés dans un même répertoire
• exemple : java.lang (les classes de ce package se
trouvent sous les répertoires java et lang)
– Les fichiers n'ayant aucun nom de package en
entête appartiennent à un package sans nom
– Les champs/méthodes st par défaut friendly:
visibles depuis les classes d'un même package
85
2.2. Règles de visibilité
• Règle de visibilité:
“package” / “friendly”
(limitée aux classes d’un même package)
– exemple: class Employe extends Person{
import java.util.*;
private float salaire;
class Person { Employe(String name, Date birthday, float sal){
String nom; Date dnaiss; super(name, birthday); salaire = sal;
// nom et dnaiss friendly par //OK : champs nom et dnaiss friendly
défaut }}
Person(String name, Date birthday){ class TestPrivate{
nom = name; public static void main(String[] args){
dnaiss = birthday; Person p = new Person(“Ali", new Date(12,12,1942));
// OK Person est un p.nom = “Ali"; System.out.println(p.nom);
constructeur // OK si TestPrivate est dans le même package 86
// de la classe Person }}
2.2. Règles de visibilité
• Exercice 6:
Implémenter l’exemple précédent en utilisant:
– Aucun paquetage
– 1 paquetage unique contenant 1 fichiers contenant les
3 classes
– 1 paquetage unique contenant 3 fichiers distincts
associés à chacune des 3 classes
– 2 paquetages:
• p1 contenant la classe TestPrivate,
• p2 contenant les classes Personne et Etudiant

87
2.2. Règles de visibilité
• Règle de visibilité:
“public” (Visibilité publique)
– Un champ ou une méthode d'une classe est
dite publique parce qu'il est visible:
• dans la classe elle-même
• dans les classes dérivées
• dans les classes membres d'un même package
• dans les autres classes membres d'autres packages
– Note:
• ce mode de visibilité doit être évité autant que
possible pour les attributs. 88
2.2. Règles de visibilité
• Visibilité depuis la classe dérivée (héritage)
– Méthodes publiques de la classe mère (public)
• Visibibilité généralisée
– Méthodes privées de la classe mère (private)
• Non visibles dans les classes dérivées
– Méthode package de la classe mère (package)
• Visibilité possible pour les classes du package, mais
pas les classes dérivées et celles des autres pckgs.
– Méthode protégée de classe mère (protected)
• Visibilité limitée aux classes dérivées
89
2.2. Règles de visibilité
• Tableau récapitulatif:
Modificateur Classe Sous-classe Package Tout le monde

private x

protected x x x

public x x x x

package x x

90
2.2. Règles de visibilité:
• Conseils pour la conception de classes:
– Les données doivent être privées
– Utiliser un nbre limité de types de base ds une classe:
• remplacer +ieurs champs apparentés par une autre classe
– Tous les champs n’ont pas besoin de méthodes
d’accès et de méthodes d’altération
– Subdiviser les classes ayant trop de responsabilités
– Donner des noms significatifs aux classes et méthodes
– Utiliser un format std pour la déf. de vos classes

91
3. Polymorphisme

• Notion de polymorphisme:
– Capacité qu'a une méthode d'être activée,
pour un paramètre formel d'un type donné,
avec des paramètres concrets de types
différents
• Types de polymorphisme (Luca Cardelli) :
– Surcharge
– Coercicion
– Inclusion
– Paramétrisation 92
3. Polymorphisme
• Types de polymorphisme (Luca Cardelli) :
– Surcharge:
capacité de réutiliser des noms de méthodes. afficher(int),
afficher(Personne), ...
– Coercicion:
convertir un type vers un autre
– Inclusion:
substituer un type par un autre grâce à une relation d'inclusion.
Soit f(T1) l'appel f(T2) est valide si T2 est sous type (hérite)
de T1
– Paramétrisation:
remplacer un paramètre formel par un paramètre concrèt.
Exemple : Soit une liste générique, List[T] on peut instancier des
listes concrètes : List[int], List[Personne] ….
93
3. Polymorphisme

• Conversion d’objets: casting implicite


En Java, doit se faire de façon explicite, sauf:
– en cas de promotion numérique
• Les types plus petits peuvent être affectés aux plus gros sans
encombre.
• Ex : long peut être affecté à double
– en cas d'inclusion de types
Soit T2 inclus dans dans T1. Les déclarations suivantes
sont licites.
T1 v1; T2 v2 ;
v1 = v2 ; // Affectation légale sans conversion explicite

94
3. Polymorphisme

• Exemple:
//conversion
Bateaux
public class Bateaux { aurore
String nomb ;
Bateaux(String nom){nomb=nom;}
public static void main(String argv[]){
Bateaux aurore = new Bateaux("Aurore"); Voiliers
Voiliers gramma= new Voiliers("Gramma"); gramma
aurore = gramma;//OK voiliers < Bateaux (un voilier est un
bateau)
gramma = aurore;//Erreur(casting obligé)(un bateau n’est pas
nécessairement un
voilier)
}
}
class Voiliers extends Bateaux {
Voiliers(String nom1){super(nom1);}}
95
3. Polymorphisme

• Conversion d’objets: casting explicite


– Exemple
// Casting explicite
public class Bateaux { class Voiliers
String nomb ; extends Bateaux {
Bateaux(String nom){nomb=nom;} Voiliers(String nom1){
super(nom1);
public static void main(String argv[]){ }
Bateaux aurore = new Bateaux("Aurore"); }
Voiliers gramma= new Voiliers("Gramma");
BateauxAMoteurs bam =new BateauxAMoteurs("BAM"); class BateauxAMoteurs
aurore = gramma;//OK voiliers < Bateaux extends Bateaux {
gramma = (Voiliers)aurore; BateauxAMoteurs(String nom1)
//OK car aurore est un voilier {super(nom1);
bam = (BateauxAMoteurs) aurore; }
//Conversion impossible }
//Exception générée:ClassCastExeception
}
96
3. Polymorphisme

• Conversion d’objets : casting explicite


– L’opérateur ‘instanceof’:
– Il permet de déterminer à l ’exécution le type
d ’un objet
– Afin d ’éviter des conversions explicites
erronées d ’un type de base vers une de ses
filles, il peut être judicieux d ’utiliser ‘instanceof’
– Une exception ClassCastException est générée
si le casting est illégal

97
3. Polymorphisme

• Surcharge de méthodes:
– Réutiliser le même nom pour +ieurs implémentations
dans une hiérarchie de classes
– Surcharge des opérateurs impossible en java

98
3. Polymorphisme

• Méthodes polymorphes par inclusion:


– Une méthode d'une classe de base est dite polymorphe
par inclusion lorsque son implémentation est affinée
progressivement par ses classes dérivées
– Chaque implémentation d'une méthode polymorphe
dans une classe fille doit prendre en charge l'appel de
la version de sa classe de base
– Le mot clé approprié pour ce type d'appels est SUPER
suivit du nom de la méthode

99
3. Polymorphisme

• Redéfinition de méthodes:
– Exercice 5:
• Redéfinir la méthode equals() d’une classe
PolygoneRegulier, de manière à retourner “true” en
cas d'égalité des valeurs de 2 polygones réguliers
ayant des références différentes.

100
3. Polymorphisme

• Redéfinition de méthodes:
– Exercice 6: On souhaite gérer les comptes bancaires.
On définira 3 catégories de comptes:
• Compte Courant (n°compte et solde)
• Compte Depot (n°opération et opération[])
• Compte Guichet (n°opération et opérationGAB[])
– Une opération interne n'est pas taxée, alors qu'une opération issue d'un
GAB externe est taxée de 6DH par transaction
Concevoir une hiérarchie de classes et implémenter le
programme associé

101
4. Classes abstraites & Interfaces
4.1. Classes abstraites
4.2. Interfaces
4.3. Classes internes
4.4. Application: Les collections

102
4.1. Classes abstraites
• Définition:
– méthode abstraite :
• n’est pas implémentée: seul son prototype figure
• implémentation faite par surcharge lors de
l’héritage
– classe abstraite :
• contient au moins une méthode abstraite
(par manque d’information)
• ne peut être instanciée

103
4.1. Classes abstraites
• Propriétés:
– Ne p.e. instanciée, doit être étendue pour utilisation
– Une sous-classe d’une classe abstraite sera abstraite si
elle ne définit pas toute méthode abstraite héritée
• Utilité:
– Permet de définir des méthodes communes dont
l’implémentation diffère d’une sous-classe à l’autre
– Ex: propriétés des figures géométriques

104
4.1. Classes abstraites
• Application:
– Les formes géométriques
• La classe abstraite des formes géométriques
– La classe Ellipse
– La classe Rectangle
– La classe principale:
• Un tableau de formes géométriques
(ellipses + rectangles)

105
4.1. Classes abstraites
• Application:
– La classe abstraite des formes géométriques
abstract class Forme {
abstract float perimetre(); // méthode abstraite
abstract float surface(); // méthode abstraite
boolean est_plutot_rond() {
float leperimetre = perimetre();
return surface() <= leperimetre*leperimetre/16;
}
void description() {
if (estplutotrond())
System.out.println(this+
“s’etale au moins comme un carre”);
else
System.out.println(this+
“s’etale moins qu’un carre”);
} 106
}
4.1. Classes abstraites
• Application:
• La classe Ellipse
class Ellpse extends Forme {
private– int grandAxe, petitAxe;
Ellpise(int grandAxe, int petitAxe){
this.grandAxe=grandAxe; this.petitAxe=petitAxe;
}
float perimetre(){
float resultat = 0;
float pcarre = petitAxe*petitAxe;
float gcarre = grandAxe*grandAxe;
float sinus,cosinus;
for (int i=0; i<1000; i++) {
sinus=(float) Math.sin(i*Math.PI/2000);
cosinus=(float) Math.cos(i*Math.PI/2000);
resultat += Math.sqrt(pcarre*sinus*sinus+
gcarre*cosinus*cosinus);}
resultat*=4*Math.PI/2000;
return resultat;
} 107
...
4.1. Classes abstraites
• Application:
• La classe Ellipse
... –
float surface(){
return (float) Math.PI*petitAxe*grandAxe;
}
public String toString() {
return(“L’ellipse de grand axe ”+grandAxe
+” et de petit axe “+petitAxe);
}
}

108
4.1. Classes abstraites
• Application:
– La classe Rectangle
class Rectangle extends Forme {
private int longuer, largeur;
Rectangle(int longueur, int largeur) {
this.longueur=longueur;
this.largeur=largeur;
}
float perimetre() {
return 2*(longueur+largeur);
}
public String toString(){
return (“Le rectangle de longueur “+longueur
+” et de largeur “+largeur);
}
}
109
4.1. Classes abstraites
• Application:
– Tableau de formes géométriques (ellipses+rectangle)
class EssaiFormes {
public static void main(String [] args) {
Forme[] desFormes=new Forme[4];
desFormes[0]=new Ellipse(1,1);
desFormes[1]=new Ellipse(4,1);
desFormes[2]=new Rectangle(1,1);
desFormes[3]=new Rectangle(2,1);
for (int i=0; i<desFormes.length; i++)
desFormes[i].description();
}
}

Sortie:
L’ellipse de grand axe 1 et de petit axe 1 s’étale au moins comme un carré
L’ellipse de grand axe 4 et de petit axe 1 s’étale moins qu’un carré
Le rectangle de longueur 1 et de largeur 1 s’étale au moins comme un carré
110
Le rectangle de longueur 2 et de largeur 1 s’étale moins qu’un carré
4.2. Interface

• Problématique de l’héritage multiple:


– Java supporte uniquement l'héritage simple
– Problèmes de l'héritage multiple:
Les conflits de nommage La redondance de données
(héritage en diamant)
Class Point Class Couleur
Float x, y; Color coul; Classe A
void afficher() void afficher() Int x, y;
Classe B Classe C

Void afficher()
Int x, x, y, y; Classe D
111
Classe Point coloré
4.2. Interfaces

• Définition:
– Spécification du comportement d’un objet
– Classe Java ne possédant que des méthodes
abstraites et des champs finaux (constants).
• Syntaxe:
– Un nom d’interface peut être utilisé comme un
nom de classe.
– Si I est une interface, la déclaration “I i”
référencera par la variable “i” n’importe quel
objet d’une classe implémentant l’interface “I”
112
4.2. Interfaces
• Propriétés:
– Les méthodes abstraites doivent toutes être
implémentées par la classe qui en hérite
– Les interfaces permettent de simuler une sorte
d'héritage multiple sans ses inconvénients
– Les interfaces fournissent une interface
générique adaptable à chaque classe qui en
hérite
– Toutes les méthodes d'une interface sont par
défaut ‘public’: une classe qui implémente une
interface devra déclarer ‘public’ les méthodes
de l’interface qu’elle définira. 113
4.2. Interfaces
• Propriétés:
– Une classe peut étendre une seule classe mais
implémenter une ou +sieurs interfaces
– Toutes les méthodes d'une interface sont par
défaut abstraite. Il n'est pas nécessaire de les
préfixer du mot clé abstract
– Si une classe A implémente une interface I,
alors les sous-classes de A implémentent aussi
l’interface I.
– La bibliothèque Java est truffée d'interfaces
(Clonable, Runable, XXXListener,…) 114
4.2. Interfaces
• Exemple: Dessin de cercles et de carrés:
– L’interface Tracable
– La classe Cercle
– La classe CercleGraphique
– La classe Carré
– La classe CarréGraphique
– Un tableau de Tracables

115
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– L’interface Tracable

interface Tracable {
static final int DIM_MAX = 500;
void dessine(java.awt.Graphics g);
}

– Remarque:
• java.awt.Graphics
116
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– La classe Cercle
class Cercle {
private int rayon;
Cercle(int rayon) {
this.rayon=rayon;
}
static double circonference(Cercle cercle) {
return 2*Math.PI*cercle.rayon;
}
double circonference() {
return 2*Math.PI*rayon;
}
int getRayon() {
return rayon;
}
} 117
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– La classe CercleGraphique
class CercleGraphique extends Cercle implements Tracable {
int x,y;
java.awt.Color couleur;
CercleGraphique(int rayon,int x,int y,java.awt.Color couleur){
super(rayon);
this.x=x;this.y=y;this.couleur=couleur;
}
public void dessine(java.awt.Graphics g){
if (getRayon() < DIM_MAX) {
g.setColor(couleur);
g.drawOval(x-getRayon(), y-getRayon(),
2*getRayon(), 2*getRayon());
}
}
} 118
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– La classe Carré
class Carre {
int cote;
Carre(int cote) {
this.cote=cote;
}
int surface() {
return cote*cote;
}
}

119
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– La classe CarréGraphique
import java.awt.*;
class CarreGraphique extends Carre implements Tracable {
int x,y;
Polygon carre=new Polygon();
java.awt.Color couleur=color.black;
CarreGraphique(int cote,int x,int y){
super(cote);
this.x=x;this.y=y;
carre.addPoint(x-cote/2,y-cote/2);
carre.addPoint(x+cote/2,y-cote/2);
carre.addPoint(x+cote/2,y+cote/2);
carre.addPoint(x-cote/2,y+cote/2);
carre.addPoint(x-cote/2,y-cote/2);
}
... 120
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– La classe CarréGraphique
...
CarreGraphique(int cote,int x,int y, Color couleur{
this(cote,x,y);
this.couleur=couleur;
}
public void dessine(java.awt.Graphics g){
if (cote < DIM_MAX) {
g.setColor(couleur);
g.drawPolygon(carre);
}
}
}

121
4.2. Interfaces

• Exemple: Dessin de cercles et de carrés:


– Un tableau de Tracables
import java.awt.*;
class EssaiTracable extends Frame {
Tracable[] desFormes = new Tracable[5];
EssaiTracable(String titre){
super(titre);
desFormes[0] = new CercleGraphique(150,200,200,Color.orange);
desFormes[1] = new CercleGraphique(20,130,150,Color.blue);
desFormes[2] = new CercleGraphique(20,270,150,Color.blue);
desFormes[3] = new CarreGraphique(20,200,220,Color.magenta);
desFormes[4] = new CarreGraphique(30,200,300,Color.pink);
}
public void paint(Graphics g) {
for (int i=0;i<desFormes.length;i++)
desFormes[i].dessine(g);
}
public static void main(String[] args) {
EssaiTracable monDessin=new EssaiTracable(“une tete”);
monDessin.setSize(400,400);
monDessin.setVisible(true);} 122
}
4.2. Interfaces

• L’interface Cloneable:
– Problème:
• original et copie d’un obj=références au même objet
• on désire que la copie soit vraiment un nouvel objet
– Contrainte: méthode clone() de Object protégée
–Solution:
• implémenter l’interface Cloneable
• redéfinir la méthode clone() en y associant le
modificateur d’accès public
– Application
123
4.3. Classes internes
• Définition:
– Classe définie à l’intérieur d’une autre classe
• Raisons:
– Un objet d’une classe interne peut accéder à
l’implémentation de l’objet qui l’a créé – y compris
les données privées –.
– Les classes internes peuvent être cachées aux
autres classes du même package.
– Les classes internes sont très pratiques lorsqu’on
écrit des gestionnaires d’évènements
– Classes internes anonymes: utiles pour définir des
callbacks (mécanisme de communication entre une
classe courante et la classe appelante) 124
4.3. Classes internes
• Une interface Property:
– Construction d’un éditeur de propriété: fiche qui
présente les propriétés de divers objets et permet
de les modifier.
– Propriété: ressource ayant un nom, une valeur, et
permettant une nouvelle propriété.
• Syntaxe:
interface Property {
public String get();
public void set(String s);
public String name();
} 125
4.3. Classes internes
• Classe interne privée pour implémenter l’interface Property:
class Employee {

private class SalaryProperty implements Property
{private boolean isSet = false;
public String get() {…};
public void set(String s) {…};
public String name() {…};
}
public Property getSalaryProperty() {
return new SalaryProperty();
}
} 126
4.3. Classes internes
• Notation:
– Implémentation des méthodes de la classe interne:
La méthode set():
public void set(String s)
{
if (this.isSet) return;
double sal = Double.parseDouble(s);
if (sal >0) {
Employee.this.salary = sal;
this.isSet = true;
}
}

127
4.3. Classes internes
• Représentation d’un objet d’une classe interne:
– Un objet d’une classe interne obtient toujours une
référence implicite vers à l’objet créateur (pour pouvoir
accéder aux champs de l’objet externe qui a créé l’objet
interne).

128
4.3. Classes internes
• Utilité, nécessité et sécurité des classes internes: solution
alternative
class Employee {
private String name; private double salary; private Date hireDay;
public Property getSalaryProperty() {return new SalaryProperty();}
}
class SalaryProperty implements Property
{private boolean isSet = false;
public String get() {return outer.salary;}; //erreur: salary est private
public void set(String s) {…};
public String name() {…};
SalaryProperty(Employee o) { outer = o;}
private Employee outer;
}
129
4.3. Classes internes
• Classes internes locales et anonymes:
– Le nom du type SalaryProperty n’est nécessaire que lorsque l’on crée un
objet d’un de ces types avec la méthode getSalaryProperty():
– Java permet de définir une classe localement à l’intérieur d’une seule
méthode:

130
4.3. Classes internes
• Classes internes locales et anonymes:
class Employee {
private String name;private double salary;private Date hireDay;
public Property getSalaryProperty() {
class SalaryProperty implements Property {
private boolean isSet = false;
public String get() {return “”+salary;};
public void set(String s) {
if (isSet) return; double sal = Double.parseDouble(s);
if (sal >0) {salary = sal; isSet = true;};
public String name() {return name+”; salaire”;};
}
return new SalaryProperty();
} 131
}
4.3. Classes internes
• Classes internes locales et anonymes:Si 1 seule instance de la classe
SalaryProperty sera créée, il n’est pas nécessaire de lui donner un nom:
class Employee {
private String name;private double salary;private Date hireDay;
public Property getSalaryProperty() {
return new Property() {
private boolean isSet = false;
public String get() {return “”+salary;};
public void set(String s) {
if (isSet) return; double sal = Double.parseDouble(s);
if (sal >0) {salary = sal; isSet = true;};
public String name() {return name+”; salaire”;};
}
}
132
}
4.3. Classes internes
• Classes locales accédant à des variables locales:
Autoriser le changement du salaire un nombre de fois limité:
public Property getSalaryProperty(final int maxSetCount) {
{ class SalaryProperty implements Property {
public String get() {return “”+salary;};
public void set(String s) {
if (setCount >= maxSetCount) return;
double sal = Double.parseDouble(s);
h if (sal >0) {salary = sal; setCount++;};
public String name() {return name+”; salaire”;};}
private int setCount = 0;
}
Property p = new SalaryProperty();
return p;
133
}
4.3. Classes internes
• Classes internes statiques (nested class):
– Permet de cacher simplement une classe dans une autre, sans
avoir besoin de fournir à la classe interne une référence à un objet
de la classe externe: à cette fin, la classe interne est déclarée
statique.
– Avantage: dans un grand projet, il se peut que plusieurs
programmeurs aient l’idée de choisir de créer des classes
différentes ayant le même nom, ce qui entraînerait un conflit
potentiel.
– Il suffit de déclarer la classe interne statique.
– Exemple:
class ArrayAlg {
public static class Pair { …
}

134
}
4.4. Les collections
• Les interfaces de collection
• Les collections concrètes
• Le cadre des collections

135
4.4 Les collections
• Définition:
– Ensemble de structures de données fournies en
packages
– Algorithmes associés pour manipuler ces sdd
• Enjeux:
– Programmation plus rapide et aisée
– Meilleures performances:
• rapidité d’exécution
• consommation mémoire minimale
– Manipulation de données de grande taille
– Disposition triée des données
– Contrôle de l’augmentation de la taille des données136
4.4. Les collections
• Ressources:
– Interfaces de collections associées
– Classes d’implémentation
– Algorithmes de mise en œuvre
– Itérateurs qui parcourent les données

137
4.4.1. Les interfaces de collection
• Version 1.1 du jdk:
– Ensemble réduit de classes pour les structures de
données les plus utiles: Vector, Stack, Hashtable,
Bitset et l’interface Enumeration
• Version 1.2 de Java:
– Ensemble complet de structures de données
– Souci de simplicité et de taille réduite (<>
Standard Template Library de C++)
– Bénéficier de l’aspect générique mis en place par
STL
– Inclure les anciennes classes
138
4.4.1. Les interfaces de collection
• Séparer les interfaces d’une collection de leur
implémentation:
– L’interface fondamentale des classes de collection
en Java est: java.util.Collection
– 2 méthodes essentielles:
• boolean add(Object obj): ajoute un objet dans la
collection (renvoi false si la collection n’a pas été
modifiée)
• Iterator iterator(): revoi un objet qui implémente
l’interface Iterator. 3 méthodes fondamentales:
139
– Object next(), boolean hasNext(), void remove()
4.4.1. Les interfaces de collection
• L’itérateur:
– La méthode remove(): Elle supprime l’élément renvoyé
par le dernier appel à next()
Iterator it = c.iterator();
it.next(); // sauter le premier élément
it.remove(); // on peut maintenant le supprimer
it.remove(); //erreur il faut le précéder de it.next()
– Pas de méthode add(): dans une collection, la position à
laquelle a lieu l’ajout n’a pas d’importance

Élément renvoyé itérateur 140


4.4.1. Les interfaces de collection
• Exploitation des itérateurs et collections:
– Écriture de méthodes pratiques générales pouvant
travailler sur n’importe quel type de collection.
– Exemple:
public static void print(Collection c) {
System.out.print(« [ » );
Iterator it = c.iterator();
while (it.hasNext())
System.out.print(it.next()+ « »);
System.out.print(« ] » );
}
141
4.4.1. Les interfaces de collection
• Méthodes de la classe java.util.Collection:
– Iterator iterator()
– int size()
– boolean isEmpty()
– boolean contains(Object obj)
– boolean containsAll(Collection other)
– boolean add(Object element)
– boolean addAll(Collection other)
– boolean remove(Object obj)
– boolean removeAll(Collection other)
– void clear()
142
4.4.2. Les collections concrètes
• Les listes chaînées: la classe LinkedList
– Collection classée (position des objets
importante)
• LinkedList.add ajoute un objet en fin de liste
• sous-interface ListIterator de Iterator, contenant
add (l’interface Iterator est insuffisante)
– En java, les listes sont doublement chaînées:
interface ListIterator extends Iterator {
void add(Object); // l’ajout a toujours lieu
Object previous();
boolean hasPrevious();…
} 143
4.4.2. Les collections concrètes
• Les listes chaînées: la classe LinkedList
– Modification d’une valeur:
la méthode set() de ListIterator()
• Contrainte: accès concurrent , r/w
• Solution: une exception
CurrentModificationException est générée
– Accès à un élément particulier: la méthode
get()
• Contrainte: accès lent! (Object o = list.get(n);)
• Solution: à éviter 144
4.4.2. Les collections concrètes
• Les listes de tableaux: la classe ArrayList
– Implémente l’interface List
– Comparable à un Vecteur: encapsule un tableau
dynamique relogeable Object[]
– Mais: n’utilise pas la synchronisation (à la
différence de la classe Vector, où toutes les
méthodes sont synchronisées) donc + rapide
– L’utilisation est aussi simple qu’un vecteur (il
suffit de se souvenir de remplacer les méthodes
elementAt par get et setElementAt par set)
145
4.4.2. Les collections concrètes
• Les tables de hachage: la classe HashSet
– Les classes LinkedList et Array:
• Avantage: Spécifier l’ordre dans lequel on désire
organiser des éléments
• Inconvénient: localisation lente de l’élément recherché
si sa position est inconnue
– La table de hachage:
• Définition: Structure de données associant à chaque
élément un code de hachage (nombre entier associé à
tout élément,dont le calcul est très rapide)
• Avantage: localisation rapide de tout élément de liste
• Inconvénient: n’accorde pas d’importance à l’ordre
des éléments 146
4.4.2. Les collections concrètes
• Les tables de hachage: la classe HashSet
– Structure: tableau de listes chaînées
• 1 liste = 1 seau (panier ou bucket)
• Localisation d’un élément:
Position d’un élément dans la table
=
code de hachage – un modulo du nombre total de sots
• Exemple: Objet: code de hachage = 345; 101 seaux;
position: reste 345/101=42
• En cas de collision de hachage, il faut comparer avec les
objet existants
147
4.4.2. Les collections concrètes
• Les tables de hachage: la classe HashSet
– Caractéristiques d’un HashSet:
• Capacité initiale: (101 par défaut)
– Nombre premier; ~150% du nombre d’éléments prévu
– Exemple: 100 éléments; capacité 151
• Facteur de charge: (0.75 par défaut)
– Taux de remplissage de la table
– Au delà de cette valeur, la table est automatiquement
réorganisée avec le double de seaux
• Constructeurs: HashSet()
HashSet(int i)
HashSet(int i, float l)
148
4.4.2. Les collections concrètes
• Les tables de hachage: la classe HashSet
– Performances:
• Non synchronisée (<> classe HashTable)
• Si trop d’éléments sont insérés dans la table de
hachage, alors le nombre de collisions augmente et
les performances de recherche diminuent
– Fonctions de hachage:
• Valeur de retour de la méthode « public int
hashCode() »
• La méthode « public boolean equals(Object o) »:

149
4.4.2. Les collections concrètes
• Les arbres de hachage: la classe TreeSet
– Définition: collections triées par ordre croissant
– Ajout d’un élément plus lent que s’il fallait
l’ajouter dans une table de hachage, mais plus
rapide qu’un tableau trié ou liste chaînée
– Performances:
Nombre total Nombre de mots HashSet TreeSet
de mots: uniques
28195 5909 5 sec 7 sec
466300 37545 75 sec 98 sec
150
4.4.2. Les collections concrètes
• Les arbres de hachage: la classe TreeSet
– Comparaison d’objets: fonction définie dans
l’interface java.lang.Comparable, définissant une
seule méthode: int compareTo(Object other)
– À implémenter si comparaison d’objet définis par le
programmeur
– Exemple:
class Item implements Comparable {
public int compareTo(Object other)
{ Item otherItem = (Item) other;
return partNumber –otherItem.partNumber;
}

} 151
4.4.2. Les collections concrètes
• Les arbres de hachage: la classe TreeSet
– Ressources:
• java.lang.Comparable
– int compareTo(Object other)
• java.util.Comparator
– int compare(Object a, Object b)
• java.util.SortedSet
– Comparator comparator()
– Object first()
– Object last()
• java.util.TreeSet
– TreeSet(Comparator c)
152
– TreeSet(SortedSet elements)
4.4.2. Les collections concrètes
• Les cartes: les classes HashMap et TreeMap
– Définition: collections de paires (valeurs
indexées par des clés)
– Extraction d’une vue d’une carte; 3 vues:
• Ensemble des clés: Set keySet()
• Ensemble des valeurs: Collection values()
• Ensemble des paires clés/valeurs: Set entrySet()

153
5. Exceptions
• Problématique
– Traitement des erreurs sémantiques
• Erreurs syntaxiques détectées à la compilation.
• Erreurs sémantiques uniquement à l'exécution: à traiter
– Principales approches de traitement des erreurs
• Test des codes de retour (ex. C) à l'appel de chaque fonction
• Utilisation des exceptions
– Inconvénients du traitement des erreurs par le
test des codes de retour
• Risque d'oubli du traitement des valeurs de retour
• Forte déperdition de code liée à des tests multiples
• Programme souvent peut lisible if - return - case ...
• Valeur de retour des fonctions ne sert plus à retourner des
154
rés.
154
5. Exceptions

• Définition
– Notion
• Comportement intervenant lorsque le déroulement
du programme ne peut pas continuer dans les
conditions normalement définies
– Ressources associées
• Une exception est un objet Java à part entière
créé et contenant l ’information relative au
problème.
– Remontée d'erreurs
• Tâche déléguée au noyau du langage.
155
• Remontée d’erreurs automatique
5. Exceptions

• Mécanisme des exceptions


– Règles générales
• A la réception d'une exception, le code est arrêté, et
Java recherche en local puis dans la liste des
appelants la façon de traiter cette exception
– Mots-clé
• try-catch-finally: intercepter et traiter une exception
• throws: lister les exceptions à intercepter lors de
l'appel d'une méthode
• throw: permet de lever une exception
• L'utilisateur peut créer ses propres exceptions
156
5. Exceptions

• Mécanisme des exceptions


– Comportement:
• Algorithme:
si (exception générée) alors
l ’exception n ’est pas attrapée par la méthode en cours
si méthode en cours == main alors fin du programme
sinon
remontée de l ’exécution à la méthode I ’
qui a appelé la méthode I en cours
I ’ lance une exception
fin si
fin si
157
5. Exceptions

• Mécanisme des exceptions


– Comportement:
• Une exception levée et qui n ’est pas attrapée
provoque la fin du programme, en indiquant à
l ’utilisateur la pile de méthodes traversées par
l ’exception:
– pas de clause try...catch
– une méthode susceptible de lancer une exception sans
l ’attraper doit l ’indiquer dans son entête: mot clé throws

158
5. Exceptions

• Attraper une exception: couple “try...catch”


– try : délimite la portion de code à surveiller
Syntaxe: try { ... I;…}
– catch : capture et traite une exception
Syntaxe: try { ... I;…}
catch (ExceptionClass e) {…}
– Un try peut prendre en charge +ieurs exceptions
• Chacune d'elles sera traitée par un catch approprié

159
5. Exceptions
• Exemple de clause try...catch:
– sortie du programme:
C:\>Java ExceptionCatch 20 ha 14 14
Note 2 n’est pas entière
La moyenne est 16

C:\>Java ExceptionCatch 15.2 ha 15.5


Note 1 n’est pas entière
Note 2 n’est pas entière
Note 3 n’est pas entière
java.lang.ArithmeticException:/by zero
at ExceptionCatch.moyenne (:22)
at ExceptionCatch.main (:27)

160
5. Exceptions

• Finaliser une exception: la clause finally


– Ajouter un traitement commun au traitement
spécialisé de chaque exception: bloc
d'instructions exécuté à tous les coups
(exception levée ou non)
– Syntaxe complète de gestion d ’une exception:
try { // code pouvant lever une exception
…}
[catch (MyExceptiontype e){ // code a exécuter
…} // si MyExceptiontype est levée
catch (Exception e) { System.out.println(e.toString());
}]
finally { // code toujours exécuté 161
}
5. Exceptions

• Catégories d'exceptions
– Exceptions prédéfinies
– Exceptions définies par le programmeur
• Catégories d’exceptions prédéfinies
– RuntimeException
• Dues à une erreur de programmation
(mauvais typage, dépassement borne de tableau,etc)
– Les autres
• Dépasser la fin d’un fichier en lecture
• Accéder à une URL incorrecte 162
• Emploi d’un nom de classe inexistant
5. Exceptions

• Créer ses propres exceptions


– But: signaler un évènement exceptionnel d’un
type non prévu par les API.
– Démarche:
• étendre la classe java.lang.Exception
• le corps de la classe ne contient pas plus que:
– la définition d’un constructeur
– la redéfinition de la méthode toString()
– Exemple:
class ExceptionRien extends Exception {
public String toString() {
return “Aucune note n’est valide”;}} 163
5. Exceptions
• Créer ses propres exceptions:
– Contraindre la levée d ’une exception:
• Le mot clé throw permet de lever une exception
• Le mot clé throws permet de fournir pour une
méthode donnée, la liste des exceptions:
– susceptibles d ’être levées par cette méthode (obligatoire,
sauf pour les exceptions les plus courantes de l ’API).
– qui ne seront pas attrapées par ladite méthode par une
clause try-catch

164
5. Exceptions
• Conseils sur l’utilisation des exceptions
– Relancer les exceptions
– La gestion des exceptions n’est pas supposée
remplacer un test simple
– Ne faites pas une gestion ultra fine des
exceptions
– Ne pas avoir honte de propager les exceptions
• Application:
– Classe propagation
– Classe finally
165
6. Programmation graphique

6.1. Gestionnaires de présentation


6.2. Mise en oeuvre des traitements
6.3. Programmation graphique visuelle

166
6.1. Gestionnaires de présentation

6.1.1. Principaux objets graphiques


6.1.2. Objets Graphiques de type Container
6.1.3. Rôle d'un Layout Manager
6.1.4. Choix d'un Layout Manager
6.1.5. Principaux Layout Managers

167
6.1.1. Principaux objets graphiques

• Écriture de programmes utilisant une GUI


• Composants lourds: AWT
– Abstract Window Toolkit (package java.awt)
– C'est le premier outil de Fenêtrage de Java
– Objets graphiques : classe dans le package java.awt.*
• Exemple : java.awt.Panel, java.awt.Button
– Ils nécessitent l'inclusion du package java.awt:
• import java.awt.*;

• Composants allégés: Swing


– Fait partie des JFC (package javax.swing)
– Plut lent à s’afficher
– Éléments d’interface étendu et plus pratique
– Moins dépendant de la plate-forme d’exécution: 3 interfaces
look&feel spécifiques
168
6.1.1. Principaux objets graphiques
• Sous AWT:
– Containers (Windows, Panel, Frame, Applet)
– Fonds (Canvas) adaptés aux dessins d'images
– Composants de base (bouton, étiquettes, champs
textes, listes déroulantes, radios, cases à cocher, barres
de défilement, …)
• Sous SWING:
– Equivalent Swing à +part des composants awt : le nom
possède simplement un préfixe “J”
• Exemple: JPanel, JFrame
– JFrame : un des rares composants lourds Swing

169
6.1.1. Principaux objets graphiques
• Arboresence des objets graphiques: JCheckBox
Button Applet

Canvas Panel Jtoggle


JList Button

Checkbox AbstractButton JButton

Choice JComponent JPanel

Object Component Container Windows Dialog FileDialog

Label Frame
NOTE :
List JFrame
Les menus
Scrollbar TextField
sont dans une
arborescence séparée TextComponent TextArea 170
6.1.2 Objets de type Container

• Container:
– Composant AWT contenant d'autres
composants graphiques (y compris d’autres
containers).
– Types de containers:
• Panneaux (Panel, applets)
• Fenêtres (Windows, Frame, Dialog, FileDialog)

171
6.1.2 Objets de types Container

• Panneau (Panel):
– Composant AWT permettant de regrouper
d'autres composants AWT dans la fenêtre
(Frame) courante
– N'est pas redimensionnable ni iconifiable
– N'existe que parce qu'il est dans une Frame
– Exemple: applet = type de Panel spécifique
apparaissant dans la fenêtre d'un navigateur.

172
6.1.2 Objets de types Container

• 1.5. Propriétés d’un Jpanel


– La méthode paintComponent(Graphics)
class MyPanel extends JPanel {
public void paintComponent( Graphics g)
{
super.paintComponent(g)
…;
}
Container contentPane = monCadre.getContentPane()
Component c = …; // exemple: JPanel c=new MyPanel();
173
contentPane.add(c);
6.1.2 Objets de type Container

• Fenêtre (Windows):
– Containers indépendants.
– On distingue :
(1) les Frame : servent à définir des fenêtres
principales redimensionnables, iconifiables
(2) les Dialog : fenêtres sans menus pouvant
être modale

174
6.1.2 Objets de type Container
Title
- Gère l’aspect
Look and Feel
- Contient les différents
composants
JFrame
JRoot
JLayeredPane
Barre de menus (option)
Couche du contenu
Vitre
175
6.1.3. Rôle d’un Layout Manager
• Définition:
– “Layout Manager”, “Gestionnaire de Présentation” ou
“Gestionnaire de mise en forme”: classe permettant de
gérer la répartition des objets de l'interface
utilisateur (boutons, etc) dans un Container.
– On distingue les Layout Manager suivants :
• FlowLayout GridBagLayout
• BorderLayout CardLayout
• GridLayout BoxLayout
Personnalisé

176
6.1.4 Choix d'un Layout Manager

• La méthode setLayout de la classe


Container:
– Permet de fixer le type de Layout Manager
– Les profiles de cette méthode :
• setLayout(FlowLayout fl);
• setLayout(BorderLayout bl);
• setLayout(GridLayout gl);
• setLayout(CardLayout cl);

177
6.1.4 Choix d'un Layout Manager

• Note :
– L'ajout d'un composant dans un container se
fait via sa méthode add.
– Cette méthode est surchargée pour chaque
type de composant pouvant être ajouté à un
container.
add(Component c);
add(Component c, int i);
add(String s, Component c);
178
6.1.5. Principaux Layout Managers
• Le FlowLayout Manager
– Le plus simple Layout Manager (par défaut pour un
composant JPanel)
– Aligne les composants dans un container selon l'ordre de
leur arrivée : gauche à droite, ligne par ligne
– Supporte les composants de tailles différentes
– Trois constructeurs associés au FlowLayout:
• public FlowLayout();
• public FlowLayout(int align);
• public FlowLayout(int align, int hgap, int vgap);
– align = FlowLayout.[LEFT, CENTER, RIGHT]
– hgap et vgap = espacement horizontal et vertical (en pixel)

179
6.1.5. Principaux Layout Managers
• Le FlowLayout Manager
import java.awt.*;
import javax.swing.*; class PlafFrame extends JFrame {
class PlafPanel extends JPanel { PlafFrame(){
public PlafPanel(){ setTitle("PlafTest"); setSize(300,200);
rouge = new JButton(“Rouge"); Container contentPane = getContentPane();
vert = new JButton(“Vert"); JPanel c = new PlafPanel();
bleu = new JButton(“Bleu"); contentPane.add(c);
setLayout(new FlowLayout( }
}

FlowLayout.LEFT,30,30));
add(rouge);
add(vert);
add(bleu);
} public class PlafTest{
private JButton rouge; public static void main(String[] args){
private JButton vert; JFrame frame = new PlafFrame();
frame.show();}} 180
private JButton bleu;
6.1.5. Principaux Layout Managers
• Le BorderLayout Manager:
– Layout Manager par défaut, associé à l’objet
contentPane d’une fenêtre Jframe (ajout dans la zone
par défaut: le centre)
– Aligner les composants selon l'une des zones
géographiques : North, South, East, West, Center
• Un seul composant par zone géographique
• Largeur comp. North / South = largeur du Lay. Man.
• Hauteur comp. West/East = hauteur du Lay. Man.
• Composant de la zone Center: comble le reste
– 2 constructeurs pour créer des BorderLayout
• public BorderLayout();
• public BorderLayout(int hgap, int vgap);
181
– hgap et vgap correspondent à l'espacement horizontal et vertical
6.1.5. Principaux Layout Managers
• Le BorderLayout Manager:
import java.awt.*; import java.awt.event.*;
import javax.swing.*; class PlafFrame extends JFrame {
class PlafPanel extends JPanel { PlafFrame(){
public PlafPanel(){ setTitle("PlafTest"); setSize(300,200);
nord = new JButton("Nord"); Container contentPane = getContentPane();
sud = new JButton("Sud"); JPanel c = new PlafPanel(); contentPane.add(c);
est = new JButton("Est"); }}
ouest = new JButton("Ouest"); public class TestBorderLayout{
centre = new JButton("Centre"); public static void main(String[] args){
setLayout(new BorderLayout(10,10)); JFrame frame = new PlafFrame();
add(nord,BorderLayout.NORTH); frame.show();
add(sud,BorderLayout.SOUTH); }}
add(est,BorderLayout.EAST);
add(ouest,BorderLayout.WEST);
add(centre,BorderLayout.CENTER);
}
private JButton nord; private JButton sud;
private JButton est; private JButton ouest;
private JButton centre;} 182
6.1.5. Principaux Layout Managers
• Le GridLayout Manager
– Subdivise un container en lignes et en colonnes.
Chaque composant ajouté dans le container est mis
dans une des cases, de gauche à droite
– La taille de chaque case est identique
– 2 constructeurs permettent de créer des GridLayout
• public GridLayout(int rows, int cols);
• public GridLayout(int rows, int cols, int hgap, int vgap);
– rows et cols correspondent aux nombres de lignes et colonnes
– hgap et vgap correspondent à l'espacement horizontal et
vertical

183
6.1.5. Principaux Layout Managers
• Le GridLayout Manager
import java.awt.*; import java.awt.event.*; class PlafFrame extends JFrame {
import javax.swing.*; PlafFrame(){
class PlafPanel extends JPanel{ setTitle("PlafTest"); setSize(300,200);
public PlafPanel(){ Container contentPane =
b1 = new JButton("bouton1"); b2 = new getContentPane();
JButton("bouton2"); JPanel c = new PlafPanel();
b3 = new JButton("bouton3"); b4 = new contentPane.add(c);
JButton("bouton4"); }}
b5 = new JButton("bouton5"); public class TestGridLayout{
setLayout(new GridLayout(3,2)); public static void main(String[] args){
add(b1); add(b2); add(b3); add(b4); add(b5); JFrame frame = new PlafFrame();
frame.show(); }}
}
private JButton b1; private JButton b2;
private JButton b3; private JButton b4;
private JButton b5;

}
184
6.1.5. Principaux Layout Managers
• Le GridBagLayout Manager
– Variante de GridLayout
– Chaque composant peut avoir une taille
différente.
– Nécessite l'initialisation d’une ou plusieurs
variables de la classe GridBagConstraints.
NONE, RELATIVE, HORIZONTAL, …,
CENTER, ..., BOTH
– Application

185
6.1.5. Principaux Layout Managers
• Le CardLayout Manager
– Permet d'empiler des composants dans un container
sous forme de carte.
– Composants ne sont pas visibles simultanément:
affichage de la carte souhaitée par programmation
Taille de chaque case identique
– 2 constructeurs:
• public CardLayout();
• public CardLayout( int hgap, int vgap);
– hgap et vgap : espacement horizontal et vertical

186
6.1.5. Principaux Layout Managers
• Le CardLayout Manager
import java.awt.*; public void exec(){
import java.awt.event.*; f=new Frame("Test du Card Layout");
public class TestCardLayout implements ActionListener { c= new CardLayout(100, 75);
private Frame f; f.setLayout(c);
private Button b1, b2, b3, b4, b5; f.add("Bouton 1", b1=new Button("Bouton 1"));
CardLayout c; f.add("Bouton 2", b2=new Button("Bouton 2"));
public static void main(String args[]){ f.add("Bouton 3", b3=new Button("Bouton 3"));
TestCardLayout tcardl = new TestCardLayout(); f.add("Bouton 4", b4=new Button("Bouton 4"));
tcardl.exec(); f.add("Bouton 5", b5=new Button("Bouton 5"));
} b1.addActionListener(this);
public void actionPerformed(ActionEvent e){c.next(f); b2.addActionListener(this);
} b3.addActionListener(this);
b4.addActionListener(this);
b5.addActionListener(this);
f.pack(); f.setVisible(true);
}
}
187
6.1.5. Principaux Layout Managers
• Le BoxLayout Manager:
– Permet de placer une seule ligne ou colonne de
composants avec plus de souplesse que le GridLayout
– La classe Box:
• Conteneur dont le gestonnaire par défaut est BoxLayout
• Création d’un nouveau conteneur avec BoxLayout:
– Box b = Box.createHorizontalBox();
Ou
– Box b = Box.createVerticalBox();
• Ajout de composants:
b.add(boutonok);
b.add(boutonannuler); 188
6.1.5. Principaux Layout Managers
• Le BoxLayout Manager:Réserves:
• par défaut, il n’y a pas d’espace entre les composants d’un
BoxLayout.
• Les réserves (filler) permettent d’espacer les éléments:
– Strut: ajoute peu d’espace entre composants
b.add(boutonok);
b.add(Box.createHorizontalStru(5)); //createVerticalStrut()
b.add(boutonannuler);
– RigidArea: analogue à une paire de Strut
b.add(Box.createRigidArea(new Dimension(5, 12));
– Glue: effet opposé de Strut
b.add(boutonok);
b.add(Box.createGlue(5)); //createHorizontalGlue();
//createVerticalGlue();
b.add(boutonannuler);
189
• java.awt.Component.getAlignementX(); getAlignementY();
6.2. Programmation graphique

6.2.1. Définitions
6.2.2. Modèle d’évènements JDK 1.1
6.2.3. Récapitulation (JDK 1.1)
6.2.4. Exemples

190
6.2.1 Définitions

• Interface graphique:
– Ensemble de composants graphiques disposés dans
une fenêtre principale, considérée elle-même comme
composant graphique
– Certains composants peuvent en contenir d’autres
– Divers types de composants (bouton, liste, etc)
– A chaque type de composant est associée une
interface,
– Toutes ces interfaces héritent de l’interface origine
EventListener
191
6.2.1 Définitions

• Evénement
– Objet décrivant ce qui s'est passé lorsqu'un utilisateur
interagit avec un composant graphique (bouton, champ
texte, …) appartenant à une interface graphique
– Exemples :
• Les événements souris
– Mouvement de la souris vers un composant graphique
– Clic sur un composant graphique
• Les événements Claviers
– Appui sur une touche
– Relachement d'une touche
192
6.2.1 Définitions

• Adaptateur:
– Toute instance d’une classe implémentant une
interface héritée de EventListener
– Il existe une interface qui hérite de EventListener
pour chaque type d’évènement pouvant se produire
– Moyen efficace pour traiter les évènements depuis la
version 1.1 de Java

193
6.2.2 Modèle d'évènements JDK1.1

• La notion de délégation
– Il sépare l'écoute et le traitement d'un évènement.
– Le traitement d'un événement est délégué à
une classe distincte qui implémente l'interface des
classe dites écouteurs.
• Exemple : ActionListener est une interface dont la
méthode à implémenter est actionPerformed
• NOTE : Il est conseillé de définir ses classes comme
étant des classes internes à la classe principale pour
faciliter l'accès aux champs de cette dernière.

194
6.2.2 Modèle d'évènements JDK1.1

• La notion de délégation
– Chaque composant désirant écouter doit par
contre se faire enregistrer via sa méthode
addXXXListener(). XXX représente le type
d'événement.
• Exemple : addActionListener(ActionListener) pour
les événements de type ACTION.
• Note : un composant ne réagit à un événement que s'il
s'est enregistré pour l'écouter

195
6.2.2. Modèle d’évènements JDK 1.1

• Gestion des évènements:


– Intervenants (sous AWT/Swing):
– Objet écouteur: listener interface
– Source d’évènement: objet graphique
– Mécanisme sous-jacent:
1. Production d’un événement : envoie de l’objet à tous les
écouteurs recensés
2. Les objets écouteurs déterminent leur réponse
Objet AWT/Swing XXXListener (ECOUTEUR)
Frame/JFrame
Panel/JPanel ActionListener,
Button/JButton MouseListener

196
Evénément de type Action Evénément Souris Traitement des événéments
6.2.2. Modèle d’évènements JDK1.1

• Notification d’un évènement:


addActionListener
ButtonPanel JButton
actionPerformed

getObject

ActionEvent
197
6.2.2. Modèle d’évènements JDK 1.1

• Un écouteur de fenêtre:
MyFrame addWindowListener

windowClosing, windowClosed, …

Terminator

198
6.2.2. Modèle d’évènements JDK 1.1

• Capture des événements de fenêtre:


 Classe interne:
public class MyFrame extends JFrame {
public MyFrame() {
addWindowListener(new Terminator());
}

class Terminator implements WindowListener {
public void windowClosed(WindowsEvent e) {}
public void windowIconified(WindowsEvent e) {}
public void windowOpened(WindowsEvent e) {}
public void windowClosing(WindowsEvent e) {System.exit(0);}
public void windowDeiconified(WindowsEvent e) {}
public void windowActivated(WindowsEvent e) {}
public void windowDeactivated(WindowsEvent e) {}
}
…} 199
6.2.2. Modèle d’évènements JDK 1.1
• Les adaptateurs
– L'implémentation d'une Interface Listener implique
l'implémentation de toutes ses méthodes. Cela peut
être génant lorsqu'on ne désire qu'implémenter
quelques unes d'elles
• Exemple 1 : pour l'interface MouseListener nous ne
souhaitons implémenter que
– mouseClicked(MouseEvent)
– mouseExited(MouseEvent)
• Exemple 2 : pour l'interface WindowsListener nous ne
souhaitons implémenter que :
– windowsClosing(WindowsListener)

200
6.2.2. Modèle d’évènements JDK 1.1
• Les adaptateurs
– Java offre pour les Listener Interface ayant plus
d'une méthode à redéfinir des classes appelées
Adaptateurs. Ces classes implémentent les
méthodes de ces listener Interface avec un
code vide.

201
6.2.2. Modèle d’évènements JDK 1.1

• Capture des événements de fenêtre:


 Classe adaptateur:

public class MyFrame extends JFrame {


public MyFrame() {
addWindowListener(new Terminator());
}

class Terminator extends WindowAdaptor {
public void windowClosing(WindowsEvent e) {
System.exit(0);
}
}

}
202
6.2.2. Modèle d’évènements JDK 1.1

• Hiérarchie des évènements:


Event
Object

AWT
Event

Action Adjustment Component Item Text


Event Event Event Event Event

Container Focus Input Paint Window


Event Event Event Event Event

Key Mouse
Event Event 203
6.2.2. Modèle d’évènements JDK 1.1

• Gestion d'événements multiples:


– 1 év. p.e. écouté par +ieurs composants
• Exemple : Button bcarre, bracine;
...
bcarre.addActionListener(new ActionL());
bracine.addActionListener(new ActionL());
• Le traitement lié à chaque composant sera pris en charge par
la méthode à redéfinir (actionPerformed)
– 1 composant peut écouter +ieurs types d'év.
• Exemple: TextField tf;
...
tf.addMouseListener(new MouseL());
tf.addActionListener(new ActionL());

204
6.2.2. Modèle d’évènements JDK 1.1

• Avantages et incovénients
– Avantages
• un meilleur filtrage des événements devient
possible car à chaque type d'événement est
associé une classe d'événement. exemple :
ActionEvent
• la délégation du traitement d'événement à une
classe séparée implémentant l'interface
XXXListener (exemple ActionListener) permet de
bien séparer la source d'un évènement et son lieu
de traitement
• les java beans s'appuient sur ce modèle

205
un composant ne peut écouter des évéments que
6.2.2. Modèle d’évènements JDK 1.1

• Avantages et incovénients
– Inconvénients
• Modèle assez complexe comparé à celui du
JDK1.0

• il faut implementer toutes les methodes d'un


Listener Interface même si on n'en a besoin que
d'une. Les classes XXXadapter permettent de
résoudre ce problème.

• Incompatible avec le modèle du JDK1.0 206


6.2.3. Récapitulation (JDK 1.1)
• Principaux types d'évènements et Statut:
– Evémenements classés par type,
– Filtrage automatique sans passer par des
tests fastidieux.
– Les types d'événements :
• ActionEvent, ItemEvent, MouseEvent, KeyEvent,
TextEvent, ComponentEvent, ContainerEvent,
WindowsEvent, FocusEvent

207
6.2.3. Récapitulation (JDK 1.1)
Classe d'événements Les attributs et les méthodes

• Les principaux types d'événements et leur


ActionEvent String getActionCommand()
// Rend le Label du composant associé à une action

Statut int getModifiers()


// rend une valeur entière correspondant à
// la touche alternative : actionEvent.SHIFT_MASK,
// actionEvent.CTRL_MASK, actionEvent.ALT_MASK
// actionEvent.META_MASK

Object getSource()
// rend le nom de la variable de l'objet source

AdjustementEvent Adjustable getAdjustable()


(ajustement des scrollbar // rend le composant qui a généré l'événement
par exemple)
int getAdjustmentType()
// Rend le type d'adjustment survenu. La valeur peut - être
// l'une des constantes suivantes définie dans la classe
// AdjustementEvent :UNIT_INCREMENT,
// UNIT_DECREMENT, BLOCK_INCREMENT, BLOCK_DECREMENT, TRACK.

int getValue() 208


// Rend la valeur du composant avant que l'Adjustment intervient
6.2.3. Récapitulation (JDK 1.1)
Classe d'événements Les attributs et les méthodes
• Les principaux types d'événements et leur
ComponentEvent Component getComponent()

Statut // rend le composant ayant généré l'événement

ContainerEvent Component getChild()


// rend le composant dont l'ajout ou la suppression déclenche cet événement.
Container getContainer()
// rend le container ayant déclenché l'événement.

FocusEvent boolean isTemporary()


// Rend vrai si un composant a perdu temporairement le focus
// (curseur). Il recouvrera dès qu'on reviendra dans sa fenêtre.
Component getComponent()
// définit dans la classe ComponentEvent. Cette méthode
// Rend le type de composant ayant perdu ou reçu le focus.

ItemEvent Object getItem()


// Rend l'objet le label associé à un item dont l'état a changé.
ItemSelectable getItemSelectable()
// Rend le composant qui a généré l'événement.
int getStateChange()
209
//Rend le nouvel état de l'item : SELECTED ou DESELECTED
6.2.3. Récapitulation (JDK 1.1)
• Les principaux types d'événements et leur
Classe d'événements Les attributs et les méthodes

KeyEvent
Statut int getKeyChar()
void setKeyChar(char)
// Lit ou assigne le caractère associé à la touche appuyée. Caractères unicodes : 2 octets.
int getKeyCode()
void setKeyCode(int)
// Lit ou affecte le code d'une touche. La classe KeyEvent
// définit des constantes associées à chaque touche. Exemple :
// VK_A pour la touche A, VK_ESCAPE pour la touche ESCAPE.
Méthodes héritées de InputEvent
int getWhen()
// Retourne l'heure à laquelle l'événement est arrivé.
boolean isAltDown()
boolean isControlDown()
boolean isMetaDown()
boolean isShiftDown()
// Test l'état d'un touche alternative.
void setModifiers(int)
// Assigne l'état d'une touche alternative.
Méthode héritée de Component 210
Object getComponent()
6.2.3. Récapitulation (JDK 1.1)
• Les principaux types d'événements et leur
Classe d'événements Les attributs et les méthodes

MouseEvent
Statut int getClickCount()
// rend le nombre de clicks consécutifs opérés par l'utilisateur
int getX()
int getY()
Point getPoint()
// Rend les positions X et Y du lieu ou est survenu l'événement.
boolean isPopupTrigger()
// Rend vrai si l'événement cause l'affichage d'un menu popup
Méthodes héritées de InputEvent
int getWhen()
// Retourne l'heure à laquelle l'événement est arrivé.
boolean isAltDown()
boolean isControlDown()
boolean isMetaDown()
boolean isShiftDown()
// Test l'état d'un touche alternative.
void setModifiers(int)
// Assigne l'état d'une touche alternative.
Méthode héritée de Component 211
Object getComponent()
6.2.3. Récapitulation (JDK 1.1)
• Les principaux types d'événements et leur
Classe d'événements Les attributs et les méthodes

Statut
TextEvent getSource() // hérités Event object ???
// Rend le nom de la variable de l'objet de type texte.

WindowsEvent getWindows()
// Rend le nom de la fenêtre ayant générée l'événement.

212
6.2.3. Récapitulation (JDK 1.1)
• Les interfaces de Gestion d'événements
Evénément Nom interface Listener Méthodes d'interface du listener (à redéfinir)

ActionEvent ActionListener actionPerformed(ActionEvent)

AdjustementEvent AdjustementListener adjustementValueChanged(AdjustementEvent)

ComponentEvent ComponentListener componentHidden(ComponentEvent)


componentShown(ComponentEvent)
componentMoved(ComponentEvent)
componentResized(ComponentEvent)

ContainerEvent ContainerListener componentAdded(ContainerEvent)

FocusEvent FocusListener focusGained(FocusEvent), focusLost(FocusEvent)

KeyEvent KeyListener keyPressed(KeyEvent), keyReleased(KeyEvent)


keyTyped(KeyEvent)

213
6.2.3. Récapitulation (JDK 1.1)
• Les interfaces de Gestion d'événements
Evénément Nom interface Listener Méthodes d'interface du listener (à redéfinir)

MouseEvent MouseMotionListener mouseDragged(MouseEvent)


mouseMoved(MouseEvent)

WindowsEvent WindowsListener windowsOpened(WindowsEvent)


windowsOpened(WindowsEvent)
windowsOpened(WindowsEvent)
windowsOpened(WindowsEvent)
windowsOpened(WindowsEvent)
windowsOpened(WindowsEvent)
windowsOpened(WindowsEvent)

ItemEvent ItemListener itemStateChanged(ItemEvent)

TextEvent TextListener textValueChanged(TextEvent)

214
6.2.3. Récapitulation (JDK 1.1)
• Les adaptateurs
Interface avec adaptateurs Nom de l'adaptateur

ComponentListener ComponentAdapter

ContainerListener ContainerAdapter

FocusListener FocusAdapter

KeyListener KeyAdapter

MouseListener MouseAdapter

MouseMotionListener MouseMotionListenerAdapter

WindowsListener WindowsListenerAdapter

215
6.2.3. Récapitulation (JDK 1.1)
• Les composants et les événements qu'ils
Composants Evénements survenant sur le composant

Adjustable AdjustableEvent

Applet supportent
ContainerEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Button ActionEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Canvas FocusEvent, KeyEvent, MouseEvent, ComponentEvent

CheckBox ItemEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

CheckBoxMenuItem ActionEvent, ItemEvent

Choice ItemEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Component FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Container ContainerEvent, FocusEvent, KeyEvent, MouseEvent,ComponentEvent

Dialog ContainerEvent, WindowsEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

FileDialog ContainerEvent, WindowsEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Frame ContainerEvent, WindowsEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent 216


6.2.3. Récapitulation (JDK 1.1)
Composants Evénements survenant sur le composant

Label • Les composants et les événements qu'ils


FocusEvent, KeyEvent, MouseEvent, ComponentEvent

List supportent (suite)


ActionEvent, FocusEvent, KeyEvent, MouseEvent, ItemEvent, ComponentEvent

Menu ActionEvent

MenuItem ActionEvent

Panel ContainerEvent, FocusEvent, KeyEvent, MouseEvent,ComponentEvent

PopoMenu ActionEvent

ScrollBar AdjustmentEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Scrollpane ContainerEvent, FocusEvent, KeyEvent, MouseEvent,ComponentEvent

TextArea TextEvent, FocusEvent, KeyEvent, MouseEvent,ComponentEvent

TextComponent TextEvent, FocusEvent, KeyEvent, MouseEvent,ComponentEvent

TextField ActionEvent, TextEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent

Windows ContainerEvent, WindowsEvent, FocusEvent, KeyEvent, MouseEvent, ComponentEvent 217


6.2.4. Exemples

• Boutons
• Boutons radio
• Cases à cocher
• Souris
• Champs de texte
• Listes
• Etiquettes,
• etc.
218
6.2.4. Exemples

• JTextArea:
import java.awt.*; import java.awt.event.*; t2=new JTextArea(10,15);
import javax.swing.*; t2.setEditable(false);
public class TextAreaDemo extends JFrame { JScrollPane j2=new JScrollPane(t2);
private JTextArea t1,t2; private JButton cp; j2.setHorizontalScrollBarPolicy(
public TextAreaDemo() { JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
super("TextAreaDemo"); String s="Start";
Box b=Box.createHorizontalBox(); j2.setVerticalScrollBarPolicy(
JScrollPane.VERTICAL_SCROLLBAR_NEVER);
t1=new JTextArea(s,10,15);//lignes, colonnes b.add(j2);
JScrollPane j1=new JScrollPane(t1);
j1.setHorizontalScrollBarPolicy( Container c=getContentPane();
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER); c.add(b);
j1.setVerticalScrollBarPolicy( setSize(425,200); show();
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS); }
b.add(j1);
public static void main(String[] args) {
cp = new JButton("Copy>>>"); TextAreaDemo app = new TextAreaDemo();
cp.addActionListener( new ActionListener() { app.addWindowListener(new WindowAdapter()
public void actionPerformed(ActionEvent e)
{public void windowClosing(WindowEvent e)
{t2.setText(t1.getSelectedText());}}); {System.exit(0);}}); }}
b.add(cp); 219
6.2.4. Exemples

• Sous-classe personnalisée de JPanel:


import java.awt.*; cercle.addActionListener(new ActionListener() {
import java.awt.event.*; public void actionPerformed(ActionEvent e) {
import javax.swing.*; myPanel.dessiner(CustomPanel.CERCLE);}});
class CustomPanel extends JPanel { carre.addActionListener(new ActionListener() {
public static final int CERCLE=1,CARRE=2; public void actionPerformed(ActionEvent e) {
private int forme=0; myPanel.dessiner(CustomPanel.CARRE);}});
public void paintComponent(Graphics g){ buttonPanel = new JPanel();
super.paintComponent(g); buttonPanel.add(cercle); buttonPanel.add(carre);
g.setColor(Color.pink); Container c = getContentPane();
if (forme == 1) g.drawOval(50,50,50,50); c.setLayout(new BorderLayout());
if (forme == 2) g.drawRect(50,50,50,50); c.add(myPanel,BorderLayout.CENTER);
} c.add(buttonPanel,BorderLayout.SOUTH);
public void dessiner(int f) {forme = f; repaint();} setSize(300,150);show();
} }

class CustomPanelTest extends JFrame { public static void main(String[] args) {


JButton cercle; JButton carre; CustomPanelTest app = new CustomPanelTest();
JPanel buttonPanel; CustomPanel myPanel; app.addWindowListener(new WindowAdapter(){
CustomPanelTest() { public void windowClosing(WindowEvent e)
cercle=new JButton("Cercle"); carre=new JButton("Carre"); {System.exit(0);}});
myPanel = new CustomPanel(); }
myPanel.setBackground(Color.green); } 220
6.2.4. Exemples

• Sous-classe active de JPanel:


import java.awt.*; import java.awt.event.*; myPanel.addMouseListener(
import javax.swing.*; new MouseAdapter(){
class SelfContainedPanel extends JPanel { public void mousePressed(MouseEvent e){
private int x,y; int xOrigine,yOrigine; myPanel.xOrigine=e.getX();
boolean dessine=false; myPanel.yOrigine=e.getY();}}
public void paintComponent(Graphics g) { );
super.paintComponent(g); myPanel.addMouseMotionListener(
g.setColor(Color.yellow); new MouseMotionListener(){
if (dessine) public void mouseDragged(MouseEvent e){
g.drawOval(xOrigine,yOrigine,x-xOrigine,y-yOrigine); if (myPanel.dessiner == false) myPanel.dessine=true;
g.drawString("Position: x="+x+" y="+y,10,10); myPanel.draw(e.getX(),e.getY());}
} public void mouseMoved(MouseEvent e){
public void draw(int x,int y){this.x=x;this.y=y; repaint();} if (myPanel.dessiner == true) myPanel.dessine=false;
public Dimension getPreferredSize(){ myPanel.draw(e.getX(),e.getY());}}
return new Dimension(200,200); );
} Container c=getContentPane();c.setLayout(new FlowLayout());
} c.add(myPanel); setSize(300,150); show();
class SelfContainedPanelTest extends JFrame { }
SelfContainedPanel myPanel; public static void main(String[] args) {
SelfContainedPanelTest() { SelfContainedPanelTest app=new SelfContainedPanelTest();
myPanel = new SelfContainedPanel(); app.addWindowListener( new WindowAdapter(){
myPanel.setSize(myPanel.getPreferredSize()); public void windowClosing(WindowEvent e) {
myPanel.setBackground(Color.green); System.exit(0);}});}} 221
6.2.4. Exemples

• JSlider:
import java.awt.*; import java.awt.event.*; public static void main(String[] args){
import javax.swing.*; import javax.swing.event.*; SliderDemo app=new SliderDemo();
class SliderDemo extends JFrame { app.addWindowListener(
private JSlider diameter; private OvalPanel myPanel; new WindowAdapter(){
public SliderDemo(){ Orientation, Min, Max, Init public void windowClosing(WindowEvent e){
super("Slider Demo"); System.exit(0);}}
diameter=new JSlider(SwingConstants.HORIZONTAL,0,200,10); );
diameter.setMajorTickSpacing(10); //unité }
diameter.setPaintTicks(true); //échelle }
diameter.addChangeListener( class OvalPanel extends JPanel {
new ChangeListener() { private int diameter = 10;
public void stateChanged(ChangeEvent e) { public void paintComponent(Graphics g){
myPanel.setDiameter(diameter.getValue());}}); super.paintComponent(g);
myPanel=new OvalPanel(); g.fillOval(10,10,diameter,diameter);
myPanel.setBackground(Color.yellow); }
Container c=getContentPane(); public void setDiameter(int d){
c.add(diameter,BorderLayout.SOUTH); diameter = d;
c.add(myPanel,BorderLayout.CENTER); repaint();
setSize(220,270); show(); } 222
} }
6.2.4. Exemples
• Application & Applet:
import java.awt.*;import java.awt.event.*;import javax.swing.*; public static void main(String[] args){ int width,heigth;
public class AppletApplication extends JApplet { if (args.length != 2) {width=300;heigth=200;}
JPanel buttonPanel; private JButton trace,efface; else {width = Integer.parseInt(args[0]);heigth=Integer.parseInt(args[1]);}
DrawPanel drawingPanel; private boolean cercle=false; JFrame applicationWindow = new JFrame("applet running app.");
private int width=300; private int heigth=200; applicationWindow.addWindowListener(
public void init(){ new WindowAdapter(){
buttonPanel = new JPanel(); public void windowClosing(WindowEvent e){
trace = new JButton("Trace");efface=new JButton("Efface"); System.exit(0);}});
buttonPanel.setLayout(new FlowLayout()); AppletApplication appletObject=new AppletApplication();
buttonPanel.add(trace); buttonPanel.add(efface); appletObject.setWidth(width); appletObject.setHeigth(heigth);
trace.addActionListener(new ActionTrace()); appletObject.init(); appletObject.start();
efface.addActionListener(new ActionTrace()); Container c = applicationWindow.getContentPane();
drawingPanel = new DrawPanel(); c.setLayout(new FlowLayout()); c.add(appletObject);
Container c=getContentPane();c.setLayout(new FlowLayout()); applicationWindow.setSize(width,heigth);
c.add(buttonPanel); c.add(drawingPanel); applicationWindow.show(); }}
} class DrawPanel extends JPanel {
private class ActionTrace implements ActionListener { boolean trace=false;
public void actionPerformed(ActionEvent e) { DrawPanel(){
if (e.getSource() == trace) drawingPanel.trace=true; setSize(getPreferredSize());setBackground(Color.green);}
else drawingPanel.trace=false; public void paintComponent(Graphics g){
drawingPanel.redraw();} super.paintComponent(g); g.drawString("Applet",10,10);
} if (trace) g.drawOval(50,50,100,100);
public void setWidth(int w){width=w;} else {g.setColor(getBackground()); g.drawOval(50,50,100,100);}}
223
public void setHeigth(int h){heigth=h;} public Dimension getPreferredSize(){return new Dimension(200,200);}
6.3. Programmation Visuelle
Graphique

6.3.1. Swing
6.3.2. SWT
6.3.3. Java2D
6.3.4. Java3D
7. Programmation multithread
7.1. Définition
7.2. Création et destruction d’un thread
7.3. Gestion des threads
7.4. Groupe de threads
7.5. Synchronisation
7.6. Exemple: modèle producteur-
consommateur
7.7. Application 225
7.1. Définition
• Java est un langage multithread: plusieurs threads
peuvent être exécutés simultanément
• L’utilisation de threads peut améliorer:
– Le temps de réponse, l’efficacité,
– La structure, la lisibilité, la conception d’un
programme.
• Les threads isolent les traitements et augmentent
l’abstraction.
• Sur un système multiprocesseur, chaque thread
peut être exécuté sur un processeur
226
7.1. Définition
• Les threads sont appelés « processus
légers »:
– Flux séquentiel de contrôle dans un programme
– Plusieurs threads peuvent être associés à
l’espace d’adressage d’un même processus,
partageant ainsi plusieurs variables et
méthodes, tout en possédant leurs propres
variables locales.
– Ne peuvent s'exécuter que dans le contexte
d'un programme principal.
227
7.1. Définition
• Programmation multi-thread:
– Prend avantage des ressources allouées au
programme de même que de son
environnement

228
7.1. Définition
• Les threads sont utilisés pour la
programmation parallèle, ou pseudo parallèle
(système multi-tâche, multi-traitement)
– La programmation concurrente sous-entend les
mécanismes de synchronisation et d’exclusion
mutuelle
– Exemple :
• caissiers d'une banque et la maj de compte
• navigateur web : Chargement et lecture de pages
229
7.1. Définition
• Thread vs processus (définition):
– Processus: unité fonctionnelle à part entière
– Thread: "processus interne" à un processus
• Thread vs processus (gestion):
– Lancement d'un processus coûteux en
ressources machine (temps, taille mémoire, en
charge de l'OS),
– Thread utilise mêmes ressources machine de son
processus
230
7.2. Création et destruction
d’un thread
• Classe Thread: définie dans le package java.lang
• Syntaxe :
public class Thread extends Object implements Runnable
public interface Runnable { public abstract void run() }

• Actions à effectuer:
– Définies dans le corps du thread (la méthode run()).
– Chaque thread commence son exécution par
l’exécution de sa méthode publique run().
• Le code de l'instance d'un thread s'exécute en
"parallèle" des autres threads existants. 231
7.2. Création et destruction
d’un thread
• 2 techniques:
– Dériver la classe Thread
• Utilisée quand la classe à paralléliser n’a pas besoin
d’hériter d’une autre classe
– Implémenter l’interface java.lang.Runnable
• Permet de dériver d’une autre classe (pas d’héritage
multiple en java) (exemple: les applets)
• Permet de partager les données entre les différents
treads

232
7.2. Création et destruction
d’un thread
• 1ère technique: Dériver la classe Thread
– Redéfinir le corps de la méthode run()
(la classe Thread n’est pas abstraite)
– Instancier la classe en un objet
– Lancer le thread:
• La méthode start()
– Visualiser les résultats (option):
• La méthode sleep()
class Thread implements Runnable {}
– Exemple
class Animation extends Thread {}
start()
233
run()
7.2. Création et destruction
d’un thread
• 2ème technique: Implémenter l’interface Runnable
– Définir le corps de la méthode run()
– Créer un thread: new Thread(…, Runnable,…)
(constructeur liant le thread à la classe)
– Lancer le thread: Méthode start()
– Exemple
class Animation implements Runnable {

myThread = new Thread(Animation);


myThread. start(); Thread myThread
run(); crée start()
} 234
7.2. Création et destruction
d’un thread
• Résumé:
Avantages Inconvénients
Chaque thread a ses On ne peut plus hériter
extends java. propres données d'une autre classe.
lang.Thread
L'héritage reste possible : Les attributs de la classe
implements on peut implémenter sont partagés par tous les
java.lang. autant d'interfaces que threads qui y sont placés.
l'on souhaite.
Runnable

235
7.3. Gestion des threads
• Cycle de vie d’un Thread:
– Les états d’un thread:
• Nouveau
• Exévutable
• Bloqué
• Mort

nouveau démarrer start()

mort
la méthode run se termine
stop()
236
7.3. Gestion des threads
• Contrôle des Thread:
• public void run() : Corps du code associé à cette tâche.
Se termine soit à la fin de cette méthode soit après un
appel à stop().
• void start() : point d’entrée réel du thread. Par défaut, la
méthode Thread.start() appelle la méthode run() de
l’objet Runnable associé ou Thread.run().
• void stop() : arrête le thread courant en lui envoyant une
erreur spéciale ThreadDeath interceptée par la machine
virtuelle. (obsolète).
• void destroy() : détruit définitivement un thread.
237
7.3. Gestion des threads
• Contrôle des Thread:
• void suspend() : arrête le thread jusqu’à réception
d’un resume() envoyé par un autre thread
(obsolète).
• void resume() : reprend l’exécution de ce thread.
Cette méthode n’est valide qu’après que suspend()
ait été invoquée (obsolète).
• static void sleep() : stoppe le thread courant
pendant un temps déterminé. Il peut être réveillé
avant l’heure par une autre méthode. Dans ce cas,
le flux de programme ayant stoppé le thread recoit
une exception InterruptedException. 238
7.3. Gestion des threads
• Contrôle des Thread:
• void interrupt() : permet de réveiller une tâche
endormie par sleep(), wait() ou suspend() en lui
envoyant une exception InterruptedException.
• void join() : attend que le thread spécifié ait cessé
d’être vivant.
• void join(long millis) : attend que le thread spécifié
ait cessé d’être vivant, ou que le nombre spécifié de
millisecondes spécifié soit écoulé.
• isAlive() : renvoie true si le thread est démarré et
n’est pas encore terminé.
239
239
7.3. Gestion des threads
• Contrôle des Thread:
• static void yield() : arrête le thread courant le temps
d’exécuter d’autres tâches en attente de priorité au
moins égale à celle de ce thread.
• void wait(), notify() : méthodes héritées de la classe
Object. wait() arrête le thread auquel appartient
l’objet jusqu’à ce que la méthode notify() de cet
objet soit appelée par un autre thread,
déverrouillant ainsi le thread. Ne peuvent être
appelé que dans une méthode synchronisée.
• void notifyall(): déverrouille les thread qui ont
appelé wait() sur cet objet. 240
7.3. Gestion des threads
• Identification d’un Thread:
– Un nom : Si aucun nom ne lui est attribué lors de sa
création, il reçoit le nom Thread- suivi du
numéro d’ordre de sa création.
– Une cible : Une cible est un objet instance d'une classe
implémentant l'interface Runnable
– Un groupe : Un groupe est une instance de la classe
java.lang.ThreadGroup.
– Constructeur : les 3 paramètres pour créer un thread
sont : le nom, la cible et s’il appartient à un
groupe. 241
7.3. Gestion des threads
• Identification d’un Thread: les constructeurs
– Thread() 
– Thread(Runnable)
– Thread(Runnable, String)
– Thread(String)
– Thread(ThreadGroup, Runnable)
– Thread(ThreadGroup, Runnable, String)
– Thread(ThreadGroup, String)

242
7.3. Gestion des threads
• Scheduling, priorité d’un Thread:
• Java offre la possibilité de fixer les priorités des
différents "threads" d'un processus: la priorité d’un
thread est héritée du thread créateur
• Le partage du temps entre "threads" dépend du
S.E :
– Le niveau de priorité détermine le rapport entre les temps
alloués à chaque thread exemple: Unix et Windows
– Les "threads" actifs de plus hautes priorité se partagent la CPU.

243
7.3. Gestion des threads
• Scheduling, priorité d’un Thread:
• Attributs :
– static int MIN_PRIORITY=1,
– static int MAX_PRIORITY=10,
– static int NORM_PRIORITY=5 est la priorité par défaut
• void setPriority(int): méthode modifiant la priorité du
receveur.
• int getPriority() permet de connaître la priorité d'un
"thread“
• Exemple
244
7.4. Groupe de threads
• La création des groupes de threads permet de
faciliter la gestion des threads au niveau de:
– Priorités
– Changement d’états
• Technique:
– créer un groupe: instancier objet de la classe ThreadGroup.
– attacher des threads au groupe: constructeur adéquat de la
classe Thread qui prend comme paramètre le nom du
groupe.
– invoquer alors les méthodes de contrôle d'exécution
des threads sur l'objet de groupe, identiques à la
classe Thread : suspend(), resume(), stop(), ...
245
7.4. Groupe de threads
• Arborescence de threads:
– Au démarrage, le système crée un groupe nommé
``main``: chaque thread nouvellement crée
devient membre de ce groupe.
• Appartenance de thread à un groupe:
– Le plus grand groupe dans java est le ``main``
– Création de sous-groupes à partir du groupe main:
Les groupes de threads peuvent contenir non
seulement des simples threads mais aussi des
groupes de threads

246
7.4. Groupe de threads

247
7.5. Synchronisation
• Exclusion mutuelle:
– Mécanisme d’exclusion mutuelle : moniteur.
• Sécurisation d’une méthode:
– L'accès simultané par deux threads à une ressource
critique peut être gênant
– Pour gérer la concurrence d'accès à une méthode,
définition d’une section critique : utilisation du modificateur
"synchronized" à la déclaration de la méthode (De cette
manière, on crée un moniteur)
– L'exécution d'une méthode "synchronized" est près de 10
fois plus lente que celle d'une méthode classique.
N'utilisez cette technique qu'à bon escient.
248
7.5. Synchronisation
• Exemple:
class s {
int cellule1, cellule2, cellule3 ;
synchronized int somme(){
return cellule1+ cellule2+ cellule3 ;
}
synchronized void init_valeur(int a1, int a2, int a3){
cellule1=a1 ;
cellule2=a2 ;
cellule3=a3 ;
}
...
}

249
7.5. Synchronisation
• Sécurisation d’un bloc :
– l’utilisation de méthodes synchronisées trop
longues peut créer une baisse d’efficacité. il est
possible avec java de placer n’importe quel bloc
dans un moniteur, ce qui réduit la longueur des
sections critiques.
– Syntaxe :
synchronized (MonObjet) {
//section critique
}
250
7.5. Synchronisation
• Sécurisation d’un bloc :
exemple imprimante partagée
– Deux utilisateurs peuvent y accéder en même temps:
il est préférable que le premier arrivé puisse la
verrouiller le temps que son impression soit terminée.
– Dans le cas contraire, l'imprimante risquerait
d'imprimer alternativement une page d'un utilisateur,
puis une page d'un autre, et ainsi de suite.
=> S'il s'agit d'imprimer deux documents de cent
pages chacun, il n'y a plus qu'à trier.

251
7.6. Exemple: modèle
producteur-consommateur
• Synchronisation wait et notify:
• La synchronisation de processus utilise les signaux
modélisés par les méthodes wait() et notify(). Elle
repose sur l’exclusion mutuelle, qui permet à deux
processus de s ‘exécuter en section critique.
• Les méthodes wait et notify sont héritées de la classe
Object. Elles doivent être utilisées à l’intérieur de
sections critiques.
• En exécutant la méthode wait(), un thread libère les
ressources et passe à l’état endormi (sleep). Pendant ce
temps, un autre thread entre en section critique. Une
fois celui-ci achevé, il appelle la méthode notify du
thread initial pour le réveiller. 252
7.7. Application
• L’horloge

253
8. Entrées/Sorties simples
8.1. Les flux
8.2. Gestion des E/S
8.3. Manipulation des fichiers
8.4. Gestion du flux de données
8.5. Gestion de l’accès aléatoire à un
fichier
8.6. Flux de texte
254
8.1. Les flux

• Définition:
– Flux d’entrée:
• objet à partir duquel on peut lire une suite d’octets
– Flux de sortie:
• objet vers lequel on peut écrire une suite d’octets

255
8.1. Les flux
• Mise en œuvre:
– Les classes abstraites InputStream et OutputStream
implémentent ces deux types de flux
– Les flux d’octets conviennent mal au traitement
d’informations codées en Unicode (2 octets): introduction
des super-classes spéciales Reader et Writer pour traiter 2
octets au lieu de caractères d’1 octet
– Java fait dériver à partir de ces 4 classes abstraites, une
multitude de classes concrètes spécialisées dans le
traitement des différents formats de données stockées dans
les fichiers

256
8.1. Les flux
• La faune des flux:
InputStream

ByteArray File Piped Filter Sequence StringBuffer Object


InputStream InputStream InputStream InputStream InputStream InputStream InputStream

Buffered Checked Digest Inflater LineNumber Pushback Data


InputStream InputStream InputStream InputStream InputStream InputStream InputStream

Object
GZIP Zip Input
InputStream InputStream
•Package java.io: DataInput
nombre de classes dévolues RandomAccess
File
Jar
à la gestion des flux important InputStream DataOutput
257
8.1. Les flux DataInput

DataOutput

• La faune des flux: Object


OutputStream Output

ByteArray FileOut Piped Filter Object


OutputStream OutputStream OutputStream OutputStream OutputStream

Buffered Checked Digest Deflater Deflater Data


OutputStream OutputStream OutputStream OutputStream OutputStream OutputStream

GZIP Zip
OutputStream OutputStream

Jar
OutputStream
258
8.1. Les flux
• La faune des flux: Reader
Buffered CharArray Filter InputStream Piped String
Reader Reader Reader Reader Reader Reader

LineNumber Pushback File


Reader Reader Reader

Writer

Buffered CharArray Filter OutputStream Piped Print String


Writer Writer Writer Writer Writer Writer Writer

File
Writer
259
8.2. Gestion des E/S
• Mode d'accès aux données: accès par flux de
données (Stream):
– Définition: accéder aux données sous la forme d'un flux
séquentiel
– La POO utilisée par Java permet de manipuler les données
entrantes ou sortantes avec les mêmes classes, quelque soit
le type de source de données (qu'elle soit en mémoire, dans
un fichier ou sur Internet) :
– Exemple: lecture de données d'un flux; utiliser les méthodes
des classes InputStream, FilterInputStream ou de ses
classes dérivées
– Exemple: écriture dans un flux de données; utiliser les
méthodes des classes OutputStream,
FilterOutputStream ou de ses classes dérivées.
260
8.2. Gestion des E/S
• Mode d'accès aux données: accès aléatoire
(Random):
– Définition: permet d'accéder aux données dans n'importe
quel ordre.
– Vous pouvez à tout moment aller en avant ou en arrière pour
lire ou écrire une partie des données.
– Mode d'accès comparable à celui utilisé pour la mémoire vive
– Son usage est plus spécifique : Java fournit uniquement la
classe RandomAccessFile qui permet d'accéder à une
position quelconque dans un fichier
– Certains types de source de données, comme les pipelines
ou les URL ne peuvent supporter ce mode d'accès

261
8.2. Gestion des E/S
• Gestion de l'accès aux données avec les
exceptions:
– Les exceptions permettent de programmer de manière plus
simple et surtout plus maintenable une séquence
d'instructions devant effectuer des entrées/sorties.
– Nombre de contrôles important (il faut vérifier à chaque
accès à un flux de données ou un fichier si tout s'est bien
déroulé).
– Une programmation n'utilisant pas les exceptions est donc
truffée de contrôles après chaque instruction, ce qui en
réduit la lisibilité.
– La plupart des méthodes d'entrée/sortie déclenche une
exception de classe IOException ou de ses dérivées
EOFException, FileNotFoundException,
262
InterruptedIOException ou UTFDataFormatException
8.2. Gestion des E/S
import java.io.*;
class Classe1 {
void lireFichier (String fichier) {
try { // Suite d'instructions accédant au fichier et
// ne s'occupant pas de la gestion des erreurs  
// Tentative d'ouvrir un fichier  
// Lecture dans le fichier
}
catch (FileNotFoundException e) { // Exception déclenchée si le fichier n'existe pas
}
catch (EOFException e) { // Exception déclenchée si la fin du fichier est atteinte
}
catch (IOException e) { // Exception déclenchée si un autre problème survient
// pendant l'accès au fichier
}
finally { // Le bloc finally est toujours exécuté ce qui permet d'être sûr
// que la fermeture du fichier sera effectuée
try { // Fermeture du fichier si le fichier a été ouvert
}
catch (IOException e) { // Exception déclenchée si un problème survient pendant la
fermeture }
} }
} 263
8.3. Manipulation des fichiers
• L'interface java.io.FilenameFilter
– Interface utilisée pour permettre d'accepter ou de
rejeter un fichier issu d'une liste.
– Une instance d'une classe implémentant cette interface
est requise par les méthodes list () de la classe File et
setFilenameFilter () de la classe FileDialog.
• Méthode
– public boolean accept (File dir, String name): Cette
méthode doit renvoyer true si le fichier name se
trouvant dans le répertoire dir est accepté.

264
8.3. Manipulation des fichiers
• La classe java.io.File:
– Définition:
• Représente un chemin d'accès au système de fichiers local
• Effectue des opérations sur celui-ci (autorisation d'accès en
lecture/écriture, liste des fichiers d'un répertoire,...)
• Ce chemin d'accès peut désigner un fichier ou un répertoire.
– Exception éventuellement déclenchée:
SecurityException (si le gestionnaire de sécurité
actif leur interdit d'être exécuté).
– La description des chemins d'accès (séparateurs,
description des disques,...) utilise les conventions du
système sur lequel est exécutée la Machine Virtuelle.
265
8.3. Manipulation des fichiers
• La classe java.io.File:
– Champs
public static final String separator;
public static final char separatorChar;
La chaîne ou le caractère utilisé comme séparateur de
fichier (égal généralement à / ou \).

public static final String pathSeparator;


public static final char pathSeparatorChar;
La chaîne ou le caractère utilisé comme séparateur de
plusieurs chemins d'accès (égal généralement à ;).
266
8.3. Manipulation des fichiers
• La classe java.io.File:
– Constructeurs
public File (String path)

public File (String dir, String name)


public File (File dir, String name)

267
8.3. Manipulation des fichiers
• La classe java.io.File:
– Méthodes
public String getName() : nom du fichier ou du répertoire d'un chemin
d'accès.
public String getPath() : chemin d'accès d'un objet de classe File.
public String getAbsolutePath() : chemin d'accès absolu.
public String getParent () : chemin d'accès du répertoire parent au chemin
d'accès de l'objet de classe File, ou null s'il
n'existe pas.
public boolean exists () throws SecurityException
public boolean isFile () throws SecurityException
public boolean isDirectory () throws SecurityException
public boolean isAbsolute () Ces méthodes renvoient true, si le chemin
d'accès existe, s'il correspond à un fichier ou à un
répertoire, ou si le chemin d'accès est absolu 268
8.3. Manipulation des fichiers
• La classe java.io.File:
– Méthodes
public boolean canRead() throws SecurityException
public boolean canWrite() throws SecurityException
Ces méthodes renvoient true, si le chemin d'accès
est accessible en lecture ou en écriture.
public long lastModified() throws SecurityException
Renvoie la date de dernière modification du fichier.
Cette date n'étant pas exprimé dans la même échelle
que celle utilisée par la classe Date, elle ne peut être
utilisée que pour comparer des dates de différents fichiers.
public long length() throws SecurityException :
taille du chemin d'accès représentant un fichier.

269
8.3. Manipulation des fichiers
• La classe java.io.File:
– Méthodes
public boolean delete() throws SecurityException
public boolean renameTo(File dest) throws SecurityException
Ces méthodes permettent de supprimer ou de
renommer un chemin d'accès, et renvoient true si
l'opération s'est effectuée correctement.

public boolean mkdir() throws SecurityException


public boolean mkdirs() throws SecurityException
Ces méthodes permettent de créer le répertoire
ou les répertoires représentés par le chemin d'accès
et renvoient true si l'opération s'est effectuée
correctement.
270
8.3. Manipulation des fichiers
• La classe java.io.File:
– Méthodes
public String [ ] list() throws SecurityException
public String [ ] list(FilenameFilter filter) throws SecurityException

renvoient un tableau de chaînes de caractères dont les éléments sont


les fichiers et les répertoires contenus dans le répertoire représenté
par un chemin d'accès. Les répertoires . et .. sont exclus de cette
liste.

La seconde méthode permet d'appliquer le filtre filter pour ne


récupérer que les fichiers et les répertoires autorisés par la méthode
accept () de la classe de l'objet filter implémentant l'interface
FilenameFilter.

271
8.3. Manipulation des fichiers
• La classe java.io.File:
– Méthodes

public int hashCode()


public boolean equals (Object obj)
public String toString ()

Ces méthodes outrepassent celles de la classe Object, pour renvoyer


un code de hash, comparer un chemin d'accès à un objet ou
renvoyer une chaîne de caractères égale au chemin d'accès.

272
8.3. Manipulation des fichiers
• La classe java.io.FileDescriptor
– Classe finale représentant un descripteur de fichier. (Une instance de
cette classe permet de manipuler un fichier ouvert ou les E/S std)
– Méthodes getFD() de classes FileInputStream, FileOutputStream
et RandomAccessFile permettent d'obtenir 1 instance de classe
FileDescriptor et les champs static in, out et err associés
• Champs
public static final FileDescriptor in
public static final FileDescriptor out
public static final FileDescriptor err
• Constructeur
– public FileDescriptor ()
• Méthodes 273
public boolean valid ()  
8.4. Gestion du flux de données
• Principe:
– Accès aux données
• soit en lecture grâce aux classes qui dérivent de la classe
abstract InputStream
• soit en écriture grâce aux classes qui dérivent de la
classe abstract OutputStream.
– Dans chacun des cas, ces classes se divisent en 2
catégories:
• Les classes qui permettent de se lier à une source de
données spécifique
• Les classes de filtre sur un flux de données

274
8.4.1. Accès en lecture
•Classes •Paramètres des constructeurs

• Classes dérivant de d'accès


•Chemin InputStream:
à un fichier (classe String)
•FileInputStream
– la classe FileInputStream
•Fichier décrit par une: instance
accès deenla classe
lectureFile à un
•Descripteur de fichier (classe FileDescriptor)
fichier
– la classe StringBufferInputStream
•StringBufferInputStream •Chaîne de caractères (classe String)
pour parcourir
une chaîne de caractères sous forme de flux de
données
•ByteArrayInputStream
•Tableau d'octets (de type byte [])
– la classe ByteArrayInputStream pour parcourir un
tableau d'octets
•PipedInputStream sous
•Aucun pourforme
créer unde fluxd'entrée
pipeline de données
•Sortie d'un pipeline (classe PipedOutputStream)
– la classe PipedInputStream pour accéder à un flux
de données sous forme de pipeline
•Une énumération de flux de données de classe
– la classe SequenceInputStream
•SequenceInputStream
InputStream pour accéder aux
données de plusieurs flux
•Deux flux de de données
données les uns après
de classe InputStream
les autres. 275
8.4.1. Accès en lecture
• Remarques:
– Entrée Standard : accessible soit directement par le
champ static in de la classe System (classe
InputStream), soit par le champ static in (classe
FileDescriptor).
– L'accès en lecture aux sockets et à un fichier accessible
via une URL s'effectue grâce à la méthode
getInputStream () des classes Socket et
URLConnection, qui renvoie une instance d'une classe
dérivée de InputStream.

276
8.4.1. Accès en lecture
• Classes de filtre sur un flux de données qui
dérivent de la classe FilterInputStream :
– BufferedInputStream pour accéder à un flux de
données en utilisant une zone mémoire tampon (buffer)
– DataInputStream pour lire dans un flux de données
des données d'un des types de base de Java ou des
chaînes de caractères
– LineNumberInputStream pour permettre de compter
les lignes d'un flux de données
– PushBackInputStream pour permettre d'accéder à un
flux de données avec la possibilité de revenir en arrière
d'un octet.
– etc… 277
8.4.1. Accès en lecture
• Empilement de flux filtrés:
– Grâce à ce système il devient possible d’utiliser n'importe
quel filtre sur une source de données, et même cumuler
les filtres les uns derrière les autres

278
8.4.1. Accès en lecture
• La classe java.io.InputStream:
– super-classe abstract de toutes les classes permettant
d'accéder à d'un flux de données en lecture.

279
8.4.1. Accès en lecture
• Méthodes de la classe java.io.InputStream:
– public abstract int read () throws IOException Lit un octet dans le
flux de données. Renvoie -1 si la fin est atteinte.
– public int read (byte [ ] tab) throws IOException Lit tab.length
octets dans le tableau tab. Si la fin est atteinte pendant la lecture,
tab est remplit avec les octets lus. Renvoie le nombre d'octets lus
ou -1 si la fin est atteinte.
– public int read (byte [ ] tab, int offset, int length) throws
IOException, IndexOutOfBoundsException Lit length octets
dans le tableau tab, en le remplissant à partir de l'indice offset. Si la
fin est atteinte pendant la lecture, tab est remplit avec les octets
lus. Renvoie le nombre d'octets lus ou -1 si la fin est atteinte.
– public long skip (long n) throws IOException Saute n octets plus
loin dans la lecture du flux de données. Renvoie le nombre d'octets
effectivement sautés.
– public int available () throws IOException Renvoie le nombre
d'octets que les méthodes read () peuvent actuellement lire sans280
bloquer le thread courant.
8.4.1. Accès en lecture
• Méthodes de la classe java.io.InputStream:
– public void close () throws IOException Ferme l'accès au flux de
données.
– public synchronized void mark (int readlimit) Marque la position
courante dans le flux de données, pour qu'un appel à la méthode
reset () provoque un retour en arrière à cette position. readlimit
permet de préciser le nombre d'octets maximum que l'on peut lire
avant que la marque soit invalide, c'est-à-dire la taille maximum du
retour en arrière qu'il est possible de faire.
– public synchronized void reset () throws IOException
Repositionne la position courante dans le flux de données sur la
dernière marque positionnée par la méthode mark (). Si aucune
marque n'a été positionnée ou si la marque est invalide, une
exception IOException est déclenchée.
– public boolean markSupported () Renvoie true si le flux de
données autorise l'utilisation des méthodes mark () et reset ().
281
8.4.1. Accès en lecture
• La classe java.io.DataInputStream:
– dérive des classes FilterInputStream et InputStream
implémente l'interface DataInput (permet de lire à partir d'un flux
de données autres chose que des octets).
• Constructeur
– public DataInputStream (InputStream in) Construit une instance de
la classe DataInputStream dont la lecture sera effectuée sur le flux
de données in.
• Méthodes
– public final void read (byte [ ] tab) throws IOException
– public final void read (byte [ ] tab, int offset, int length) throws
IOException, IndexOutOfBoundsException

282
8.4.1. Accès en lecture
Méthodes de la classe FilterInputStream:
– public final void readFully (byte [ ] tab) throws IOException
– public final void readFully (byte [ ] tab, int offset, int length) throws
IOException, IndexOutOfBoundsException
– public final boolean readBoolean () throws IOException
– public final byte readByte () throws IOException
– …
– public final char readChar () throws IOException
– …
– public final double readDouble () throws IOException
– public final String readLine () throws IOException
– public final String readUTF () throws IOException
– public final static String readUTF (DataInput in) throws
IOException
283
– public final int skipBytes (int n) throws IOException
8.4.2. Accès en écriture
•Classes •Paramètres des constructeurs
• Classes dérivant de OutputStream:
– Elles permettent de se lier à un type de source de
•Chemin d'accès à un fichier (classe String)
données spécifique
•FileOutputStream : décrit par une instance de la classe File
•Fichier
•Descripteur de fichier (classe FileDescriptor)
– la classe FileOutputStream pour accéder en écriture à
un fichier
– la classe ByteArrayOutputStream
•Aucun pour créer un tableau
pour
d'octets
écrire
par
dans un
défaut
•ByteArrayOutputStream
tableau d'octets sous
•Tailleforme
minimum dedu flux
tableaude données
d'octets
– la classe PipedOutputStream pour accéder à un flux
de données sous forme de créer
•Aucun pour pipeline
un pipeline de sortie
•PipedOutputStream
•Entrée d'un pipeline (classe PipedInputStream)
284
8.4.2. Accès en écriture
• Remarques:
– Accès aux trois autres types de sources de données
restantes (les sorties standards, les sockets et un fichier
via une URL) :
– Sorties standard et d'erreur :
• soit directement par les champs static out et err de la classe
System (de classe PrintStream),
• soit par les champs static out et err de la classe
FileDescriptor. Ces dernièrs champs étant eux-même de
classe FileDescriptor, l'écriture sur les sorties standard peut
démarrer en créant une instance de classe FileOutputStream,
par exemple avec l'instruction new FileOutputStream
(FileDescriptor.out).
285
8.4.2. Accès en écriture
• Remarques:
– Sockets et fichier accessible via une URL : méthode
getOutputStream() des classes Socket et
URLConnection (qui renvoie une instance d'une classe
dérivée de InputStream)

286
8.4.2. Accès en écriture
• Classes de filtre sur un flux de données :
(dérivent de la classe FilterOutputStream)
– BufferedOutputStream pour écrire sur un flux de
données en utilisant une zone mémoire tampon (buffer)
– DataOutputStream pour écrire dans un flux de
données des données d'un des types de base Java ou
des chaînes de caractères
– PrintStream pour écrire au format texte les types de
base Java

287
8.4.2. Accès en écriture
• Classes de filtre sur un flux de données :
(dérivent de la classe FilterOutputStream)
– Remarques:
• les constructeurs de ces classes prennent tous en paramètre un
objet de classe OutputStream.
• La classe OutputStream étant la super classe de toutes les
classes d'écriture sur les flux de données, on peut donc passer
en paramètre une instance de n'importe quelle classe qui en
dérive.

288
8.4.2. Accès en écriture
• La classe java.io.OutputStream: super classe abstract de
toutes les classes qui permettent d'écrire sur un flux de
données en lecture.

289
8.4.2. Accès en écriture
• Méthodes de la classe java.io.OutputStream:
– public abstract void write (int b) throws IOException
• Ecrit un octet sur le flux de données.
– public void write (byte [ ] tab) throws IOException
• Ecrit les octets du tableau tab sur le flux de données.
– public void write (byte [ ] tab, int offset, int length) throws
IOException, IndexOutOfBoundsException
• Ecrit length octets du tableau tab sur le flux de données, à partir
de offset.
– public void flush () throws IOException
• Ecrit physiquement sur le flux de données quand zone tampon
utilisée.
– public void close () throws IOException
• Ferme l'accès au flux de données. 290
8.4.2. Accès en écriture
• La classe java.io.FileOutputStream: dérive de
OutputStream
• Constructeurs
– public FileOutputStream (String path) throws SecurityException,
FileNotFoundException
– public FileOutputStream (File file) throws SecurityException,
FileNotFoundException
Ces constructeurs permettent de créer une instance de classe
FileOutputStream à partir du chemin d'accès à un fichier path ou
d'une instance de classe File. Si le fichier n'existe pas il est créé.
– public FileOutputStream (FileDescriptor fdObj) throws
SecurityException
Construit une instance de classe FileInputStream à partir d'un
descripteur de fichier fdObj.

291
8.4.2. Accès en écriture
• Méthodes
– Méthodes de la classe OutputStream outrepassées pour qu'elles
s'appliquent à l'écriture dans un fichier:
• public void write (int b) throws IOException
• public void write (byte [ ] tab) throws IOException
• public void write (byte [ ] tab, int offset, int length) throws IOException,
IndexOutOfBoundsException
– public void close () throws IOException
– public final FileDescriptor getFD () throws IOException : Permet
d'obtenir un descripteur de fichier.
– protected void finalize () throws IOException

292
8.4.2. Accès en écriture
• La classe java.io.DataOutputStream: dérive
des classes FilterOutputStream et
OutputStream implémente l'interface
DataOutput, ce qui permet d'écrire sur un flux de
données autres chose que des octets.
• Champ:
– protected int written Constructeur
– public DataOutputStream (OutputStream out) Construit
une instance de la classe DataOutputStream dont
l'écriture sera effectuée sur le flux de données out

293
8.4.2. Accès en écriture
• Méthodes:
– public synchronized void write (int b) throws IOException
– public synchronized void write (byte [ ] tab, int offset, int
length) throws IOException, IndexOutOfBoundsException
– public final void writeBoolean (boolean v) throws
IOException
– public final void writeByte (int v) throws IOException
–…
– public final void writeDouble (double v) throws IOException
– public final void writeBytes (String s) throws IOException
– public final void writeChars (String s) throws IOException
– public final void writeUTF (String str) throws IOException
294
8.4.2. Accès en écriture
• Méthodes:
– Implémentation des méthodes de l'interface
DataOutput. La méthode write (byte [ ] tab) est
implémentée par la classe FilterOutputStream.
– public void flush () throws IOException Méthodes de la
classe FilterOutputStream outrepassées pour qu'elles
s'appliquent à ce filtre.
– public final int size () Renvoie le nombre d'octets écrits
sur le flux de données depuis la création du filtre.

295
8.5. Gestion de l’accès
aléatoire à un fichier
• La classe java.io.RandomAccessFile: classe
implémentant les interfaces DataInput et
DataOuput
• Constructeurs:
• public RandomAccessFile (String path, String mode)
throws SecurityException, IOException,
IllegalArgumentException
• public RandomAccessFile (File file, String mode)
throws SecurityException, IOException,
IllegalArgumentException
296
8.5. Gestion de l’accès
aléatoire à un fichier
• Méthodes:
– public final FileDescriptor getFD () throws
IOException Permet d'obtenir un descripteur de
fichier.
– public long getFilePointer () throws IOException
Renvoie la position courante dans le fichier.
– public void seek (long pos) throws IOException
Déplace la position courante en pos dans le
fichier.
– public long length () throws IOException Renvoie
la taille courante du fichier.
– public void close () throws IOException Ferme
l'accès au fichier. 297
8.5. Gestion de l’accès
aléatoire à un fichier
• Méthodes:
– public abstract int read () throws IOException
• Lit 1 octet dans le flux de données, renvoie -1 si la fin est
atteinte.
– public int read (byte [ ] tab) throws IOException
• Lit tab.length octets dans le tableau tab. Si la fin est atteinte
pendant la lecture, tab est remplit avec les octets lus. Renvoie
le nombre d'octets lus ou -1 si la fin est atteinte.

298
8.5. Gestion de l’accès
aléatoire à un fichier
• Méthodes:
– public int read (byte [ ] tab, int offset, int length) throws
IOException, IndexOutOfBoundsException
• Lit length octets dans le tableau tab, en le remplissant à partir
de l'indice offset. Si la fin est atteinte pendant la lecture, tab
est remplit avec les octets lus. Renvoie le nombre d'octets lus
ou -1 si fin.
– public int skipBytes (int n) throws IOException
• Méthode de l'interface DataInput implémentée pour qu'elle
déplace de n octets la position courante dans le fichier. n peut
être positif ou négatif (pour revenir en arrière). Renvoie n.

299
8.5. Gestion de l’accès
aléatoire à un fichier
• Méthodes:
Implémentation des autres méthodes de l'interface
DataInput:
– public final void readFully (byte [ ] tab) throws IOException
– public final void readFully (byte [ ] tab, int offset, int length)
throws IOException, IndexOutOfBoundsException
– public final boolean readBoolean () throws IOException
–…
– public final double readDouble () throws IOException
– public final String readLine () throws IOException
– public final String readUTF () throws IOException
300
8.5. Gestion de l’accès
aléatoire à un fichier
• Méthodes:
– Implémentation des méthodes de l'interface DataOutput.
– public void write (int b) throws IOException
– public void write (byte [ ] tab) throws IOException
– public void write (byte [ ] tab, int offset, int length)
throws IOException, IndexOutOfBoundsException
– public final void writeBoolean (boolean v)
throws IOException
– public final void writeByte (int v) throws IOException
– …
– public final void writeBytes (String s) throws IOException
– public final void writeChars (String s) throws IOException
– public final void writeUTF (String str) throws IOException301
8.5. Gestion de l’accès
aléatoire à un fichier
• Méthodes: Implémentation des autres méthodes de
l'interface DataInput:
– public final void readFully (byte [ ] tab) throws
IOException
– public final void readFully (byte [ ] tab, int offset, int
length) throws IOException,
IndexOutOfBoundsException
– public final boolean readBoolean () throws IOException
–…
– public final double readDouble () throws IOException
– public final String readLine () throws IOException
– public final String readUTF () throws IOException 302
8.6. Flux de texte

303