cours2

Quelques classes
La classe Object
 Il s ’agit de la classe principale, elle contient les
fonctions :
 protected Object clone() qui crée et retourne une copie de l ’objet
 boolean equals(Object obj) qui détermine si obj est égal à l ’objet
courant.
 protected void finalize() appelé par le ramasse miettes s ’il n ’y a
plus de référence à l ’objet
 Class getClass() retourne la classe courante de l ’objet
 int hashCode() retourne une clé pouvant être utilisé pour un tri
 void notify() réveille un processus en attente sur l ’objet
 void notifyAll() réveille tous les processus en attente
 String toString() retourne une chaîne représentant l ’objet
 void wait() mets en pause le processus courant en attendant un
réveil
La classe String (1)
 Les chaînes sont constantes, leurs valeurs ne
peuvent être changées après leurs créations.
 StringBuffer permet l ’utilisation de chaînes
"dynamiques".
 Construction :
String str = "abc"; est équivalent à
char data[] = {'a', 'b', 'c'};
String str = new String(data);
 La classe String comporte des méthodes d’accès aux
caractères, de comparaisons, de recherche, d’extraction, de
copie, de conversion minuscules/majuscule, ...
La classe String (2)
 L ’opérateur (+) est surchargé pour
permettre la concaténation, et à la conversion
implicite d’objets en chaîne.
 Toute conversion se fait de manière
automatique en faisant appel à la méthode
toString() héritée de la classe Object.
Il est donc possible de surcharger cette
méthode dans les nouvelles classes créées.
La classe String (3)
 char charAt(int index)  retourne le caractère de la position index
 int compareTo(String anotherString)  compare la chaîne à une autre, en gérant les majusculesminuscules. Retourne 0 en cas d’égalité, un entier négatif si la chaîne est inférieure à l’autre, et positif
si la chaîne est supérieure à l’autre chaîne.
 int compareToIgnoreCase(String str)  idem que la précédente, mais ignore la case.
 String concat(String str)  ajoute la chaîne str à la fin de la chaîne.
 boolean endsWith(String suffix)  teste si la chaine se termine par le suffixe.
 boolean equals(Object anObject)  nécessaire pour comparer deux chaînes, traite la case.
 boolean equalsIgnoreCase(String anotherString)  idem, mais ignore la case.
 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)  copie les caractères de la
chaîne dans un tableau de caractères.
 int indexOf(int ch)  retourne l’index de la première occurrence du caractère.
On trouve aussi int indexOf(int ch, int fromIndex) ; int indexOf(String str) et int indexOf(String
str, int fromIndex)
 Ainsi que int lastIndexOf(int ch) ; int lastIndexOf(int ch, int fromIndex) ; int
lastIndexOf(String str) ; int lastIndexOf(String str, int fromIndex) ;.
 int length()  retourne la longueur
 String replace(char oldChar, char newChar)  retourne une nouvelle chaîne après le remplacement
de toutes les occurrences du caractère.
 boolean startsWith(String prefix)  teste si la chaîne commence par le préfixe.
 String substring(int beginIndex, int endIndex)  extrait une sous-chaîne.
 String toLowerCase() ; String toUpperCase()  change la case.
 String trim()  efface les espaces avant et après.
Des classes très utiles
(import java.util.*)
Interfaces : Collection, Comparator, Enumeration,
EventListener, Iterator, List, ListIterator, Map,
Map.Entry,Observer, Set, SortedMap, SortedSet
Classes : AbstractCollection, AbstractList, AbstractMap,
AbstractSequentialList, AbstractSet, ArrayList, Arrays,
BitSet, Calendar, Collections, Date, Dictionary, EventObject,
GregorianCalendar, HashMap, HashSet, Hashtable, LinkedList,
ListResourceBundle, Locale, Observable, Properties,
PropertyPermission, PropertyResourceBundle, Random,
ResourceBundle, SimpleTimeZone, Stack, StringTokenizer,
TimeZone, TreeMap, TreeSet, Vector, WeakHashMap
Quelques classes de java.util
 La classe Vector est la plus utilisée. Elle permet de
stocker des objets dans un ensemble de longueur
variable.
 addElement(objet) permet d’ajouter un objet en queue,
 get(index) permet de récupérer l’objet positionné à l’index
donné,
 find() permet de récupérer la position de l ’objet,
 isEmpty() teste si le vecteur est vide,
 size() donne la taille du vecteur.
Quelques classes de java.util
 La classe Stack hérite directement de la classe
Vector et ajoute entre autres les méthodes :
 push(objet) : ajoute un objet en tête ;
 pop() : retire le premier objet ;
 peek() : renvoie une référence au premier objet sans le
retirer ;
 empty() : teste si la pile est vide.
 Une pile peut aussi contenir des objets de
