Java-3eme partie.pptx

Exception, IO, Threads CHAPITREIV

Package - Définition
• Java permet de regrouper les classes en ensemble appelé packages (paquetages) afin de
faciliter la modularité.
• Réunir des classes suivant un centre d’intérêt commun,
• La protection des attributs et des méthodes.
• Les packages sont comme des dossiers permettant de ranger les classes.
• Les packages sont des répertoires,
• Les classes sont des fichiers ordinaires.
• Intérêt:
• Les classes mises dans un package sont plus facilement transportables d’une application
à l’autre.
• Il suffit d’inclure le dossier de votre package dans un projet et d’y importer les classes
qui vous intéressent.
2
Package
CHAPITREIV

Package - Organisation
• Les packages sont organisés sous forme de hiérarchie. C’est un arbre dans
lequel les feuilles sont des classes:
3
Package
CHAPITREIV
java
org
lang
….
….
util
….
reflect
Date
String
….
….
Proxy
…
….
• Le séparateur est le "."
Exemple :
java.util.Date :
• classe Date dans
java.util

Package – Convention de nommage
• Le nom d’un package doit être écrit entièrement en minuscules;
• Les caractères autorisés sont alphanumériques (de a à z, de 0 à 9) et peuvent
contenir des points (.) ;
• Tout package doit commencer par com, edu, gov, mil, net, org:
• com.gestionfacture.commande
• Ou les deux lettres identifiant un pays (ISO Standard 3166, 1981):
• ma correspond au Maroc, fr correspond à la France, en correspond à l'Angleterre, etc.
• Aucun mot clé Java ne doit être présent dans le nom, sauf si vous le faites suivre
d'un underscore (« _ »), comme ceci : com.gestionfacture.package_.
4
Package
CHAPITREIV

Package – Création avec Eclipse
• Il est possible de créer les packages à l'avance même si ceux ci peuvent être
créer automatiquement en même temps qu'une classe qui la contient.
• Pour créer un nouveau package, il y a plusieurs possibilités, citons par exemple :
• Cliquer sur l'icône de la barre d'outils.
• Sélectionner l'option Package du menu File / New.
• L'assistant demande le nom du package.
• Cliquer sur Finish, pour créer le nouveau package. Le package apparait dans la
vue Packages.
5
Package
CHAPITREIV

Package – Utilisation
6
Package
CHAPITREIV
package com.fst.test1;
public class A {…}
public class B {…}
• On peut importer plusieurs classes à la fois
import com.fst.test1.A;
import com.fst.test1.B;
import com.fst.test1.B;
Public class C{
B b = new B();
}
Ou bien import com.fst.test1.*;
• On peut utiliser des classes d’un autre package sans utiliser import:
com.fst.test1.B b = new com.fst.test1.B();

Package – Droits d’accès entre les packages
• Les classes déclarées public sont visibles dans l’extérieur du package qui les
contient.
• Les classes n’ayant pas été déclarées public ne sont pas visibles depuis
l’extérieur du package qui les contient.
• Si une classe déclarée public dans son package a une variable d’un type ayant
une portée default, cette dernière ne pourra pas être modifiée depuis
l’extérieur de son package.
7
Package
CHAPITREIV

Package – Droits d’accès entre les packages (Exemple)
8
Package
CHAPITREIV
class A {…}
public class B {
public A a= new A();
}
import com.fst.test1.*;
Public class C{
B b = new B();
A a = new A();//Erreur
}

Package – Quelques packages java
• Java propose une série de classes prédéfinies, organisées en packages.
9
Package
CHAPITREIV
java.applet Classes de base pour les applets
java.awt Classes d'interface graphique AWT
java.io Classes d’entrées sorties (flux, fichiers)
java.lang Classes de support du langage
java.math Classes permettant la gestion de grands nombres.
java.net Classes de support réseau (URL, sockets)
java.rmi Classes pour les méthodes invoquées à partir de machines virtuelles non
locales.
java.security Classes et interfaces pour la gestion de la sécurité.
java.sql Classes pour l'utilisation de JDBC.
java.text Classes pour la manipulation de textes, de dates et de nombres dans
plusieurs langages.
java.util Classes d’utilitaires (vecteurs, hashtable)
javax.swing Classes d’interface graphique

Package – Trouver les packages java
• Documentation Java: https://docs.oracle.com/javase/7/docs/api/
10
Package
CHAPITREIV

Lire la documentation Java
11
Package
CHAPITREIV

Exception – Définition
• Une exception est un signal indiquant que quelque chose d’exceptionnelle (comme une erreur)
s’est produit.
• Division par zéro, indiquer un indice de tableau qui n’existe pas, entrée incorrecte depuis le clavier
(caractère au lieu d’un numérique)
• La gestion des exceptions Java est un mécanisme qui permet de traiter toutes les situations
inattendues qui peuvent se produire au moment de l'exécution.
• Elle s'appuie sur le fait que vous savez que la méthode peut avoir un comportement risqué.
• Dans ce cas, on doit écrire explicitement un morceau de code qui prend en compte cette éventualité.
• Lorsqu'une méthode possède un comportement risqué, on dit qu'elle peut générer (déclencher ou
lancer) une exception.
• Vocabulaire
• Lancer ou déclencher (throw) une exception consiste à signaler les erreurs,
• Capturer ou attraper (try .. catch) une exception permet de traiter les erreurs.
13
LesExceptions
CHAPITREV

