1

Programmation avancée
Java
PARTIE 6 – ENTRÉES/SORTIES
 2
Plan

 Historique
 Eléments du langage
 Classes et objets
 Collections
 Héritage
 Flux E/S
 Les API
 Interface graphique
 Connexion aux bases de données
 3

Les exceptions
 4
Exceptions

 Le programme idéal est un programme sans erreur

 Un programme sans la moindre erreur n’existe pas

 Plusieurs niveaux de contrôle des erreurs existent :

 Le compilateur : il vérifie la syntaxe, les types et la sémantique
 La gestion des exceptions en 2nd temps
 5
Exceptions

 Pourquoi gérer des exceptions ?

 Le concepteur prévoit un fonctionnement dit nominal de l’application
 L’utilisateur n’a pas forcément connaissance des spécifications rédigées par le
concepteur et va utiliser l’application comme bon lui semble
 Entre deux utilisateurs, l’utilisation ne sera pas forcément la même

 Conséquence : l’application s’arrête si l’utilisateur n’est pas dans le

fonctionnement nominal
 6
Exceptions

 Les exceptions permettent de séparer le bloc d’instructions de la gestion

des erreurs pouvant éventuellement survenir dans ce bloc.
 Deux blocs sont à déclarer pour la gestion des exceptions :
 Un bloc try : il s’agit du bloc pouvant lever l’exception
 Un bloc catch : il s’agit du bloc de traitement de l’erreur. Il prend en paramètre
une instance d’une classe héritant de Exception. Il est possible de combiner
plusieurs blocs catch avec des erreurs différentes.
 7
Exceptions

 Exemple :
try {
// traitement pouvant lever une exception
} catch (final NullPointerException e) {
// Gestion de l'exception NullPointer
} catch (final Exception ex) {
// Gestion des autres exceptions
}
 8
Exceptions

 Lorsqu’un exception est levée dans un programme, elle remonte les

différents appels de méthodes jusqu’à rencontrer un bloc catch qui va la
traiter.

 Si à aucun moment, un bloc catch n’est trouvé, l’exception est capturée

par l’interpréteur et le programme s’arrête.
 9
Exceptions

 Une méthode pouvant lever une exception doit impérativement :

 Soit la traiter elle-même, en contenant le code concernant dans un bloc
try/catch
 Soit propager l’exception à sa méthode appelante. Elle ne la traite pas
directement mais laisse la méthode appelante la traiter à sa place
type methode() throws Exception {

}
 10
Exceptions

 Il est possible malgré le traitement d’une exception, de continuer un

traitement.
 Le bloc optionnel finally est exécuté soit :
 Après un catch
 Un break / continue / return dans le bloc try

 Le bloc est ajouté à la suite du catch

 11
Exceptions

 Il est possible de lever manuellement des exceptions.

 Pour cela, il faut :
 Créer une instance d’une classe dérivant de la classe Exception
 La propager avec le mot clé throw

 Deux possibilités selon le constructeur :

 Soit par défaut
throw new Exception();
 Soit une chaîne de caractères
throw new Exception("message");
 12

Les flux
 13
Flux

 La manipulation des flux se fait selon deux types :

 Les flux d’entrée (lecture) via la classe InputStream
 Contient la méthode read() pour lire dans le flux

 Les flux de sortie (écriture) via la classe OutputStream

 Contient la méthode write() pour écrire dans le flux

 Ces classes sont présentes dans le package java.io

 14
Flux d’entrée

 Il existe plusieurs types de flux selon les données que l’on veut manipuler :
 ByteArrayInputStream : tableau d’octets
 StringBufferInputStream : chaîne de caractères
 FileInputStream : fichier
 PipedInputStream : pipeline
 SequenceInputStream : ensemble de stream
 15
Flux d’entrée

 Exemple de lecture d’un fichier :

FilteInputStream fs = new FileInputStream("nom du fichier");

// Lecture caractère par caractère

