1 / 56

Compléments

Compléments. Chapitre III. Au sommaire de ce chapitre. Les fichiers ----------------- 3 Les classes utilitaires ----- 26 La généricité --------------- 46. 1 – Les fichiers. Les flots. Java propose un ensemble de classes pour la gestion des E/S décrites dans le package java.io

kolton
Download Presentation

Compléments

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Compléments Chapitre III

  2. Au sommaire de ce chapitre • Les fichiers ----------------- 3 • Les classes utilitaires ----- 26 • La généricité --------------- 46

  3. 1 – Les fichiers

  4. Les flots • Java propose un ensemble de classes pour la gestion des E/S décrites dans le package java.io • les E/S sont implémentées par les flots • un flot peut être représenté comme un buffer et des mécanismes associés pour réaliser l'E/S

  5. Les flots (suite) • dans un flot binaire aucune transformation n'est effectuée sur les octets échangés • entre mémoire et disque • dans un flot caractère les données sont stockées sous forme de caractères sur le disque • il y a donc une transformation qui est effectuée

  6. Les classes • La hiérarchie des classes relatives aux E/S comprend 4 classes abstract • InputStream : lecture sur les flots binaires • OutputStream : écriture sur les flots binaires • Reader : lecture sur les flots caractères • Writer : écriture sur les flots caractères

  7. Les classes d'E/S • A cela il faut rajouter aussi comme classes de base : • File : fichier • RandomAcessFile : accès aléatoires sur un fichier

  8. Sérialisation-Désérialisation • Parmi tous les mécanismes d'E/S proposés par Java, le plus intéressant est la sérialisation qui permet : • de sauvegarder des objets dans un fichier • ou de restaurer des objets à partir d'un fichier • Deux classes du package java.io sont utilisées • ObjectOutputStream pour la sérialisation • ObjectInputStream pour la desérialisation

  9. La sérialisation • Classe java.io.FileOutputStream • un FileOutputStream est un flux en sortie pour écrire des données dans un fichier • FileOutputStream est une sous-classe de OutputStream • Classe java.io.ObjectOutputStream • un ObjectOutputStream est un tampon qui reçoit les objets à sérialiser • écrit des données de type primitif (boolean, byte, char, int, etc) et des objets dans un flot de OutputStream

  10. La sérialisation • Pour écrire le tampon dans le flot, on appelle la méthode writeObject() • la classe de l'objet qui effectue la sérialisation doit être public • la classe de l'objet doit implémenter Serializable • Cette méthode appelle également la méthode writeObject() de chaque objet composite • si leur classe implémente l'interface Serializable • et jusqu'à ce que tout ce qui compose l'objet soit écrit

  11. Exemple 1 : sérialisation d’un objet import java.io.*; public class SerializerPersonne { public static void main(String argv[]) { Personne personne = new Personne("Dupond","Jean",175); try { FileOutputStream fichier = new FileOutputStream("personne.ser"); ObjectOutputStream oos = new ObjectOutputStream(fichier); oos.writeObject(personne); oos.flush(); // pour forcer le tampon à se vider dans le fichier oos.close(); // on ferme le tampon pour terminer l’opération } catch (IOException e) { e.printStackTrace(); } } // de main() } Une exception de type IOException peut être levée si un problème intervient avec le fichier

  12. Le fichier obtenu • Après l'exécution de cet exemple, un fichier nommé « personne.ser » est créé. • On peut visualiser sont contenu mais surtout pas le modifier car sinon il serait corrompu • En effet, les données contenue dans ce fichier ne sont pas toutes au format caractères.

  13. L'interface Serializable • Cette interface ne définit aucune méthode • mais permet simplement de marquer une classe comme pouvant être sérialisée (cf. Cloneable) • Elle est définie dans java.io • Si l'on tente de sérialiser un objet qui n'implémente pas l'interface Serializable • une exception NotSerializableException est levée.

  14. Sérialiser des types primitifs • La classe ObjectOutputStream contient aussi plusieurs méthodes qui permettent de sérialiser des types élémentaires et non des objets : • writeInt, writeDouble, writeFloat ...

  15. La dé-sérialisation • Classe java.io.FileInputStream • Un FileInputStream est un flux en entrée pour lire des données à partir d'un fichier • FileInputStream est une sous-classe de InputStream • Classe java.io.ObjectInputStream • Un ObjectInputStream est un tampon qui lit des données de type primitif et des objets à partir un InputStream

  16. Processus de dé-sérialisation • Il est un tout petit peu plus complexe… • Pour remplir un tampon de lecture à partir d'un fichier, on appelle la méthode readObject() • cette méthode renvoie une référence sur Object • il faut donc effectuer un transtypage • Si on ne connaît pas la classe d'appartenance d'un objet (parmi plusieurs possibles) • on récupère la classe par les méthodes getName()et getClass() de la classe Class • exemple : if (monObjet.getClass().getName().equals(MaClasse)

  17. Exemple 1 : dé-sérialiser une Personne public class DeSerializerPersonne { public static void main(String argv[]) { try { FileInputStream fichier = new FileInputStream("personne.ser"); ObjectInputStream ois = new ObjectInputStream(fichier); Personne personne = (Personne) ois.readObject(); System.out.println("Personne : "); System.out.println("nom : "+personne.getNom()); System.out.println("prenom : "+personne.getPrenom()); System.out.println("taille : "+personne.getTaille()); } catch (java.io.IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } // de main() }

  18. Exemple 2 : sérialisation d’un tableau

  19. Exemple 2 : dé-sérialisation

  20. Exemple 2 : la classe Compte

  21. A noter… • La classe ObjectInputStream possède aussi des méthodes pour lire des données de type primitives : • readInt(), readDouble(), readFloat ... • Lors de la déserialisation, le constructeur de l'objet n'est jamais utilisé.

  22. Précisions • Une classe peut effectuer un traitement durant la sérialisation ou désérialisation en implémentant les méthodes suivantes : • private void writeObject (ObjectOutputStream stream) throws IOException; • private void readObject(ObjectInputStream stream)throws IOException, ClassNotFoundException;

  23. Exceptions possibles • Si la classe a changée entre le moment ou elle a été sérialisée et le moment ou elle est déserialisée • une exception est levée : java.io.InvalidClassException • Une exception de type treamCorruptedException peut être levée si le fichier a été corrompu • par exemple en le modifiant avec un éditeur.

  24. Exceptions possibles (suite) • Au cours de la déserialisation : Une exception de type ClassNotFoundException peut être levée si l'objet est transtypé vers une classe qui n'existe plus ou pas au moment de l'exécution. • Par ex. si on renomme Personne.class

  25. Précisions (suite) • Lorsqu'un attribut d'une classe ne doit pas être sérialisé il faut le déclarer transient • Le contenu des attributs sont visibles dans le flux dans lequel est sérialisé l'objet. • Il est ainsi possible pour toute personne ayant accès au flux de voir le contenu de chaque attribut même si ceux si sont private : • Ex. : private transient String codeSecret; • Attention lors de la déserialisation, les champs transient sont initialisé avec la valeur null ! • Un attribut static n'est pas sérialisé • Les sous-classes d'une classe sérialisable le sont également

  26. 2 – Les classes utilitaires

  27. Classes utilitaires • Composants du package java.util fournis • sous forme de classe • ou sous forme d'interface • Quelques exemples • classes conteneurs Vector, Stack, HashMap • classes outils Random, Date • interfaces CollectionIteratorObserver

  28. La classe Vector • Cette classe définit un conteneur de type tableau dynamique • il s'agit d'une collection d'objets de type quelconque • à laquelle on peut accéder soit par un index soit par un itérateur • la classe Vector implémente l'interface List ce qui permet de l'utiliser comme une liste • les instances stockées peuvent être des objets de classes différentes

  29. Constructeurs de la classe Vector • Vector() //crée un vecteur vide • Vector(int capacitéInitiale) // crée un vecteur vide de capacitéinitialCapacité • Vector(int capacitéInitiale, int incrémenteCap ) // crée un vecteur vide de facteur d'accroissement spécifié • …

  30. Classe Vector • Principales méthodes supportées: • ajout, insertion, suppression, recherche, extraction d'un élément Quelques méthodes de la classe Vector • Insertion d'un élément • boolean add(Object o) // ajoute l'élément à la fin du vecteur • void add(int Index, Object element) // insère l'élément donné en position donnée

  31. Quelques méthodes de la classe Vector • Recherche - information • Object get(int index) // renvoie l'élément situé à la position indiquée • int indexOf(Object element) // recherche la première occurrence d'un élément- surcharge // nécessaire de la méthode equals / critère de recherche • int size() // renvoie le nombre de composants du vecteur • Suppression - Modification • Object remove(int index) // supprime l'élément situé à la position indiquée • boolean remove(Object o) // supprime la première occurrence de l'élément donné • void clear() // supprime tous les éléments du vecteur

  32. Quelques méthodes de la classe Vector • Conversion d'un vecteur en un tableau • Object[] toArray() • Object[] toArray(Object[]tab) • Tri du conteneur • Spécifier que la classe des objets du conteneur implémente l'interface Comparable • Implémenter la méthode compareTo dans cette classe • Invoquer la méthode sort de la classe Collections Vector conteneur = new Vector(20,5); …. Collections.sort(conteneur);

  33. Exemple type Object par défaut Transtypage obligatoire

  34. Exemple

  35. Exemple

  36. Exemple

  37. Interface Comparable • Tous les objets qui doivent définir un ordre utilisé par le tri d'une collection • doivent implémenter cette interface. • Cette interface = une seule méthode : int compareTo(Object) • Cette méthode doit renvoyer : - une valeur entière négative si l'objet courant est inférieur à l'objet fourni - une valeur entière positive si l'objet courant est supérieur à l'objet fourni - une valeur nulle si l'objet courant est égal à l'objet fourni

  38. Interface Comparable • Les classes wrappers (=Integer, Short, Double, etc), String et Date implémentent cette interface.

  39. Les collections • Les collections en Java stockent toujours des références sur les objets contenus dans la collection et non les objets eux mêmes. • Ce sont obligatoirement des objets qui doivent être ajoutés dans une collection • Il n'est pas possible de stocker directement des types primitifs : il faut obligatoirement encapsuler ces données dans des wrappers.

  40. Interfaces Java pour les collections Les interfaces à utiliser par des objets qui gèrent des collections sont : • Collection : interface qui est implementée par la plupart des objets qui gèrent des collections. • Map : interface qui définie des méthodes pour des objets qui gèrent des collections sous la forme clé/valeur • Set : interface pour des objets qui n'autorisent pas la gestion des doublons dans l'ensemble • List : interface pour des objets qui autorisent la gestion des doublons et un accès direct à un élément • SortedSet : interface qui étend l'interface Set et permet d'ordonner l'ensemble • SortedMap : interface qui étend l'interface Map et permet d'ordonner l'ensemble

  41. Collections personnalisées • Le package Java pour les collections fournit aussi plusieurs classes abstraites • qui proposent une implémentation partielle d'une interface pour pouvoir créer une collection personnalisée : • AbstractCollection, AbstractList, AbstractMap, AbstractSequentialList et AbstractSet

  42. Classe COLLECTIONS • La classe Collections propose plusieurs méthodes statiques • qui effectuent des opérations sur des collections • Ces traitements sont polymorphiques car ils demandent en paramètre un objet qui implémente une interface et retourne une collection • Ex. void copy(List, List) //copie tous les éléments de la seconde liste dans la première • Enumaration enumeration(Collection) // renvoie un objet Enumeration pour parcourir la collection • Object max(Collection) // renvoie le plus grand élément de la collection selon l'ordre naturel des éléments • Object max(Collection, Comparator) // renvoie le plus grand élément de la collection selon l'ordre naturel précisé par l'objet Comparator

  43. Classe Collections (suite) • void sort(List) // trie la liste dans un ordre ascendant selon l'ordre des éléments defini par l'interface Comparable qui est donc obligatoire dans les élements constituant la liste !! • void sort(List, Comparator) // trie la liste dans un ordre ascendant selon l'ordre précisé par l'objet Comparator • Si un élément dans la liste n’implémente pas l'interface Comparable : • une exception de type ClassCastException est levée

  44. Quelques méthodes de l’Interface Collection • boolean add(Object) // ajoute l'élément fourni en paramètre à la collection. La valeur de retour indique si la collection a été mise à jour • boolean addAll(Collection) // ajoute à la collection tous les éléments de la collection fournie en paramètre • void clear() // supprime tous les éléments de la collection • boolean contains(Object) // indique si la collection contient au moins un élément identique à celui fourni en paramètre • boolean containsAll(Collection) // indique si tous les éléments de la collection fournie en paramètre sont contenus dans la collection

  45. Quelques méthodes de l’Interface Collection • boolean isEmpty() // indique si la collection est vide • Iterator iterator() // renvoie un objet qui permet de parcourir l'ensemble des éléments de la collection • boolean remove(Object) // supprime l'élément fourni en paramètre de la collection. La valeur de retour indique si la collection a été mise à jour • boolean removeAll(Collection) • supprime tous les éléments de la collection qui sont contenus dans la collection fournie en paramètre • int size() // renvoie le nombre d'éléments contenu dans la collection • Object[] toArray() // renvoie d'un tableau d'objets qui contient tous les éléments de la collection

  46. 3 – La généricité

  47. Rappel sur la généricité • Problème du typage des données • chaque type a une représentation interne particulière • et un certain nombre d'opérateurs associés • conséquence: pour une même algorithme l'implémentation dépend du type • La généricité vise donc à s'affranchir du type des données • classes génériques • méthodes génériques

  48. Java et la généricité • Pas de mécanisme dédié pour la généricité • comme en C++ avec les templates • Cependant en Java : • toutes les classes héritent implicitement de la classe Object • et en pratiquant le transtypage on peut transformer une instance de Object dans un type voulu • Ainsi, en définissant un modèle au moyen de la classe Object • il est possible de structurer des données de type quelconque

  49. Java et la généricité • Mais l'absence pour l'instant de template en Java comporte des limites • En effet un template est modèle générique • il est expansé lors de son utilisation • la résolution de la définition appropriée des méthodes à utiliser est donc faite lors de l'utilisation du modèle

  50. Java et la généricité • En Java la classe qui traduit le modèle est compilée, d'où un certain nombre de problèmes • dans le cas du clonage la seule méthode clone connue à la compilation est celle de Object qui ne fait qu'une copie superficielle • dans le cas d'une comparaison, tout dépend dépend de la sémantique de l'objet qui est inconnue au moment de la traduction

More Related