Exception – Lancer et capturer une exception
1. Déclarer qu’une méthode est risquée (Throwable): mot clé throws.
2. Dans le code de cette méthode, créer une nouveau objet Exception puis la
lancer: mot clé throw.
3. Lors de l’appel de la méthode, il faut capturer l’exception et la traiter: mots
clés try .. catch.
14
LesExceptions
CHAPITREV
public Point(int x, int y) throws ErrConst {…}
throw new ErrConst();
ErrConst est une classe pour créer
des objets Exception que nous
devons définir plus tard
try {
Point a = new Point(-2, 4);
} catch (ErrConst e) {
e.afficherErreur();
}

Exception – Lancer et capturer une exception
(Exemple)
15
LesExceptions
CHAPITREV
public class Point {
private int x;
private int y;
public Point(int x, int y) throws ErrConst {
if ((x < 0) || (y < 0))
throw new ErrConst();
this.x = x; this.y = y;
}
public void afficher(){
System.out.println(x + " " + y);
}
}
1
public class Test {
public static void main(String[] argv) {
try {
Point a = new Point(1, 4);
a.afficher();
a = new Point(-2, 4);
a.afficher();
e.afficherErreur();
System.exit(-1);
}
}
}
2
3

Exception – Mécanisme de capture
• Règles :
• si le bloc 1) réussi, passer au bloc 3)
• si le bloc 1) échoue quelque part,
passer au bloc 2), puis au bloc 3)
16
LesExceptions
CHAPITREV
try {
// 1)
}
catch ( Exception ex) {
// 2)
}
// 3)
public class Test {
public static void main(String[]
argv) {
try {
Point a = new Point(1, 4);
a.afficher();
a = new Point(-2, 4);
a.afficher();
e.afficherErreur();
System.exit(-1);
}
...
}}

Exception – Types
• Toute exception doit être une instance d’une
sous-classe de la classe java.lang.Throwable,
• Deux sous-classes de Throwable :
• Exception : conditions exceptionnelles que
les programmes utilisateur devraient
traiter.
• Error : exceptions catastrophiques que
normalement seul l’environnement
d’exécution devrait gérer.
17
LesExceptions
CHAPITREV
Throwable
Error Exception
ErrConst UneException ….
Erreurs non
récupérables.
Erreurs que l’on
peut traiter puisque
récupérable.

Exception – Définir une classe d’exception
• Pour créer sa propre classe d’exception, il suffit donc de créer une classe qui
hérite de java.lang.Exception
• La plupart du temps, on crée une nouvelle exception pour
• gérer, par programmation (et non par message d’erreur), les utilisations incorrectes d’une
méthode.
• et surtout prévenir l’utilisateur de la méthode que certaines utilisations sont incorrectes et
qu’elles doivent être gérées explicitement.
18
LesExceptions
CHAPITREV
public class ErrConst extends Exception {
public ErrConst() { }
public void afficherErreur(){
System.out.println("Erreur de création");
}
}

Exception – Exemple 1
19
LesExceptions
CHAPITREV
• Que produit le programme
suivant lorsqu’on lui fournit
en donnée : -5 puis 0 et
enfin 4.
debut main
donnez un entier positif : -5
*** erreur construction ***
donnez un entier positif : 0
*** erreur construction ***
donnez un entier positif : 4
fin main

Exception – Exemple 2
20
LesExceptions
CHAPITREV
• Que produit le programme
suivant lorsqu’on lui fournit en
donnée :
• la valeur 0,
• la valeur 1,
• a valeur 2.
Valeur 0:
donnez un entier : 0
debut premier bloc try
fin premier bloc try
suite du programme
debut second bloc try
catch 2 - n = 0
Valeur 1:
catch 1 - n = 1
suite du programme
fin second bloc try
fin programme
Valeur 2:
catch 1 - n = 2
suite du programme
catch 2 - n = 2

Exception – Classes d’exception fréquentes
• Un grand nombre de classes d’exception sont proposées dans l’API pour couvrir
les catégories d’erreurs les plus fréquentes.
21
LesExceptions
CHAPITREV
Classe Description
AWTException
Les exceptions de cette classe peuvent se produire lors d’opérations de
type graphique.
ClassCastException
Signale une erreur lors de la conversion d’un objet en une classe
incompatible avec sa vraie classe.
FileNotFoundException Signale une tentative d’ouverture d’un fichier inexistant.
IndexOutOfBoundsException
Se produit lorsque l’on essaie d’accéder à un élément inexistant dans
un ensemble.
IOException
Les exceptions de cette classe peuvent se produire lors d’opérations
d’entrées sorties.
NullPointerException
Se produit lorsqu’un pointeur null est reçu par une méthode
n’acceptant pas cette valeur, ou lorsque l’on appelle une méthode ou
une variable à partir d’un pointeur null.

Les Exception
• Quand un cas non prévu survient, il est possible de le capter et le traiter : Exception
– Si on capte et traite une exception, le programme peut continuer à se dérouler
– Sinon, le programme sort de l’exécution avec un message d’erreur
– Exemple d’exception : division par 0, ouvrir un fichier qui n’existe pas, …
• Mécanisme de traitement d’exception
– Pour capter et traiter des exceptions utiliser :
Try {…} catch {…} fially {…}
– Pour lancer une exception on utilise le mot clé :
throws throw
Programmation JAVA Pr. A.SADIQ 22

On n’est pas obligé de traiter ces exceptions-ci
On doit traiter ces exceptions-ci
On ne peut pas traiter
les « Error »
Throwable
Exception Error
RunTime Exception
Vos Exceptions
Hiérarchie des exceptions

Traitement des exceptions
Principes
• Le traitement des exceptions contient deux aspects:
– L’interception des exceptions
• Utilisation du bloc try – catch – finally pour récupérer les exceptions
• Et réaliser les actions nécessaires
– Le lancement (la génération) d’exceptions
• Automatiquement par l’environnement la machine virtuelle pour certaines exceptions prédéfinies par Java
• Explicitement par le développeur dans une méthode avec « throws » et « throw » (en tout cas pour les
exceptions créées par le développeur)

