LES CHAINES DE CARACTÈRES ET LES TYPES ENUMÉRÉS

Texte intégral

(1)Java Les chaines de caractères et les types énumérés La gestion des exceptions La généricité Les collections Ahcène Bounceur.

(2) Partie 1. LES CHAINES DE CARACTÈRES ET LES TYPES ENUMÉRÉS.

(3) Introduction : . Clé "Bonjour" "Salut". Déclaration. Valeur "Bonjour" "Salut". String ch1 ; ch1 = "Bonjour" ; String ch2 = "Salut" ;. . Autres déclarations String ch3 = new String() ; String ch4 = new String("Hello") ; String ch5 = new String(ch2) ; "Hello" ch4.

(4) Les types énumérés Existence depuis jdk 5.0  Déclaration . ◦ enum Jour {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} ◦ Jour courant, debut ; ◦ courant = Jour.mercredi ; ◦ debut = Jour.debut ; . Remarque : Jour est une classe. Elle dérive de la classe Enum.

(5) Les types énumérés . Comparaison d'égalité : ◦ if (courant == Jour.dimanche) …. . Comparaison basée sur un ordre : ◦ Il n’est pas possible d’utiliser les opérateurs arithmétiques usuels sur les types énumérés ◦ On utlisera donc la méthode compartTo    . courant = Jour.mercredi courant.compareTo(Jour.mardi) sera positif courant.compareTo(Jour.vendredi) sera négatif courant.compareTo(Jour.mercredi) sera nul.

(6) Les types énumérés . La méthode ordinal() : elle envoie le rang d'une valeur donnée dans la liste des constantes du type. La première est de rang 0: ◦ courant = Jour.mercredi ◦ courant.ordinal() vaut 2.

(7) Les types énumérés . Itération sur les valeurs ◦ La méthode values() ◦ Jour.values() fournit un tableau formé des 7 valeurs du type Jour  Il est donc possible d'écrire :  For (Jour j : Jour.values() ) //….

(8) Partie II. LA GESTION DES EXCEPTIONS.

(9) Premier exemple Considéronts la classe Point  Supposons que nous traitons uniquement des points avec des coordonnées positifs  Donc, l'affectation d'une valeur négative aux attributs doit déclancher une exception .

(10) Premier exemple . Nous allons d'abord créer l'exception à déclancher : exemple, ErrConst. public class ErrConst extends Exception { ... }. public class Point { public Point(int x, int y) throws ErrConst { if ( (x<0) || (y<0)) throw new ErrConst () ; this.x = x ; this.y = y ; } }.