différents types.
Quelques classes de java.util
 La classe Hashtable peut être vue comme un
dictionnaire composé de deux vecteurs : un vecteur
pour la clé et un vecteur pour l’objet.
 Une table de clés possède les méthodes :
 put(clé, objet) :
 get(clé) :
 containskey(clé) :
 containsvalue(objet) :
 isEmpty() :
 entre autres...
Quelques classes de java.util
 La classe Set définit un ensemble ne pouvant
contenir qu’un exemplaire d’un objet.
 Cette classe dispose, entre autres, des méthodes :
 add(objet) qui n’ajoute l’objet que s’il n’est pas déjà présent
 contains(objet) ;
 remove(objet) ;
 isEmpty().
Quelques classes de java.util
 L ’interface Enumeration ne contient que deux
méthodes :
 nextElement() : retourne l ’objet (à caster) courant et
passe à l’élément suivant,
 hasMoreElements() : indique la présence d’au moins un
élément.
 elle est utilisée surtout pour la lecture des éléments
d’un vecteur :
for(Enumeration e=vecteur.elements();e.hasMoreElements();)
System.out.println(e.nextElement()) ;
 Remarque : elements() est la méthode qui retourne une
énumération à partir du vecteur.
Gestion d ’exceptions
Les exceptions
 La gestion des exceptions est très importante, voire
primordiale, dans tous systèmes informatiques.
Elle confère un aspect beaucoup plus professionnel
aux applications.
 Eviter les applications qui plantent sans information
précise, ex :
Les exceptions (2)
 Les exceptions sont des instances des
classes héritant des classes
 java.lang.Error (pour des erreurs graves quasi
impossibles à gérer : plus de mémoire, classe
manquante, ...)
 java.lang.Exception (pour des exceptions
attendues sinon probables pouvant être gérée :
débordement d ’un tableau, erreur de calcul, ...).
 Ces deux classes implémentent l’interface
Throwable
Les exceptions (3)
 La classe Exception possède deux constructeurs
Exception() et Exception (String msg) ).
 Elle hérite de l ’interface Throwable de :
 getMessage qui permet de récupérer le message de
l’exception s’il existe.
 toString, qui retourne la classe et le message sous forme
de chaîne.
 printStackTrace, qui fait appel à toString, mais qui en plus