Interception par bloc try – catch – finally
try
{
// quelques actions potentiellement risquées
}
catch(IOException se)
{
// que faire si une exception de ce type survient
}
finally
{
// toujours faire ceci, quelle que soit l’exception
}
Le block finally est exécuté si il y a une Exception et
même s’il y a pas

Interception par bloc try – catch – finally
try
{
}
finally
{
// toujours faire ceci, quelle que soit l’exception
}
try
{
}
System.out.println(«Exception »);
catch(IOException se)
{
// que faire si une exception de ce type survient
}
Légale
illégale

Traitement des exceptions: try – catch
Exemple
Implémentation
for(int i=0;i<3;i++) {
test[i]=Math.log(i+1);
}
try {
for(int i=0; i<4 ; i++) {
System.out.println("log("+i+") = "+test[i]);
}
} catch(ArrayIndexOutOfBoundsException ae) {
System.out.println(" Arrivé à la fin du tableau ");
}
System.out.println ("Continuer le constructeur ");
Programmation JAVA 27
Pr. A.SADIQ

Exemple 1
import java.io.*;
public class TestExeption {
public static void main(String[] args) {
try { int r;
FileReader in = new FileReader(new File ("point.java"));
while ((r = in.read()) = = -1)
System.out.println(r);
}
catch (FileNotFoundException e) { // Fichier pas existant
System.out.println("Pas de fichier "+e);
e.printStackTrace();
System.exit(1);
}
catch (IOException e) { // Autre erreur d’E/S
System.out.println("Autre erreur");
}
}
}

Lancement avec les mots-clés : throws et throw
• Une méthode avec une propriété throws peut lancer des exceptions avec throw
• Toute exception ou erreur lancée pendant l’exécution provient d’un throw Fonctionne
avec les exceptions qui héritent de Throwable (la classe de base)
• Le développeur peut créer de nouvelles classes d’exceptions et les lancer avec throw
import java.io.*;
class MonException extends Exception {
MonException(String msg){
System.out.println("MyException lancee, msg =" + msg);
}
}
...
void maMethod(boolean flag) throws MonException {
if(!flag) throw new MonException(" Exception dans maMethod" );
…
}
Une classe pour la
gestion des exceptions
Programmation JAVA 29
Pr. A.SADIQ

Exemple 3
public class ExceptionEssai {
public void methode (int a, int b) throws ExceptionAEgalB{
if (a = = b)
throw new ExceptionAEgalB ();
else
System.out.println (a+" et "+b+" OK !");
}
public static void main (String [] args) {
try {
methode (2,2);
System.out.println ("Pas d'erreur");
}
catch (ExceptionAEgalB exp) {
System.out.println ("Erreur "+exp.message());
}
finally{
System.out.println ("Message final" );
}
}
}
30
On indique au compilateur que la méthode est
susceptible de lever une exception de type
ExceptionAEgalB.
On lève effectivement une
instance (new) de l’exception.
Ici les deux nombres sont égaux, donc
l’exception est levée dans méthode
et interceptée par le bloc catch du main.
La méthode message de la classe est
appelée et "Erreur A égal à B!"
apparaît à l’écran.
class ExceptionAEgalB extends Exception {
public String message () {
return "A égal à B !";
}
}
On définit une classe dérivée de la classe
Exception et une méthode retournant un
message.

EXEMPLE 2
import java.util.Scanner;
public class Except2 {
public int factorielle(int n) throws Exception {
int res = 1;
if (n<0){
throw new Exception();
}
for(int i = 1; i <= n; i++)
res = res * i;
return res;
}
public static void main (String [] args) { int x;
System.out.println("Entrez un nombre (petit):");
Scanner clavier=new Scanner(System.in);
x = clavier.nextInt();
try {
System.out.println(factorielle(x));
} catch (Exception e){
System.out.println("Factorielle de " +x+" pasdefinie !");
}
}
}

Exercice
• Créez deux classe PileVideException et PilePleineException dérivée de la classe Exception
• Créez une classe Pile qui contient une variable static final Taille_Max de Pile, un tableau de type int t[] pour stocker les
éléments de Pile, et une variable nb pour le nombre d’élément dans la pile.
• La pile connu par les méthodes suivantes:
– pilevide() boolean returne true si la pile est vide
– empiler() permet d’ajouter un int à la pile si le nbre d’éléments dans la pile est inférieur à Taille_Max sinon lever une
exception de type PilePleineException .
– Sommet() return le dernier élément dans la pile, si la pile est vide il va lever une exception de type PileVideException
– depiler() retirer un élément de la pile, si la pile est vide lever une exception de type PileVideException
– depilerTout() dépiler tous les éléments de la pile un par un en essayant d’utiliser la méthode depiler() lorsqu’il ya un
sommet sinon lever l’exception pilevide
• Créez une classe de teste
– Essayez d’empiler 3 int et de dépiler le tout.
– lever une exception si la pile est vide
– Lever une exception si la pile est plein

public class Pile{
// taille maximum de la pile
private static final int TAILLE_MAX = 3;
// tableau stockant les éléments de la pile
private int t[];
// nombre d’éléments dans la pile
private int nb;
public Pile()
{
t = new int[TAILLE_MAX];
nb = 0;
}
public boolean pileVide()
{ return nb == 0; }
public void empiler(int i) throws Exception
{
if (nb == TAILLE_MAX) throw new Exception();
t[nb] = i;
nb++;
System.out.println("sortie de empiler");
}
public int sommet() throws Exception
{
if (nb == 0) throw new Exception();
System.out.println("sortie de sommet");
return t[nb-1];
}
public void depiler() throws Exception
{
if (nb == 0) throw new Exception();
nb--;
System.out.println("sortie de dépiler");
}
public void depilerTout()
{
try{
while(true)
{
System.out.println(sommet());
depiler();
}
}
catch (Exception e)
{System.out.println("le dépilerTout est passé par là");}
System.out.println("sortie du dépilerTout");
}
}
33