(11) Gestionnaire d’exceptions try { // instructions } catch (ErrConst e) { System.out.println(Erreur de construction") ; System.exit(-1) ; }.

(12) Gestion de plusieurs exceptions try { ... } catch (ErrConst e) { … } catch (ErrDepl e) { … } finally { ... }.

(13) Notion d'exception En Java, les erreurs se propagent sous la forme d'exceptions Une exception : ◦ ◦ ◦ ◦. est un objet, instance d'une classe d'exception provoque la sortie d'une méthode correspond à un type d'erreur contient des informations sur cette erreur.

(14) Classes d'exceptions Une classe d'exception hérite de java.lang.Throwable correspond à un type d'erreur et encapsule les informations relatives à l'erreur. La méthode public String getMessage() retourne une chaîne de caractères décrivant l'exception    . IndexOutOfBoundsException NullPointerException NumberFormatException ClassCastException.

(15) Graphe d’héritage (partiel).

(16) Déclaration des exceptions possibles Chaque méthode doit déclarer les exceptions qu'elle peut émettre La liste des exceptions possible est indiquée par throws suivi des classes d'exceptions concernées. public static int parseInt(String s) throws NumberFormatException { … }.

(17) Émission et création d'exceptions Lorsqu'une erreur est détectée dans une méthode il faut : - Créer un objet (de classe d'exception) - Émettre cette exception. int getValue(int pos) throws IndexOutOfBoundsException { if (pos > tab.length) throw new IndexOutOfBoundsException("trop grand"); else return tab[pos]; }.

(18) Autre exemple class MonException extends Exception {. public MonException() { } public MonException(String msg) { super(msg); } } … public static void g() throws MonException { System.out.println("MonException levée dans g()"); if (x==0) throw new MonException("démarrée en g()"); }.

(19) Nouvelles exceptions public class FilePleineException extends Exception { … }. public class FileVideException extends Exception { … }.

(20) Traitement des exceptions Si une méthode peut émettre une exception (ou appelle une autre méthode qui peut en émettre une) il faut :.  soit propager l'exception (la méthode doit l'avoir déclarée)  soit intercepter et traiter l'exception.

(21) Propagation d'exceptions public int ajouter(int a, String str) throws NumberFormatException int b = Integer.parseInt(str); a = a + b;. return a; } Throws précise les exceptions susceptibles d’être levées (ou propagées) par cette méthode.

(22) Interception d'exceptions public int ajouter(int a, String str) { try { int b = Integer.parseInt(str); a = a + b; } catch (NumberFormatException e) { System.out.println(e.getMessage()); } Finally { // bloc toujours exécuté } }.

(23) try/catch n’est pas obligatoire (Heureusement !) pour toutes les classes dérivées ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException.

(24) Partie III. LA GÉNÉRICITÉ.

(25) Exemple public class Couple<T> { private T x ; private T y ; public Couple(T premier, T second) { x = premier ; y = second ; } public void afficher() { ... } Public T getPremier() {return x ; } }.

(26) Utilisation de la classe Couple . Couple<Integer> ci ; ◦ Couple d'objets de type Integer. . Couple<Point> pi ; ◦ Couple d'objets de type Point. . T doit être une classe : ◦ Couple <int> pi ;. . // erreur. On peut créer une classe générique avec plusieurs paramètres : public class Couple<T, U> {...}.

(27) Instanciation de types paramétrés public class Exple<T> { Tx; … public void f(…) { x = new T() ; // Erreur } }.

(28) Héritage et programmation générique La classe dérivée conserve les paramètres de type de la classe de base, sans en ajouter d'autres  class C<T> {…}  class D<T> extends C<T> {…} .

(29) Types génériques Les classes, mais aussi les méthodes et les constructeurs, peuvent être paramétrés par un ou plusieurs type(s)  Le type paramètre d’une fonction paramétrée est déduit à l’appel de la fonction.  Exemple : . ◦ <U> void f(U u) {...} ◦ appel f("abc”) : U est implicitement lié à String.

(30) Types génériques . Exemple. class Boite<T,U> { // boîte contenant deux “trucs” private T obj1; private U obj2; public void put1(T t) { obj1 = t; } public void put2(U u) { obj2 = u; }. public <V> boolean put(V v) { if(v.getClass().equals(obj1.getClass())) obj1=(T)v; else if (v.getClass().equals(obj2.getClass())) obj2=(U)v; else return false; return true;. } } Boite<Integer,String> b = new Boite<Integer,String>(); b.put1(new Integer(2)); b.put2("2");// b contient (2, "2") b.put("abc");// b contient (2, "abc") b.put(new Integer(18)); // b contient (18, "abc") b.put(new Char('x'));// b n’est pas modifié.

(31) Paramètres contraints . . Dans l’exemple suivant, on peut instancier une boîte en précisant n’importe quel type de paramètre : public class Boite<T>{ ◦ private T obj; }. . Boite<Integer> b1 = new Boite<Integer>(); ◦ // boîte d’Integer. . Boite<String> b2 = new Boite<String>(); ◦ // boîte de chaînes de caractères.

(32) Paramètres contraints  . On peut contraindre un paramètre à être une certaine sous-classe. Exemple : public class Boite<T extends Number>{ private T obj; } Boite<Integer> b1a = new Boite<Integer>(); // boîte d’Integer (sous-classe de Number) Boite<Float> b1b = new Boite<Float>(); // boîte de Float (sous-classe de Number) Boite<String> b2 = new Boite<String>(); // ERREUR de compilation : // String n’est pas une sous-classe de Number.

(33) Paramètres contraints . Remarques ◦ Le paramètre <T> est équivalent à <T extends Object> ◦ On peut préciser qu’un paramètre T doit être une sousclasse de A et implémente les interfaces I1 et I2 de cette façon : <T extends A & I1 & I2 > ◦ On peut préciser qu’un paramètre T implémente uniquement l’interface I2 de cette façon : <T extends I2 >.

(34) Sous typage . Attention : une classe A paramétrée par un type Y n’est pas une sous-classe de la même classe A paramétrée par un type X super- classe de Y. Exemple :. public class Boite<T>{ private T obj; } Boite<Number> b = new Boite<Integer>(); // ERREUR : // Integer est bien une sous-classe de Number, mais // Boite<Integer> n’est pas une sous-classe de // Boite<Number> . Il faut introduire une contrainte de sous-typage pour corriger le problème :. public class Boite<T>{ private T obj; }. Boite<? extends Number> b = new Boite<Integer>(); // Ok !.

(35) Sous typage Remarques :  Le type le plus général d’une classe A paramétrée est : . A<? extends Object> Un raccourci de A<? extends Object> est A<?>.

(36) Sur-typage . On peut introduire une contrainte de sur-typage :. public class Boite<T>{ private T obj;} Boite<? super Integer> b = new Boite<Number>(); // Ok.

(37) Compilation . Afin de conserver la compatibilité avec les API et les programmes Java antérieurs à Java 1.5, les types génériques sont entièrement convertis en types classiques à la compilation..

(38) Compilation . Conséquences : ◦ On ne peut pas manipuler un paramètre comme une classe :. class Boite<T> { public void f(Object o) { if (o instanceof T) {...}. // ERREUR. T t = new T();. // ERREUR. T[] tab = new T[10];. // ERREUR. T t = (T)o; } }. // WARNING.

(39) Compilation . On peut manipuler un type générique comme un type classique, mais le compilateur émet un avertissement :. class Boite<T> { public void f(Object o) { Boite<Object> Boite<?> Boite<Object> Boite<?> Boite Boite } }. b1 = new Boite<Object>(); b2 = new Boite<Object>(); b3 = new Boite(); b4 = new Boite(); b5 = new Boite<Object>(); b6 = new Boite();. // Ok // Ok // WARNING // Ok // WARNING // WARNING.

(40) Partie IV. LES COLLECTIONS.

(41) Définitions  . Une collection est un objet qui contient d’autres objets En java, il existe plusieurs types de collections organisées en hiérarchie d’interfaces. ◦ Chaque interface détermine les caractéristiques de la collection (éléments indexés ou non, pouvant contenir plusieurs occurrences d’un même objet ou non, ...) ◦ Pour chaque interface, il existe au minimum une classe qui l’implémente ◦ Depuis java 1.5, les collections sont paramétrées par le type des éléments qu’elles contiennent.

(42) Extrait de la hiérarchie dans l’API.

(43) L’interface Collection . L’interface Collection rassemble les opérations basiques nécessaires à la manipulation d’un ensemble d’objets.

(44) L’interface Collection public interface Collection<E> extends Iterable<E> { int size() ; // nombre d’éléments boolean isEmpty() ; // test collection vide boolean contains(Object element) ; // test d’appartenance boolean add(E element) ; // ajout d’élément : // rend vrai seulement si l’ajout est possible boolean remove(Object element) ; // suppression d’élément : // rend vrai seulement si l’élément à supprimer existe Iterator<E> iterator() ; // itérateur (vu plus loin) boolean containsAll(Collection<?> c) ; // test d’inclusion boolean addAll(Collection<? extends E> c) ; // union. boolean removeAll(Collection<?> c) ; // différence boolean retainAll(Collection<?> c) ; // intersection void clear() ; // suppression de tous les éléments Object[] toArray() ; // transformation en tableau d’Object. <T> T[] toArray(T[] a) ; // transformation en tableau de T }.

(45) Sous interfaces de Collection . L'interface Set : représente une collection gérée comme un ensemble : ◦ la collection ne doit pas contenir plusieurs occurrences du même élément ◦ Set hérite de Collection et n’introduit aucune nouvelle méthode.

(46) Sous interfaces de Collection . L’interface List : représente une collection gérée comme une liste : les éléments de la collection sont ordonnés (et peuvent apparaître plusieurs fois).

(47) Sous interfaces de Collection . L’interface List :. public interface List<E> extends Collection<E> { // List dispose de toutes les méthodes de Collection E get(int index); // accès par indice E set(int index, E element); // mise à jour par indice void add(int index, E element); // insertion d’élément à un certain indice E remove(int index); // suppression d’élément à un certain indice boolean addAll(int index, Collection<? extends E> c); // insertion d’une collection à un certain indice int indexOf(Object o);// indice de la première occurrence d’un élément int lastIndexOf(Object o);// indice de la dernière occurrence d’un élément ListIterator<E> listIterator();// itérateur de liste (vu plus loin) ListIterator<E> listIterator(int index);// itérateur de liste (vu plus loin) List<E> subList(int from, int to); // extraction d’une sous-liste }.

(48) Sous interfaces de Collection . L’interface Queue : représente une collection gérée comme une file : ◦ les éléments de la collection sont ordonnés (et peuvent apparaître plusieurs fois).

(49) Sous interfaces de Collection . L’interface Queue :. public interface Queue<E> extends Collection<E> { boolean offer(E e); // place un élément en bout de file E element(); // fourni la tête de file (exception si file vide) E remove(); // supprime la tête de file (exception si file vide) E peek(); // comme element(), mais rend null si la file est vide E poll(); // comme remove(), mais rend null si la file est vide.

(50) Sous interfaces de Collection . L’interface SortedSet : représente un ensemble ordonné : ◦ la collection ne doit pas contenir plusieurs occurrences du même élément ◦ les éléments sont comparables selon un certain ordre ◦ les éléments sont triés selon cet ordre : ils doivent donc implémenter l’interface Comparable<T>  Comparable<T> contient seulement int compareTo(T o) qui renvoie une valeur négative, nulle ou positive, selon que le paramètre o est inférieur, égal, ou supérieur à l’instance courante.

(51) Implémentation de Collection . Implementation de List ◦ Classe Vector ◦ Classe Stack, sous-classe de Vector  Gestion de la liste en pile  Méthodes supplémentaires : push (ajout en sommet de pile), pop (suppression du sommet de pile), peek (lecture du sommet de la pile)  Classe ArrayList : comme Vector, mais non synchronisé  Dans une application non multi-threadée,Vector et ArrayList sont strictement équivalents. . Implémentation de Queue ◦ Classe LinkedList (collection implémentée dans une liste chaînée). . Implémentation de Set ◦ Classe HashSet (collection implémentée dans une table de hachage) ◦ Classe TreeSet, implémentation de SortedSet (collection implémentée dans une structure d’arbre).

(52) Implémentation de Collection . ATTENTION ◦ Les implémentations de méthodes comme  boolean contains(Object e),  boolean remove(Object e), ou  int indexOf(Object e). s’appuient sur la méthode equals pour rechercher un (ou plusieurs) élément(s) de la collection. ◦ Dans la plupart des cas, il est donc impératif de redéfinir equals dans la classe des éléments d’une collection !.

(53) Parcours de Collection . Instruction for Collection<Integer> c = new ArrayList<Integer>(); c.add(1); c.add(2); c.add(3); System.out.println(c) ; for (Integer i : c) System.out.print(i+" ") ;. // [1, 2, 3].

(54) Parcours de Collection . Itérateur ◦ Un itérateur est un objet (qui implémente Iterator) qui permet deparcourir une collection ◦ Un itérateur encapsule un curseur qui se déplace sur une collection.

(55) Parcours de Collection . Interface Iterator :. public interface Iterator<E> { boolean hasNext(); // indique s’il y a un élément après le curseur E next(); // renvoie l’élément situé après le curseur, // puis déplace le curseur void remove(); // supprime le dernier élément rendu par next // ATTENTION : // ne peut être appelé qu’après next, // et une seule fois ! }.

(56) Parcours de Collection . Iterator : ◦ Exemple : Collection<Integer> c = new ArrayList<Integer>(); c.add(1); c.add(2); c.add(3); Iterator<Integer> it = c.iterator(); it.hasNext() ;. c. // true. 1. it. 2. 3.

(57) Parcours de Collection . Iterator : ◦ Exemple : Collection<Integer> c = new ArrayList<Integer>(); c.add(1); c.add(2); c.add(3); it.next() ;. . it.hasNext() ; // true. c. 1. it. 2. 3.

(58) Parcours de Collection . Iterator : ◦ Exemple : Collection<Integer> c = new ArrayList<Integer>(); c.add(1); c.add(2); c.add(3); it.next() ;. . it.hasNext() ; // true. c. 1. 2. it. 3.

(59) Parcours de Collection . Iterator : ◦ Exemple : Collection<Integer> c = new ArrayList<Integer>(); c.add(1); c.add(2); c.add(3); it.next() ;. . it.hasNext() ; // false. c. 1. 2. 3. it.

(60) Parcours de Collection . Itérateur de liste ◦ La fonction ListIterator<E> listIterator() de l’interface List renvoie un itérateur spécialisé pour les listes : public interface ListIterator<E> extends Iterator<E> { boolean hasNext(); // comme pour Iterator E next(); // comme pour Iterator boolean hasPrevious(); // indique s’il y a un élément avant le curseur E previous(); // comme next, mais dans l’autre sens int nextIndex(); // renvoie l’indice de l’élément situé après le curseur int previousIndex(); // renvoie l’indice de l’élément situé avant le curseur void remove(); // supprime le dernier élément rendu // (par next ou par previous) void set(E e) // insère un élément à l’emplacement du curseur }.

(61) Parcours de Collection . Exemple : parcours et affichages des éléments de gauche à droite :. List<Integer> c = new ArrayList<Integer>(); /* ... */ Iterator<Integer> it ; for (it = c.iterator() ; it.hasNext(); ). System.out.println(it.next());.

(62) Parcours de Collection . Exemple : parcours et affichages des éléments de gauche à droite :. List<Integer> c = new ArrayList<Integer>(); ListIterator<?> it ; for(it=c.listIterator(c.size()); it.hasPrevious(); ) System.out.println(it.previous()) ;.

(63) L’interface Map . L’interface Map rassemble les opérations basiques nécessaires à la manipulation d’un ensemble de couples (clé, valeur associée) : ◦ La valeur de la clé est unique dans un Map ◦ À partir d’une clé, on peut créer, lire, ou modifier la valeur associée dans un Map. . L’interface Map contient une interface interne : Entry ◦ Représente les couples (clé, valeur associée).

(64) L’interface Map public interface Map<K,V> { V put(K k, V v); // rajoute ou met à jour le couple (k,v) V get(Object key); // récupère la valeur associée à la clé V remove(Object key); // supprime le couple boolean containsKey(Object k); // indique si la clé existe boolean containsValue(Object v); // idem avec la valeur v int size(); // nombre de couples dans le Map boolean isEmpty(); // indique si le Map est vide void putAll(Map<? extends K, ? extends V> m); // met à jour le Map à partir d’un autre Map void clear(); // vide la Map Set<K> keySet(); // rend l’ensemble des clés Collection<V> values(); // rend la collection des valeurs Set<Map.Entry<K,V>> entrySet(); // ensemble des couples public interface Entry { // interface interne : couple K getKey(); // rend la clé V getValue(); // rend la valeur V setValue(V value); // met à jour la valeur } }.

(65) Sous-interface de Map et implémentations . L’interface SortedMap représente un Map dont les clés sont ordonnées : ◦ les clés sont comparables selon un certain ordre ◦ les couples sont triés selon l’ordre des clés : les clés doivent donc implémenter l’interface Comparable<T>.

(66) Sous-interface de Map et implémentations public interface SortedMap<K, V> extends Map<K, V { SortedMap<K, V> subMap(K min, K max); // sous-ensemble des couples du Map dont les // clés sont comprises entre min et max SortedMap<K, V> headMap(K max); // sous-ensemble des couples du Map dont les // clés sont inférieures à max SortedMap<K, V> tailMap(K min); // sous-ensemble des couples du Map dont les // clés sont supérieures à min K firstKey(); // plus petite clé K lastKey(); // plus grande clé }.

(67) Sous-interface de Map et implémentations . . Implémentations de Map : ◦ Classe Hashtable (ensemble des couples implémenté dans une tablede hachage) ◦ Classe HashMap : comme Hashtable, mais non synchronisé Implémentation de SortedMap : ◦ Classe TreeMap (ensemble des couples triés selon les valeurs de clés et stockés dans une structure d’arbre).

(68) . Merci de votre attention.

(69)

LES CHAINES DE CARACT&Egrave;RES ET LES TYPES ENUM&Eacute;R&Eacute;S

LES CHAINES DE CARACTÈRES ET LES TYPES ENUMÉRÉS