Java Les chaines de caractères et les types...
Transcript of Java Les chaines de caractères et les types...
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
LES CHAINES DE CARACTÈRES ET LES TYPES ENUMÉRÉS
Partie 1
Introduction :
Déclaration
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
"Bonjour" "Bonjour"
"Salut" "Salut"
Clé Valeur
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
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
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
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() ) //…
LA GESTION DES EXCEPTIONS
Partie II
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
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 ;
}
}
Gestionnaire d’exceptions
try {
// instructions
}
catch (ErrConst e) {
System.out.println(Erreur de construction") ;
System.exit(-1) ;
}
Gestion de plusieurs exceptions
try {
...
}
catch (ErrConst e) { … }
catch (ErrDepl e) { … }
finally {
...
}
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
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
Graphe d’héritage (partiel)
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 {
…
}
É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];
}
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()");
}
Nouvelles exceptions public class FilePleineException extends Exception { … }
public class FileVideException extends Exception { … }
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
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
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é
}
}
(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
try/catch n’est pas obligatoire
LA GÉNÉRICITÉ
Partie III
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 ; }
}
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> {...}
Instanciation de types paramétrés
public class Exple<T> {
T x ;
…
public void f(…) {
x = new T() ; // Erreur
}
}
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> {…}
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
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é
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
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
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 sous-
classe 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 >
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 !
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<?>
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
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.
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
}
}
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> b1 = new Boite<Object>(); // Ok
Boite<?> b2 = new Boite<Object>(); // Ok
Boite<Object> b3 = new Boite(); // WARNING
Boite<?> b4 = new Boite(); // Ok
Boite b5 = new Boite<Object>(); // WARNING
Boite b6 = new Boite(); // WARNING
}
}
LES COLLECTIONS
Partie IV
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
Extrait de la hiérarchie dans l’API
L’interface Collection
L’interface Collection rassemble les
opérations basiques nécessaires à la
manipulation d’un ensemble d’objets
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
}
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
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)
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
}
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)
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
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
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)
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 !
Parcours de Collection
Instruction for Collection<Integer> c = new ArrayList<Integer>();
c.add(1);
c.add(2);
c.add(3);
System.out.println(c) ; // [1, 2, 3]
for (Integer i : c)
System.out.print(i+" ") ;
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
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 !
}
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() ; // true
c 1 2 3
it
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 3
it
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 3
it
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
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
}
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());
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()) ;
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)
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
}
}
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>
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é
}
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)
Merci de votre attention