public static void main(String[] args)
{
Pile p = new Pile();
try
{
p.empiler(2);
p.empiler(4);
p.depilerTout();
System.out.println(p.sommet());
}
catch (PileVideException e)
{System.out.println("Le main pense que la pile est vide");}
catch (PilePleineException e)
{System.out.println("Le main pense que la pile est pleine");}
catch (Exception e)
{System.out.println("Le main est passé par là");}
System.out.println("sortie du main");
}
}

Gestion de fichiers,flux d'entrées/sortie,
sérialisation
CHAPITREVI
Programmation JAVA
Pr. A.SADIQ

Pr. A.SADIQ
Gestion de fichiers
• La gestion de fichiers se fait par l’intermédiaire de la classe java.io.File.
• Cette classe possède des méthodes qui permettent d’interroger ou d’agir sur le système de fichiers du
système d’exploitation.
• Un objet de la classe java.io.File peut représenter un fichier ou un répertoire.
• Déclaration :
File monFichier = new File( Note.txt);
• Il s’agit de la création d’objet File et non du fichier physique
monFichier.createNewFile();
• Création du fichier portant le nom Note.txt
36
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Quelques méthodes de la classe java.io.File
• File (String name)
• File (String path, String name)
• File (File dir, String name)
• boolean isFile () : vérifie s’il s’agit d’un fichier
• boolean isDirectory () : vérifie s’il s’agit d’un répertoire
• boolean mkdir () : creation d’un répertoire
• boolean exists () : vérifie s’il existe ou non
• boolean delete () : supprime le fichier ou le répertoire
• boolean canWrite () : vérifie si le fichier peut être modifié
• boolean canRead () : vérifie si le fichier peut être lu
• File getParentFile () : renvoie le répertoire parent
• String [] list () : renvoie la listes des fichiers et des répertoires connu dans le répertoire
37
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Exemple
38
Gestionde fichiers
CHAPITREVI
import java.io.* ;
public class ExempleFile {
ExempleFile () {
liste (new File ("c:")) ;
}
private void liste (File dir){
if (dir.isDirectory () = = true)
{
String fichiers [ ] = dir.list () ;
System.out.println(dir.getAbsolutePath()+":");
for (int i = 0 ; i != fichiers.length ; i++) {
System.out.println("t"+fichiers[i]);
}
}else{
System.err.println (dir + " n'est pas un repertoire") ;
}
}
static public void main (String args [ ]) {
new ExempleFile () ;
}
}

