Académique Documents
Professionnel Documents
Culture Documents
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
• 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
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
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
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();
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:
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
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
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
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
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
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();
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
• 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
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
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
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
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
interface Tracable {
static final int DIM_MAX = 500;
void dessine(java.awt.Graphics g);
}
– Remarque:
• java.awt.Graphics
116
4.2. Interfaces
119
4.2. Interfaces
121
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
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
158
5. Exceptions
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
160
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
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
166
6.1. Gestionnaires de présentation
167
6.1.1. Principaux objets graphiques
169
6.1.1. Principaux objets graphiques
• Arboresence des objets graphiques: JCheckBox
Button Applet
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
• 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
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
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
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
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
AWT
Event
Key Mouse
Event Event 203
6.2.2. Modèle d’évènements JDK 1.1
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
207
6.2.3. Récapitulation (JDK 1.1)
Classe d'événements Les attributs et les méthodes
Object getSource()
// rend le nom de la variable de l'objet source
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)
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)
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
Menu ActionEvent
MenuItem ActionEvent
PopoMenu ActionEvent
• 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
• 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 {
235
7.3. Gestion des threads
• Cycle de vie d’un Thread:
– Les états d’un thread:
• Nouveau
• Exévutable
• Bloqué
• Mort
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
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
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
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 \).
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.
271
8.3. Manipulation des fichiers
• La classe java.io.File:
– Méthodes
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
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