Java Les chaines de caractères et les types …pagesperso.univ-brest.fr/~bounceur/cours_pdf/java/poo/...2011/10/09 · Déclaration des exceptions possibles Chaque méthode doit

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


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


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


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


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


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


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)


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

}


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)


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


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+" ") ;


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


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 !

}


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


Iterator :



it.next() ;


c 1 2 3

it


Iterator :



it.next() ;


c 1 2 3

it


Iterator :



it.next() ;

it.hasNext() ; // false

c 1 2 3

it


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

}


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());


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>


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);


// clés sont inférieures à max

SortedMap<K, V> tailMap(K min);


// clés sont supérieures à min

K firstKey(); // plus petite clé

K lastKey(); // plus grande clé

}


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

Documents

Java Les chaines de caractères et les types …pagesperso.univ-brest.fr/~bounceur/cours_pdf/java/poo/...2011/10/09 · Déclaration des exceptions possibles Chaque méthode doit