Pr. A.SADIQ
Exemple
import java.io.File;
public class AttributsFichier {
public static void main(String arg[]){
File dir;
dir = new File("c:testBonjour.txt");
if (dir.isFile()) {
System.out.println(dir.getAbsolutePath()+" est un fichier");
}
else if(dir.isDirectory()) {
System.out.println(dir.getAbsolutePath()+" est un repertoire");
}
else System.out.println("…………………………Autre");
System.out.println("taille : "+dir.length()+" octets");
System.out.println("lecture autorisee : "+(dir.canRead()?"oui":"non"));
System.out.println("ecriture autorisee : "+(dir.canWrite()?"oui":"non"));
}
}
39
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les flux
• Pour obtenir des données, un programme ouvre un flux de données sur une source de données(fichier,
clavier, mémoire, etc).
• De la même façon pour écrire des données dans un fichier, un programme ouvre un flux de données
• Java emploie un stream (flux en anglais) entre la source et la destination des données.
• le flux est un canal de communication dans lequel les données sont écrites ou lues de manière
séquentielle.
40
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les flux
• Deux groupes de classes manipulent des flux :
• les classes (abstraites)qui manipulent des flux d’octets (ou bytes) :
• La classe InputStream et ces dérivées pour lire des octets (FileInputStream),
• La classe OutputStream et ces dérivées pour écrire des octets (FileOutputStream)
• Les classes (abstraites) qui manipulent des flux de caractères :
• La classe Reader et ces dérivées (BufferedReader, FileReader)
• La classe Writer et ces dérivées (BufferedWriter, FileWriter)
• Toutes les classes d'entrée/sortie sont dans le package java.io
• Toutes les méthodes peuvent générer une java.io.IOException.
41
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Classes de flux de bytes
• Ce genre de flux peut servir à charger en mémoire des images ou bien de les enregistrer sur le
disque, ils sont aussi utilisés pour enregistrer des objets ou les charger (procédé nommé
sérialisation /désérialisation)
• Les flux d’entrée sont des sous-classes de InputStream et peuvent être classés en deux
catégories:
• Les flux de communication, servant essentiellement à créer une liaison entre le programme et une autre
entité.
• Les flux de traitement qui, comme leur nom l'indique, servent plutôt à traiter les données échangées.
42
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Classes de flux de bytes (InputStream )
les flux de communication:
• FileInputStream:
• Permet de créer un flux avec un fichier présent dans le système de fichiers
• Possède un constructeur prenant en paramètre un objet de type File et un autre prenant
un String comme paramètre, qui représente le chemin vers le fichier.
• ByteArrayInputStream:
• Permet de lire des données binaires à partir d'un tableau d'octets
• La source de ce flux est le programme lui-même
• PipedInputStream:
• Permet de créer une sorte de tube d'entrée (pipe) dans lequel circuleront des octets.
• Utilise pour faire communiquer deux threads
43
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Classes de flux de bytes (InputStream)
Les flux de traitement
• BufferedInputStream:
• Cette classe permet la lecture de données à l'aide d'un tampon
• Lorsqu'elle est instanciée, un tableau d'octets est créé afin de servir de tampon. Ce tableau est redimensionné
automatiquement à chaque lecture pour contenir les données provenant du flux d'entrée
• DataInputStream:
• Sert à lire des données représentant des types primitifs de Java (int, boolean, double, byte, ...) qui ont été
préalablement écrits par un DataOutputStream.
• Possède des méthodes comme : readInt(), readBoolean(), ...
• SequenceInputStream:
• Permet de concaténer deux ou plusieurs InputStream. La lecture se fait séquenciellement en commençant par
le premier et en passant au suivant dès qu'on a atteint la fin du flux courant, tout en appelant sa
méthode close().
• ObjectInputStream:
• Permet de «désérialiser» un objet, c'est-à-dire de restaurer un objet préalablement sauvegardé à l'aide
d'un ObjectOutputStream..
44
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Classes de flux de bytes (OutputStream)
• Pour chaque flux d'entrée qu'on a vu, correspond un flux de sortie
Les flux de communication:
• FileOutputStream:
• permet l'écriture séquentielle de données dans un fichier
• ByteArrayOutputStream:
• permet d'écrire les données dans un tampon dont la taille s'adapte en fonction du besoin.
• On peut récupérer les données écrites avec la méthode toByteArray() ou bien toString().
• Un appel à la méthode close() aussi bien pour cette classe que pour ByteArrayInputStream est sans effet.
• PipedOutputStream:
• Permet la création d'un tube (pipe)
45
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Classes de flux de bytes (OutputStream)
Les flux de traitement:
• BufferedOutputStream:
• Permet d'écrire dans un tampon puis d'écrire le tampon en entier sur le fichier au lieu d'écrire octet par
octet sur le fichier.
• DataOutputStream:
• Permet l'écriture de données sous format Java et assure une portabilité inter-applications et inter-
systèmes.
• ObjectOutputStream:
• Permet de sauvegarder l'état d'un objet dans un fichier ou autre. Pour cela, l'objet doit implémenter
l'interface serializable.
46
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
FileOutputStream
import java.io.* ;
public class EcritFichier
{
static public void main (String args [])
{
String Chaine = "Bonjour les PALIM" ;
try {
FileOutputStream f = new FileOutputStream ("c:data.txt") ;
f.write (Chaine.getBytes ()) ;
f.close () ;
} catch (IOException e)
{
System.err.println ("Erreur ecriture") ;
}
}
}
47
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
FileInputStream
import java.io.* ;
public class LitFichier
{
public static void main (String args [])
{
try {
InputStream s = new FileInputStream ("c:data.txt") ;
byte buf [ ] = new byte [s.available()] ;
s.read (buf) ;
for (int i = 0 ; i != buf.length ; i++)
System.out.print ( (char) buf [i]) ;
s.close () ;
} catch (IOException e)
{
System.err.println ("Erreur lecture") ;
}
}
}
48
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
FileOutputStream, FileInputStream
import java.io.*;
class EcritureBinaire {
try {
FileOutputStream fichier = new FileOutputStream(new File(“c:fichier.txt"));
for (int i=1;i<10;i++)
fichier.write(i);
}catch (IOException e) {
System.out.println(e.toString());
}
try {
FileInputStream fichier = new FileInputStream(new File(“c:fichier.txt"));
for (int i=1;i<10;i++)
System.out.println(fichier.read());
}
}
}
49
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les classes de flux de caractères
• La question qu'on pourrait se poser est:
• Pourquoi des flux spéciaux pour les caractères alors que ce sont des données binaires ?
• Réponse:
• Java, contrairement à beaucoup d'autres langages, utilise Unicode
• les caractères sont codés sur 16 bits et non sur 8
• Ces flux servent donc à gérer les jeux de caractères
• Néanmoins ces classes présentent une certaine analogie avec ce qui a été
vu précédemment et ne devraient donc pas poser de problème
50
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les classes de flux de caractères d'entrée
• Les flux d’entrée étendent pour la plupart la classe abstraite Reader et définissent sa
méthode read().
Les flux de communication
• CharArrayReader:
• c'est l'équivalent de ByteArrayInputStream pour les caractères. Il utilise aussi un tampon indexé pour la
lecture des caractères.
• StringReader:
• Permet la lecture de caractères à partir d'une chaine. La chaine en question est alors la source du flux .
• PipedReader:
• A un comportement très similaire à PipedInputStream : elle se connecte à un PipedWriter afin de créer un
tube pour l'échange de caractères.
• FileReader:
• La classe la plus importante car c'est certainement la plus utilisée. Elle étend InputStreamReader et utilise le
tampon et l'encodage par défaut.
51
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les classes de flux de caractères d'entrée
Les flux de traitement
• InputStreamReader:
• Permet de transformer un flux de données binaires en un flux de caractères.
• Très utile lorsque le tampon ou l'encodage par défaut de FileReader ne conviennent pas.
• Elle possède un constructeur qui prend en paramètres un flux d'entrée de données binaires et un Charset (objet
servant à définir l'encodage à utiliser). La méthode read() lit le nombre nécessaire d'octets constituant un caractère.
• BufferedReader:
• Permet l'emploi d'un tampon (dont on peut spécifier la taille) lors de la lecture d'un flux de caractères.
• Très utile pour améliorer la performance de l'opération de lecture.
• Son emploi est analogue à celui de BufferedInputStream.
• LineNumberReader:
• Sous-classe de BufferedReader, elle en hérite donc l'utilisation d'un tampon et permet en plus de lire ligne par ligne
(tout en les comptant) grâce à la méthode readLine().
52
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les classes de flux de caractères de sortie
• Les flux de sortie étendent tous la classe Writer et redéfinissent, en plus de la méthode write(), la méthode
flush() qui vide le tampon en forçant l'écriture effective des caractères présents dans ce dernier.
Les flux de communication:
• CharArrayWriter:
• permet l'écriture de caractères dans un tampon dont la taille varie afin de contenir les données. A noter que la
méthode close() n'a aucun effet sur une instance de cette classe et que l'appel d'autres méthodes après close() ne lèvent pas
d'IOException.
• StringWriter:
• permet l'écriture de caractères dans un StringBuffer. Son contenu peut être obtenu sous forme de String grâce à la
méthode toString().
• PipedWriter:
• permet de créer un tube où circuleront les caractères en se connectant à un objet de type PipedReader.
• FileWriter:
• Elle convient pour la plupart des cas d'écriture dans un fichier, son fonctionnement est l'opposé de FileReader. Cependant elle
utilise aussi le tampon et l'encodage par défaut.
53
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Les classes de flux de caractères de sortie
Les flux de traitement:
• OutputStreamWriter:
• convertit un flux de données binaires en un flux de caractères.
• PrintWriter:
• permet d'écrire des caractères formatés, très utile pour l'affichage en mode texte.
• BufferedWriter:
• permet l'utilisation d'un tampon et donc d'écrire les caractères par bloc.
54
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Reader /InputStreamReader
import java.io.*;
class Lecture1 {
char c;
try {
System.out.print("Saisie :");
Reader in = new InputStreamReader(System.in);
c=(char)in.read();
System.out.println(" c= "+c);
}
}
}
55
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
BufferedReader
import java.io.*;
class Lecture2 {
String s;
BufferedReader in = new BufferedReader( new InputStreamReader(System.in));
try {
System.out.print("Saisie :");
s=in.readLine();
System.out.println("chaine lue :"+s);
}
catch (IOException e) {
}
}
}
56
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Classe StreamTokenizer
• La classe fournit les méthodes permettant de faire de l’analyse syntaxique élémentaire sur les
données en entrée.
• La lecture se fait d’unité lexicale (token) en unité lexicale.
• Le constructeur d’un StreamTokenizer prend en argument un objet StreamInput ou Reader
• les variables et méthodes les plus utiles :
• double nval si le token est un nombre, c’est sa valeur
• String sval si le token est un mot, c’est la chaîne correspondante
• int TT_EOF constante indiquant la fin du flot
• int TT_EOL constante indiquant la fin d’une ligne
• int TT_NUMBER constante indiquant un nombre
• int TT_WORD constante indiquant un mot
• int ttype contient le type du token et prend une des valeurs constantes définies précédemment
• int nextToken() lit le token suivant, son type est rangé dans ttype et sa valeur éventuellement dans
nval ou sval
57
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Exemple
import java.io.*;
class Analyse {
public static void main (String[] argv) throws IOException {
int somme=0,nb=0; int type;
String stop=new String("fin");
System.out.println("Donnez le nom de l’étudiant, ses notes et terminez avec fin");
StreamTokenizer entree= new StreamTokenizer(new InputStreamReader(System.in));
type=entree.nextToken();
if (type!=StreamTokenizer.TT_WORD) {
System.out.println("donnez d’abord le nom !");
}else {
String nom=entree.sval;
while(true) {
type=entree.nextToken();
if (type==StreamTokenizer.TT_NUMBER) {
somme+=(int)entree.nval;
nb++;
}else
if ((type==StreamTokenizer.TT_WORD) && (stop.equals(entree.sval))) break;
}
System.out.println("La moyenne de "+nom+" est "+((double)somme/nb));
}}
} 58
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
La sérialisation
• La sérialisation d’un objet est le processus de stockage d’un objet complet (par exemple sur un
disque).
• Le processus inverse est la désérialisation.
• Un objet sérialisé est dit persistant.
• Enregistrer des données sur disque nécessite une convention de format pour la lecture/écriture
• Si un objet contient d’autres objets sérialisables, ceux-ci seront automatiquement sérialisés.
• Si la classe a été modifiée entre la sérialisation et la désérialisation, l’exception
java.io.InvalidClassException est déclenchée.
59
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Comment sérialiser
• Une classe est sérialisable si elle implémente l’interface java.io.Serializable.
• Des objets de type java.io.ReadObjectStream et java.io.WriteObjectStream vont permettre de
sérialiser/désérialiser.
• Les données membres que l’on ne souhaite pas sauvegarder doivent être déclarées transient.
• Des méthodes de lecture/écriture peuvent être redéfinies le cas échéant:
• private void writeObject (java.io.ObjectOutputStream out) throws IOException ;
• private void readObject (java.io.ObjectInputStream in) throws IOException,ClassNotFoundException ;
60
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Exemple
import java.io.* ;
class Info implements Serializable{
private String nom = "" ;
private String motPasse = "" ;
public Info(String nom, String motPasse){
this.nom=nom ;
this.motPasse = motPasse ;
}
public String getNom () {
return this.nom ;
}
public String getPassword () {
return this.motPasse ;
}
}
61
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
public class ExempleSerialisation
{
static public void main (String args []) {
new ExempleSerialisation () ;
}
public ExempleSerialisation () {
Info User = new Info ("Sadiq","password") ;
Ecrire (User) ;
User = Lire () ;
if (User != null)
System.out.println ("nom = " + User.getNom() + " mot de passe = " +
User.getPassword ()) ;
}
void Ecrire (Info user){
try {
FileOutputStream file = new FileOutputStream ("c:travailinfo.txt") ;
ObjectOutputStream out = new ObjectOutputStream(file) ;
out.writeObject (user) ; out.flush () ; out.close () ; file.close () ;
} catch (IOException ex){
System.err.println ("Erreur d'ecriture " + ex) ;
}
}
62
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Exemple
Info Lire ()
{
Info User = null ;
try {
FileInputStream file = new FileInputStream ("c:travailinfo.txt") ;
ObjectInputStream in = new ObjectInputStream (file) ;
User = (Info) in.readObject() ;
} catch (Exception ex)
{
System.err.println ("Erreur de lecture " + ex) ;
}
return User;
}
}
63
Gestionde fichiers
CHAPITREVI

Pr. A.SADIQ
Exercice: classe pour la gestion de fichiers
64
Gestionde fichiers
CHAPITREVI
• Créer la classe Fichier Classe: Fichier
private String nom;
private FileWriter fw;
private FileReader fr;
private BufferedReader br;
private BufferedWriter bw;
Fichier(String nom)
getNom(): String
creer () : void
ouvrir () : void
ecrireLigne(String ligne) :void
lireFichier(): void
lireLigne(int numeroLigne):String
supprimeLigne(int numeroLigne) :void
fermer(): void
Utiliez :
FileWriter (String Nom_fichier) :créer un
fichier pour l’écriture
FileReader (String Nom_fichier) : pour la
lecture d’un fichier
BufferedReader (FileReader fr) : temporaire
vers FileReader
BufferedWriter (FileWriter fw) : temporaire
vers FileWriter

Les threads CHAPITREVII
Programmation JAVA

Pr. A.SADIQ
Les threads
• Un thread (tâche en français) est une unité d’exécution au sein d’un même processus (ce n’est pas un
autre processus).
• Tous les threads d’un même processus partagent la même zone mémoire.
• La programmation multithreads donne l’illusion de la simultanéité.
• Un thread possède un nom et une priorité.
• Un thread s’exécute jusqu’au moment où:
• Un thread de plus grande priorité devient exécutable.
• Une méthode wait (), yield () ou sleep () est lancée.
• Son quota de temps a expiré dans un système préemptif.
66
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Création d’un thread
• Une classe est un thread si elle remplit une des deux conditions:
• Elle étend la classe java.lang.Thread
• Elle implémente l’interface java.lang.Runnable
• Le corps du thread est contenu dans une méthode :
public void run ()
• Un thread est lancé par appel d’une méthode start ()
67
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Premier exemple de création d’un thread
class MonThread extends Thread
{
// Constructeur,données membres, méthodes éventuels
…
public void run ()
{
// corps du thread
}
}
MonThread lethread = new MonThread () ; // Création du thread
lethread.start () ; // Appelle la méthode run ()
68
Lesthreads
CHAPITREVII
• Création d’un thread par héritage de la classe Thread

Pr. A.SADIQ
Premier exemple de Création de Thread
69
Lesthreads
CHAPITREVII
public class MaThread extends Thread {
public void run(){
int i=0;
while(true){
if(i++%10==0)
System.out.println(""+(i-1)+" est divisible par 10");
if(i>101) break;
}
}
}
public class LancerThread{
public static void main(String[]arg){
MaThread t=new MaThread();
t.start();
}
}
Grâce à l’héritage, un objet de type
MaThread est lui-même Runnable,
on peut donc appeler un constructeur
sans argument

Pr. A.SADIQ
Deuxième exemple de création d’un thread
• Création d’un thread par héritage de la classe Thread
70
Lesthreads
CHAPITREVII
class MaClass implements Runnable
{
// Constructeur,données membres, méthodes éventuels
…
public void run ()
{
// corps du thread
}
}
MaClass objet = new MaClass () ; // Création d'un objetMaClass
Thread lethread = new Thread (objet) ; // Récupération du
thread
lethread.start () ; // Appelle la
méthode run ()

Pr. A.SADIQ
Deuxième exemple de création d’un thread
71
Lesthreads
CHAPITREVII
public class MaRunnable implements Runnable {
public void run(){
int i=0;
while(true){
if(i++%10==0)
System.out.println(""+i+" est divisible par 10");
if (i>101) break;
}
}
}
public class LanceThread {
Thread t=new Thread(new MaRunnable());
t.start();
}
}}
Le constructeur de la classe Thread
attend un objet Runnable
en argument