int code;
while((code = fis.read() != -1) {
char ch = (char) code;
}

fs.close();
 16
Flux d’entrée

 Pour lire un type de données bien particulier, il faut utiliser une classe dérivant de
FilterInputStream : par exemple la classe DataInputStream

 Les données pouvant être lues sont

 Les types primitifs
 Les Strings

FilteInputStream fs = new FileInputStream("nom du fichier");

DataInputStream ds = new DataInputStream(fs);

int i = ds.readInt();
 17
Flux d’entrée

 Quelques classes dérivant de FilterInputStream :

 DataInputStream : type primitif
 BufferedInputStream : notamment les flux claviers
 PushbackUInputStream : analyse lexicale
 18
Flux de sortie

 Il existe plusieurs types de flux de sortie :

 ByteArrayOutputStream : buffer d’octet en mémoire
 FileOutputStream : fichier
 PipedOutputStream : pipeline
 19
Flux de sortie

 Exemple d’écriture dans un fichier :

FileOutputStream fs = new FileOutputStream("nom du fichier");

// Ecriture caractère par caractère

String text = "Today is a beautiful day";
byte[] mybytes = text.getBytes();
fs.write(mybytes);

fs.close();
 20
Flux de sortie

 Comme pour les flux d’entrée, la classe DataOutputStream permet

d’écrire directement des types primitifs.
 Les mêmes fonctions existent que pour DataInputStream
writeType();
 La classe hérite de FilterOutputStream
 21
Flux de sortie

 Deux autres classes héritant de FilterOutputStream :

 PrintStream : flux standard

PrintStream ps = new PrintStream(new FileOutputStream(fichier));

ps.println("Une ligne");
ps.flush();
ps.close();

 BufferedOutputStream : écriture dans un buffer

 22
Reader / Writer

 Une nouvelle hiérarchie de classes a été mise en place pour gérer les E/S
 Son but :
 Rendre plus flexible les flux
 Internationaliser les flux (Unicode 16 bits)
 Augmenter la rapidité des opérations
 23
Reader / Writer

Ancienne hiérarchie Nouvelle hiérarchie

InputStream Reader
OutPutStream Writer
FileInputStream FileReader
FileOutputStream FileWriter
StringBufferInputStream StringReader
StringWriter
ByteArrayInputStream CharArrayReader
ByteArrayOutputStream CharArrayWriter
PipedInputStream PipedReader
PipedOutputStream PipedWriter
 24
Reader / Writer

 Pour lire dans un fichier :

Reader input = new FileReader("fichier");

char[] array = new char[100];

input.read(array);
System.out.println(array);
 25
Reader / Writer

 Pour écrire dans un fichier :

Writer w = new FileWriter("output.txt");

String content = "test";
w.write(content);
w.close();
 26
Une classe particulière - File

 Package java.io
 Cette classe permet de manipuler des fichiers et des répertoires de la
plateforme.
 Quelques fonctions :
 exists() : vérifie l’existence d’un fichier ou d’un répertoire
 canRead() : droits de lecture
 canWrite() : droits d’écriture
 getLength(): taille
 isDirectory() : vérifie si c’est un répertoire
 27
Une classe particulière - File

 Quelques fonctions :
 list() : retourne la liste des fichiers composant un répertoire
 getAbsolutePath() : chemin complet
 renameTo() : renommage du nom
 delete() : suppression
 28
StreamTokenizer

 Cette classe permet de découper un flux d’entrée en un ensemble de

« tokens »
 Un « token » est un morceau de texte suivant des règles d’écriture
 Ex : un entier : un chiffre suivi d’un autre chiffre …
 Par défaut, le séparateur de tokens est le caractère espace
 La classe StringTokenizer est spécifique au découpage d’objets de type
String.
 StringTokenizer st = new StringTokenizer(str, ";, ");
 29
Sérialisation

 La sérialisation consiste à assurer la sauvegarde et la lecture d’objets dans

un flux

 Très utilisé dans le cadre de transfert d’objets entre machines distantes,

 Assure la cohérence et l’intégrité des données à transférer

 30
Sérialisation

 Pour sérialiser un objet, il faut :

 Créer un OutputStream particulier : ObjectOutputStream
 Appeler writeObject()

 Sur la machine distante :

 Créer un ObjectInputStream
 Appeler readObject()
 31
Sérialisation

// Ecriture
FileOutputStream fos = new FileOutputStream("tmp");
ObjectOutput oos = new ObjectOutputStream(fos);

oos.writeObject("test");
oos.flush();

// Lecture
FileInputStream fis = new FileInputStream("tmp");
ObjectInputStream ois = new ObjectInputStream(fis);
String today = (String)ois.readObject();
 32
Sérialisation

 Par défaut, tous les champs, quelque soit leur niveau de protection sont
sérialisable
 Des problèmes de sécurité peuvent apparaître
 Plusieurs solutions existent :
 Ne pas implémenter Serializable
 Réécrire les méthodes writeObject() et readObject()
 Ajouter le mot clé transient sur les champs à protéger
 Utiliser les classes javax.crypto.SealedObject ou java.security.SignedObject
 33

Fin partie 6

Cyril MARCQ
cyril.marcq@univ-lille.fr