indique l’endroit du programme où a été levée l’exception.
Capture d’une exception
Pour récupérer, ou attraper, une exception :
….
try
{…. //endroit où pourrait apparaître une exception }
catch (type_exception_1 e1)
{ …. // traitement de l’exception de type 1 }
catch (type_exception_2 e2)
{ …. // traitement de l’exception de type 2 }
finally
{ …. // dans tous les cas, passer par ici }
….
Exemple
...
total = 0
try
Exception levée
{
somme = a + b;
moyenne = somme / total;
nb_moy = nb_moy + 1
Partie abandonnée
}
catch(Exception e)
{
System.out.println(« division par 0 ...»);
Exception
moyenne = 0;
attrapée et gérée
nb_moy = nb_moy + 1
}
...
reprise du cours normal
du programme
Des classes d ’Exception
ClassNotFoundException, CloneNotSupportedException,
IllegalAccessException, .InstantiationException,
InterruptedException, NoSuchFieldException,
NoSuchMethodException, RuntimeException,
ArithmeticException, ArrayStoreException,
ClassCastException, IllegalArgumentException,
IllegalThreadStateException, NumberFormatException,
IllegalMonitorStateException, IllegalStateException,
IndexOutOfBoundsException,
ArrayIndexOutOfBoundsException,
StringIndexOutOfBoundsException,
NegativeArraySizeException, NullPointerException,
SecurityException, UnsupportedOperationException
Exemple (2)
...
total = 0
try
Exception levée
{
somme = a + b;
moyenne = somme / total;
nb_moy = nb_moy + 1;
}
Erreur de calcul attrapée et
catch(ArithmeticException e)
gérée
{
System.out.println(« division par 0 ...»);
moyenne = 0;
nb_moy = nb_moy + 1;
}
catch(Exception e)
Autres erreurs
{
System.out.println(«... erreur inconnue ...»);
}
...
Propagation d ’une exception
 Si une exception n ’est pas gérée dans une
procédure, elle se propage hors de la
procédure,
 Il faut donc que cette procédure soit capable
de propager l ’exception (utilisation du mot clé
throws),
 Si à la fin du programme, une exception n ’a
pas été attrapée, la pile des méthodes
traversées par l'exception est affichée.
Exemple (3)
void moyenne() throws Exception
Exception propagée
{
total = 0
somme = a + b;
Exception levée
moyenne = somme / total;
nb_moy = nb_moy + 1
}
public static void main(Strig args[])
{
try {moyenne(); }
Exception
catch(Exception e)
{
attrapée et gérée
System.out.println(« division par 0 ...»);
}
}
Définir son exception
Il est possible de définir une exception en la
faisant dériver de la classe Exception :
class ExceptionMoyenne extends Exception
{
public String toString()
{
return "Problème de moyenne";
}
}
Le mot clé throw permet de lancer son
exception.
Exemple (4)
void moyenne() throws ExceptionMoyenne
Exception propagée
{
total = 0
somme = a + b;
Exception lancée
if (total==0) then throw (new ExceptionMoyenne());
moyenne = somme / total;
nb_moy = nb_moy + 1
}
public static void main(Strig args[])
{
Exception
try {moyenne(); }
catch(ExceptionMoyenne e)
attrapée et gérée
{
System.out.println(e.getMessage());
}
}
Les Entrées-Sorties
La classe Java.lang.System
 Utilisation des classes et interfaces du
package java.io
 Il existe trois flux (flots) :
 System.in : flux d ’entrée,
 System.out : flux de sortie standard,
 System.err : flux de sortie pour message d ’erreur.
 Les entrées sorties peuvent générer une
exception de type IOException à gérer
Exemple (read)
import java.io.*;
class Lire
{
public static void main(String[] argv)
{
int b, nb = o;
try
{
while((b = System.in.read())!=10)
{
nb++;
system.out.println(b);
}
}
catch(IOException e){ …}
}
}
Flux d ’entrées
 InputStream dont dérivent les classes
ByteArrayInputStream, FileInputStream,
FilterInputStream, InputStream,
ObjectInputStream, PipedInputStream,
SequenceInputStream et StringBufferInputStream
 Reader (orientée caractères) dont dérivent les classes
BufferedReader, LineNumberReader,
CharArrayReader, FilterReader, PushbackReader,
InputStreamReader, FileReader, PipedReader,
StringReader
Flux de sorties
 OutputStream dont dérivent les classes
ByteArrayOutputStream, FileOutputStream,
FilterOutputStream, ObjectOutputStream,
OutputStream, PipedOutputStream
 Writer (orientée caractères) dont dérivent les classes
BufferedWriter, CharArrayWriter, FilterWriter,
OutputStreamWriter, PipedWriter, PrintWriter,
StringWriter
Gestion de fichiers
 La classe File permet d’accéder aux
caractéristiques des fichiers et répertoires.
 Trois constructeurs :
 File(File dir, String name) ;
 File(String path, String name);
 File(String path).
 Les différentes méthodes sont :
 canRead() ; canWrite() ; delete() ; equals(Object
obj) ; exists() ; getAbsolutePath() ;
getCanonicalPath() ; getName() ; getParent() ;
getPath() ; hashCode() ; isAbsolute() ;
isDirectory() ; isFile() ; lastModified() ;
length() ; list(FilenameFilter filter) ; list() ;
mkdir() ; mkdirs() ; renameTo(File dest) ;
toString().
Exemple (File)
public static void main(String args[])
{
File f = new File("C:\\ProgJava\\Fichiers", "Essai.java");
System.out.println("Essai.java est dans le répertoire " + f.getPath());
if (f.exists())
{
System.out.println("Essai.java est dans le répertoire " + f.getPath());
System.out.println(" droits en lecture, écriture" + f.canRead() + "," +
f.canWrite() );
}
}
Exemple (FileInputStream)
FileinputStream fis;
byte[] b = new byte[1024];
try
{
fis = new FileInputStream(" toto.txt ");
}
catch (FileNotFoundException e) {…}
try
{
int i =fis.read(b);
}
catch (IOException e) {…}
String s = new String (b);
Exemple de filtre
( DataInputStream )
 Lecture de données typées, y compris les chaînes de caractères pouvant
être lues ligne par ligne… N ’est plus recommandée depuis java 1.1
public static void main(String args[])
{
File f = new File("C:\\ProgJava\\Fichier", "Essai.java");
if (f.exists())
{
String chaine = "";
try
{
FileInputStream fis = new FileInputStream(f);
DataInputStream bis = new DataInputStream(fis);
chaine = bis.readLine();
bis.close();
fis.close();
}
catch (Exception e) {}
System.out.println(chaine);
}
}
Exemple (FileOutputStream)
FileinputStream fis;
byte[] b = new byte[1024];
try
{
fis = new FileInputStream(" toto.txt ");
}
catch (FileNotFoundException e) {…}
try
{
int i =fis.read(b);
}
catch (IOException e) {…}
String s = new String (b);
Java.io.FileOutputStream
Exemple d ’écriture dans un fichier :
public static void main(String args[])
{
File f = new File("C:\\ProgJava\\fichier", "Essai.txt");
try
{
FileOutputStream fos = new FileOutputStream(f);
String s = new String (" Coucou ");
int longueur = s.length();
byte[] buffer = s.getBytes();
for(int i = 0; i < longueur; i++) fos.write(buffer[i]);
fos.close();
}
catch (Exception e) {}
}
Exemple de filtre
( DataOutputStream )
Lecture de données typées, y compris les chaînes de caractères …
public static void main(String args[])
{
File f = new File(" C:\\ProgJava\\fichier", "Essai.txt");
try
{
FileOutputStream fos = new FileOutputStream(f);
DataOutputStream dos = new DataOutputStream(fos);
dos.writeBytes(" coucou ");
dos.close();
fos.close();
}
catch (Exception e) {}
}
}
Depuis le JDK 1.1 et Java2
 Notion de flot de caractères
(characters Streams) :
 On ne travaille plus uniquement sur des bytes,
mais sur des caractères
 Apparition de 2 classes : Writer et Reader
 FileReader
<->
FileInputStream
 FileWriter <-> FileOutputStream
 Echange facile de données avec accents
(unicode)
Récapitulation
Flot de caractères
Description
Reader
Classe Abstraite pour flot d ’entrée (InputStream)
BufferedReader
Bufférise les entrées ligne par ligne
LineNumberReader
Garde trace du nb de lignes lues
CharArrayReader
Lit un tableau de caractères
InputStreamReader Ttransforme un flot de byte et car. Unicode
FileReader
Transforme des bytes lus depuis un fichier en car.
FilterReader
Classe abstraite pour filtrer les caractères
d ’entrées
PipedReader
Lecture depuis PipeWriter
StringReader
Lit depuis une chaîne de caractères
Récapitulation
Flot de caractères
Description
Writer
(OutputStream)
Classe Abstraite pour flot de sortie
BufferedWriter
Bufférise les sorties ligne par ligne
CharArrayWriter
Ecrit un tableau de caractères
inputStreamWriter
Transforme un flot de car. Unicode en flot de bytes
FileWriter
Transforme un fichier de car. en flot de bytes
PrintWriter
Ecrit des valeurs et des objs dans un Writer
PipedWriter
Ecrit dans un PipeWriter
StringWriter
Ecrit dans une chaîne de caractères
Exemple (FileWriter)
public static void main(String args[])
{
File f = new File("C:\\Progjava\\fichier", "Essai.txt");
try
{
FileWriter fw = new FileWriter(f);
PrintWriter pw = new PrintWriter(fw);
// ou PrintWriter pw = new PrintWriter(new FileWriter(f));
pw.println(" coucou ");
pw.close();
fw.close();
}
catch (Exception e) {}
}
Exemple (FileReader)
public static void main(String args[])
{
String chaine = "";
File f = new File("C:\\Progjava\\fichier", "Essai.txt");
try
{
}
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
// ou BufferedReader br = new BufferedReader(new FileReader(f));
chaine = br.readLine();
br.close();
fr.close();
}
catch (Exception e) {}
System.out.println(chaine);
Exemple (Saisie clavier)
public static void main(String args[])
{
String chaine = "";
try
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
chaine = br.readLine();
}
catch (Exception e) {}
System.out.println(chaine);
}
La sérialisation
 Signifie persistance,
 Pour éviter la perte des données à la fin de
l ’exécution
 Si un objet contient un autre objet, ce dernier
est aussi sérialisé, et on obtient un arbre de
sérialisation
Sérialisation (2)
 Les objets transients
 Ce sont des objets qui ne peuvent pas être
sérialisés (processus, flux de données)
 Si ils sont inclus dans un objet sérialisé, il
faut indiquer qu ’ils sont transient
 idem si on ne veut pas que certaines parties
d ’un objet soient sérialisées
Syntaxe pour la sérialisation
 La classe doit implémenter l ’interface
serializable (pas de méthode à implémenter)
 Exemple :
import java.io.*;
class MaClasse implements Serializable
{
public transient Thread mathread;
private String nom;
private int total;
Bidon reservoir; ...
Sauvegarde d ’un objet
public static void main(String args[])
{
Bidon b1 = new Bidon("b1", 25);
Bidon b2 = new Bidon("b2", 50);
File f = new File("C:\\Progjava\\fichier", "Essai.obj");
try
{
FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(b1);
oos.writeObject(b2);
oos.close();
fos.close();
}
catch (Exception e) {}
}
Lecture d ’un objet persistant
public static void main(String args[])
{
File f = new File("C:\\Progjava\\fichier", "Essai.obj");
try
{
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fis);
Bidon b1 = (Bidon) ois.readObject();
Bidon b2 = (Bidon) ois.readObject();
ois.close();
fis.close();
}
catch (Exception e) {}
}