Pr. A.SADIQ
Gestion des Thread
• Méthodes de gestion :
• t.start() : démarrer effectivement le thread sur lequel elle est invoquée, ce qui va provoquer l'appel de
la méthode run() du thread.
• t.yield() throws InterruptedException : méthode static permet au thread courant de céder le
contrôle pour permettre à d'autres threads en attente, de s'exécuter
• t.sleep(int milliseconde) throws InterruptedException : méthodes static permettent d'arrêter le
thread courant pendant un certain laps de temps, pour permettre ainsi à d'autres threads en attente,
de s'exécuter.
• t.join() throws InterruptedException : Met la file en attente jusqu’au moment où la file t est
terminée (a fini sa méthode run()). Le thread appelant redevient alors activable.
72
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Gestion des Thread
• t.stop() : Cette méthode permet d'arrêter un thread en cours d'exécution. Elle est utile
principalement pour stopper des threads dont la méthode run() ne se termine jamais
• t.wait() : Suspend le thread.
• t. notify() : Place le thread dans un état exécutable
• t.notifyAll() : Réveille tous les threads en attente
• t.resume() : reprend l'exécution du thread t préalablement suspendu par t.suspend( ).
• t.destroy() : met fin brutalement au thread
73
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Gestion des Thread
74
Les threads
Programmation JAVA
class FileSecondaire implements Runnable{
public void run(){
for(int i=0;i<40;i++){
System.out.println("File secondaire en execution "+i);
try{
Thread.sleep(10);
} catch (InterruptedException ie) {}
}
System.out.println("Fin de file secondaire");
}
}

Pr. A.SADIQ
Gestion des Thread
75
Les threads
Programmation JAVA
public class ExJoin {
Thread t=new Thread(new FileSecondaire());
t.start();
for(int i=0;i<20;i++){
System.out.println("File principale en cours d’exécution "+i);
try{
Thread.sleep(10);
} catch(InterruptedException ie){}
}
try {
t.join();
} catch (InterruptedException ie) {}
System.out.println("t termine son exécution, fin programme");
}
}

Pr. A.SADIQ
Gestion des Thread (Diagrammes d’état)
76
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Exercice
• Nous allons écrire un programme qui simulera le remplissage de la baignoire par un robinet dont le débit est
connu et paramétrable. La baignoire a une fuite dont le débit lui aussi est connu et paramétrable. Dès que la
baignoire est entièrement vide on bouche la fuite et tout rentre dans l'ordre. On arrête le programme dès
que la baignoire est pleine que la fuite soit colmatée ou non.
• Une classe Eau qui contient un champ static indiquant le volume d'eau actuel de l'objet auquel il appartient.
• Une classe Baignoire possédant un contenu (en litres d'eau) et une fuite qui diminue le volume d'eau du
contenu de la baignoire.
• Une classe Robinet qui débite (augmente) le volume d'eau du contenu de la baignoire d'une quantité fixée.
• Une classe Remplir qui permet le démarrage des actions : mise en place de la baignoire, du robinet,
ouverture du robinet et fuite de la baignoire
78
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Solution
public class Robinet extends Thread {
public void debit(int qte)
{
for(int i=1;i<100;i++)
if(Baignoire.contenu.volume<Baignoire.maximum)
{
Baignoire.contenu.volume + =qte;
System.out.println("contenu de la baignoire apres remplissage =
"+Baignoire.contenu.volume);
Thread.yield();
}
else{ System.out.println("la baignoire est pleine !" ); break; }
}
public void run(){
debit(50);
}
}
79
Lesthreads
CHAPITREVII
public class Eau {
int volume;
public Eau(int v){
volume=v;
}
}

Pr. A.SADIQ
Solution
public class Baignoire extends Thread {
public static final int maximum =1000;
public static Eau contenu=new Eau(0);
public void fuite(int qte){
for(int i=1;i<100;i++)
if(Baignoire.contenu.volume<=0){
System.out.println("Baignoire vide, on colmate la fuite !");
break;
} else if(Baignoire.contenu.volume>=Baignoire.maximum) break;
else{ Baignoire.contenu.volume - =qte;
System.out.println("Contenu de la baignoire apres fuite = "
+Baignoire.contenu.volume);
}
}
public void run(){
fuite(20);
}}
80
Lesthreads
CHAPITREVII
public class Remplire {
Baignoire unebaignoire= new Baignoire();
Robinet unrobinet=new Robinet();
unrobinet.start();
unebaignoire.start();
}
}

Pr. A.SADIQ
La synchronisation des threads
• L’utilisation de threads peut entraîner des besoins de synchronisation pour éviter les problèmes liés
aux accès simultanés aux variables.
• La synchronisation des threads se fait grâce au mot clé synchronized, employé principalement comme
« modifieur » d'une méthode
81
Lesthreads
CHAPITREVII
public class Compte {
private double solde;
public void deposer(double somme) {
solde = solde + somme;
}
public double retirer () {
return solde;
}
}

Pr. A.SADIQ
Exemple
• Un producteur est une thread qui dépose des jetons numérotés dans une
trappe qui ne peut contenir qu'un seul jeton. Un consommateur prend ce
jeton qui doit être présent dans le trappe. Donc :
• le producteur doit s'arrêter de déposer des jetons lorsqu'il y en a déjà un et doit être
informer qu'un jeton a été retiré.
• le consommateur ne peut pas prendre de jeton s'il n'y en a pas (arrêt du consommateur) et
doit être informé lorsqu'un jeton a été déposé.
• L'objet le plus à même pour avertir le producteur et le consommateur est la
trappe lui même.
82
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Solution
public class Trappe {
private int contenu;
private boolean valable = false;
public synchronized int get() {
while (valable == false) {
try {wait();
} catch (InterruptedException e) { }
}
valable = false; notifyAll(); return contenu;
}
public synchronized void put(int value) {
while (valable == true) {
try {wait();
}
contenu = value; valable = true; notifyAll();
}
}
83
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Solution
public class Producteur extends Thread {
private Trappe trap;
private int number;
public Producteur(Trappe c, int number) {
trap = c;
this.number = number;
}
public void run() {
for (int i = 1; i < 11; i++) {
trap.put(i);
System.out.println("Producteur #" + this.number + " poser: " + i);
try {
sleep((int)(Math.random() * 100));
}
}
}
84
Lesthreads
CHAPITREVII

Pr. A.SADIQ
Solution
public class Consumateur extends Thread {
private Trappe trap;
private int number;
public Consumateur(Trappe c, int number) {
trap = c;
this.number = number;
}
public void run() {
int valeur = 0;
for (int i = 1; i < 11; i++) {
valuer = trap.get();
System.out.println("Consumateur #" + this.number + " consommer: " + valeur);
}
}
}
85
Lesthreads
CHAPITREVII
public class ProducerConsumerTest {
Trappe c = new Trappe();
Producteur p1 = new Producteur(c, 1);
Consumateur c1 = new
Consumateur(c,1);
p1.start();
c1.start();
}
}

Java-3eme partie.pptx

Contenu connexe

Similaire à Java-3eme partie.pptx

Plus de HassanAbdel

Java-3eme partie.pptx