C 5

Exceptions Clone Packages
Cours POO
Jean-Baptiste Mouret
mouret@isir.fr
ISIR - Université Paris 6

http://www.isir.fr
Cours 5
Jean-Baptiste Mouret Cours POO

Exceptions

Gestion des erreurs
Gérer les erreurs est primordial pour faire un programme

fiable :
afficher un message d’erreur compréhensible à
l’utilisateur/au programmeur
« rattraper »les erreurs rattrapables (ex. redemander à
l’utilisateur de taper son mot de passe)
faire des traitement spéciaux pour les cas désespérés (ex.
auto-destruction d’une fusée si le programme plante)

Types d’erreurs
Une erreur peut être due à une mauvais utilisation de

fonctions :
accès en dehors d’un tableau
division par zéro
utilisation d’une référence nulle
...
Une erreur n’est pas forcément un bug !

erreur d’entrée de l’utilisateur
accès interdit à certains fichiers/ressources/etc.
...

Les exceptions : concept
Java inclut un mécanisme très puissant pour gérer les

erreurs : les exceptions
Les exceptions sont présentes dans la plupart des
langages modernes (C++, python, c#, ...)
Concept :
seule la fonction appelante est susceptible de savoir quoi
faire en cas d’erreur
si elle ne sait pas le faire, elle délègue le traitement à sa
propre fonction appelante
etc.

Les exceptions : propagation
Principe :
à tout moment, une fonction peut lancer une exception
l’exception est propagée à la fonction appelante
qui la propage à la fonction appelante
qui la propage à la fonction appelante
etc...
... jusqu’à ce qu’une fonction ai du code pour traiter l’erreur
... ou jusqu’à la terminaison du programme

Exemples
Vous avez déjà rencontré des exceptions, exemple :

Dépassement des bornes d’un tableau :
E x c e p t i o n i n t h r e a d "main"
j a v a . l a n g . ArrayIndexOutOfBoundsException : 10
a t Exemple1 . t e s t ( Exemple1 . j a v a : 1 3 )
a t Exemple1 . main ( Exemple . j a v a : 1 8 )
Utilisation d’une référence nulle :
E x c e p t i o n i n t h r e a d "main"
java . lang . NullPointerException
a t t e s t . main ( t e s t . j a v a : 3 2 )

Questions
Comment lancer des exceptions quand vous détectez des

erreurs ?
Comment « attraper » ces exceptions (par ex. pour afficher

un message d’erreur) ?
Quels sont les types d’exceptions disponibles
Comment déclarer ses propres exceptions ?

Lancer des exceptions
Les exceptions :
sont des objets (il y a donc des classes d’exception)
sont automatiquement propagées de méthodes en
méthodes
sont lancées avec l’instruction throw
Les méthodes qui peuvent lancer des exceptions doivent être
déclarées avec throws NomException (attention au s !)

Exemple
public class Exemple {

public void t e s t ( i n t [ ] t , S t r i n g s )
throws ArrayIndexOutOfBoundsException
{
i n t i = S t r i n g . valueOf ( s ) ;
i f ( i < 0 | | i >= t . l e n g t h )
throw new ArrayIndexOutOfBoundsException ( ) ;
/ / . . . du code . . .
}
}
Notez :
throws TypeException : annonce que cette méthode peut
lancer l’exception TypeException
throw new TypeException() : lance l’exception

On peut déclarer être capable de lancer plusieurs types

d’exceptions
Dans ce cas, on sépare les types par des virgules :
public class Exemple {

public void t e s t ( i n t [ ] t , S t r i n g s )
throws TypeException1 , TypeException2
{ /∗ . . . ∗/ }
}

Attraper les exceptions
En Java, les exceptions peuvent être attrapées avec un bloc :

try
{
/ / code pouvant l a n c e r une e x c e p t i o n
}
catch ( TypeException1 e1 )
{
/ / code a e x c e c u t e r en cas d ’ e x c e p t i o n
/ / de t y p e TypeException1
}
catch ( TypeException2 e2 )
{
/ / code a e x e c u t e r en cas d ’ e x c e p t i o n
/ / de t y p e TypeException2
}

Finally
Une clause optionnelle finally permet d’excecuter du code
même en cas d’exception (exemple : fermer une ressource)
public class MaClasse {
public void maMethode ( . . . ) {
try {
/ / i c i , code generant e v e n t u e l l e m e n t
/ / une e x c e p t i o n
F i l e R e a d e r f r = new F i l e R e a d e r ( "toto.txt" ) ;
// et la suite . . .
} catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
/ / t r a i t e m e n t de l ’ e x c e p t i o n
System . e r r . p r i n t l n ( "Toto.txt not found" ) ;
} finally {
f r . c l o s e ( ) ; / / ferme l e f i c h i e r
}
}

Les types d’exception
Deux grands types d’exception :

Erreurs système : générée par l’environnement
Ô RuntimeException
Erreurs contractuelles : mauvaise utilisation d’un objet
Ô Exception

Vérification du compilateur
Si on veut utiliser une méthode qui lance (throws) une

exception (et pas une RuntimeException), le programme
ne compilera que si on indique comment traiter cette
exception
Concrètement :
soit on fait l’appel dans un bloc try/catch
soit on déclare que la méthode que l’on programme peut
elle aussi lancer l’exception
On dit que les RuntimeException ne sont pas vérifiées

Définir ses propres exceptions
Pour définir ses propres exceptions, il suffit de dériver une

classe d’Exception :
public class MonException extends E x c e p t i o n {

private String e ;
public MonException ( S t r i n g e ) { t h i s . e = e ; }
void p r i n t ( ) {
System . e r r . p r i n t l n ( "mon exception, erreur :"
+ erreur ) ;
}
}
// ...
throws new MonException ( ) ;
// ...
catch ( MonException e ) { e . p r i n t ( ) ; }

Héritage entre exceptions
Les exceptions sont des objets
Elles sont donc instances de classes
On peut donc hériter de classes d’exceptions

Hiérarchie des exceptions

Ordre des catch
L’ordre dans lequel on liste les exceptions « catch » est

important
d’abord les sous-classes d’exceptions les moins
génériques
ensuite les sous-classes moins génériques
Raison : si on traite d’abord un cas plus générique, on ne
traitera jamais le cas le plus spécifique
Exemple : si l’exception E2 dérive de E1, comme E1 « est
un » E2, on peut attraper un E2 avec une clause de E1

Intérêt des exceptions

1 Erreurs à la construction
un constructeur ne retourne rien, donc surement pas un
code d’erreur
2 Séparation des préoccupations

d’un côté : code qui génère les erreurs => throw
de l’autre côté : code qui traite les erreurs => try ... catch
3 remontée automatique
4 Syndrome du « segmentation fault »

messages d’erreurs
« remontée » de la pile d’exécution
possibilité de récupération (poursuivre malgré l’exception)

Clone

Copie profonde
public class P o i n t {
public P o i n t ( i n t x , i n t y ) {
this . x = x ; this . y = y ;
}
}
public class C e r c l e {
public C e r c l e ( P o i n t p ) { c e n t r e = p ; }
private Point centre ;
}
public class Test {
public s t a t i c void main ( S t r i n g [ ] arg ) {
P o i n t p1 = new P o i n t ( 2 , 2 ) ;
C e r c l e c1 = new C e r c l e ( p1 ) ;
p1 . move ( 2 , 2 ) ;
/ / c1 . c e n t r e a bouge !
}
}

Copie profonde (2)
Problème : on n’a que copié que la référence vers p

On voudrait faire une « vraie »copie
Ô créer un nouvel objet identique (mêmes attributs)
Méthode classique : on définit une méthode clone() dans

Point qui renvoie une copie

Copie profonde (3)
On pourrait écrire :
public class P o i n t {
public P o i n t ( i n t x , i n t y ) {
this . x = x ; this . y = y ;
}
public P o i n t c l o n e ( ) / / [ a t t e n t i o n , ne f o n c t i o n n e pas ]
{
r e t u r n new P o i n t ( t h i s . x , t h i s . y ) ;
}
}

Clone en Java
Méthode Object clone() dans la classe Object :

renvoie un Object Ô peut « cacher »n’importe quelle classe
Ô nécessite un transtypage : Point p = (Point) p1.clone() ;
implémentation par défaut : copie les champs un par un
avec « = »
Ô ne fonctionne pas dès que l’on a des attributs objets (et pas
type de base)
Pour pouvoir utiliser clone(), la classe doit implémenter
l’interface Cloneable (marqueur)
Dans un clone :
on appelle super.clone() Ô nouvel objet
on appelle clone sur tous les attributs clonables
on recopie les autres attributs
on renvoie le nouvel objet

Un clone correct
public class P o i n t implements Cloneable {
public O b j e c t c l o n e ( )
{ / / super . c l o n e = c l o n e de l a c l a s s e mere
P o i n t o = ( P o i n t ) super . c l o n e ( ) ;
o.x = x; p.y = y;
return o ;
}
public class C e r c l e implements Cloneable {
{
Point centre ;
public O b j e c t c l o n e ( )
{
C e r c l e c = ( C e r c l e ) super . c l o n e ( ) ;
c . centre = centre . clone ( ) ;
return c ;
}
}

Autre intérêt de clone
Lorsque l’on utilise le polymorphisme, on ne sait pas quel

est le « vrai » type de l’objet que l’on manipule
Comment faire une copie du « vrai » objet ?
Exemple :
public class A { }
public class B extends A { }
public class Test {
public s t a t i c void main ( S t r i n g [ ] arg )
{
A a = new B ( ) ;
A a2 = a ; / / c o p i e de r e f e r e n c e
/ / e t une c o p i e profonde ?
}
}

Autre intérêt de clone (2)
Grâce à l’héritage et à clone, on peut effectuer une copie

profonde même dans ce cas
Exemple :
/ / s i on a j o u t e l e s methodes c l o n e . . .
public s t a t i c void main ( S t r i n g [ ] arg )
{
A a = new B ( ) ;
A a2 = a . c l o n e ( ) ; / / a p p e l l e l e c l o n e de B
}
}

Paquetages (package)

Concept
Un paquetage (package) est une collection de classes et

d’interfaces qui fonctionnent ensemble
Sorte de module
On peut imbriquer les packages
Une classe/une interface ne peut appartenir qu’à un seul
paquetage
Buts :
créer des modules afin de mieux s’y retrouver
créer des modules réutilisables
définir un « espace de nom »(pour avoir plusieurs classes
avec le même nom dans un même projet, mais dans des
packages différents)

UML
ax
mon_package
A <<interface>>
Inter1
sous_package
B C

En Java
Pour mettre une classe dans un package, on met en

première ligne du fichier :
package nom_package ;
Pour les packages imbriqués :

package mon_projet . nom_package . sous_package ;
La structure des packages reflète la structure des

fichiers
soit une classe MaClasse dans le package
mon_projet.nom_package ;
elle doit être dans le fichier
mon_projet/nom_package/MaClasse.java

Avec Eclipse...
Créez un package dans votre projet (bouton droit)
Déplacez vos classes dans le package
Pas grand chose à faire avec Eclipse

Ô ne vous privez pas !

Utilisation d’un package
Pour utiliser une classe d’un package, on utilise

l’instruction import au début du fichier
Exemple :
/ / i m p o r t e l a c l a s s e A r r a y L i s t du package j a v a . u t i l
import j a v a . u t i l . A r r r a y L i s t ;
/ / t o u t i m p o r t e r ( p l u s l e n t , moins p r e c i s ) :
import j a v a . u t i l . ∗ ;

Packages et visibilité
Visibilité des classes
/ / c l a s s e v i s i b l e a l ’ e x t e r i e u r du package
public class A { / ∗ . . . ∗ / }
/ / c l a s s v i s i b l e uniquement dans l e package ( d e f a u t )
class B { / ∗ . . . ∗ / }
Visibilité des méthodes et des attributs :

private : uniquement dans la classe
protected : dans les classes dérivées et le package
public : partout

Bonnes pratiques
Toujours mettre ses classes dans un package

Mettre les tests dans un package séparé

C 5

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C 5

Transféré par

Droits d'auteur :

Formats disponibles

Exceptions Clone Packages

ISIR - Université Paris 6

Jean-Baptiste Mouret Cours POO

Jean-Baptiste Mouret Cours POO

Gestion des erreurs

Gérer les erreurs est primordial pour faire un programme

Jean-Baptiste Mouret Cours POO

Une erreur peut être due à une mauvais utilisation de

Une erreur n’est pas forcément un bug !

Jean-Baptiste Mouret Cours POO

Les exceptions : concept

Java inclut un mécanisme très puissant pour gérer les

Jean-Baptiste Mouret Cours POO

Les exceptions : propagation

Jean-Baptiste Mouret Cours POO

Vous avez déjà rencontré des exceptions, exemple :

Utilisation d’une référence nulle :

Jean-Baptiste Mouret Cours POO

Comment lancer des exceptions quand vous détectez des

Comment « attraper » ces exceptions (par ex. pour afficher

Quels sont les types d’exceptions disponibles

Comment déclarer ses propres exceptions ?

Jean-Baptiste Mouret Cours POO

Lancer des exceptions

Jean-Baptiste Mouret Cours POO

public class Exemple {

Jean-Baptiste Mouret Cours POO

On peut déclarer être capable de lancer plusieurs types

public class Exemple {

Jean-Baptiste Mouret Cours POO

Attraper les exceptions

En Java, les exceptions peuvent être attrapées avec un bloc :

Jean-Baptiste Mouret Cours POO

Jean-Baptiste Mouret Cours POO

Les types d’exception

Deux grands types d’exception :

Jean-Baptiste Mouret Cours POO

Si on veut utiliser une méthode qui lance (throws) une

Jean-Baptiste Mouret Cours POO

Définir ses propres exceptions

Pour définir ses propres exceptions, il suffit de dériver une

public class MonException extends E x c e p t i o n {

Jean-Baptiste Mouret Cours POO

Héritage entre exceptions

Les exceptions sont des objets

Elles sont donc instances de classes

On peut donc hériter de classes d’exceptions

Jean-Baptiste Mouret Cours POO

Hiérarchie des exceptions

Jean-Baptiste Mouret Cours POO

Ordre des catch

L’ordre dans lequel on liste les exceptions « catch » est

Jean-Baptiste Mouret Cours POO

Intérêt des exceptions

2 Séparation des préoccupations

4 Syndrome du « segmentation fault »

Jean-Baptiste Mouret Cours POO

Jean-Baptiste Mouret Cours POO

Jean-Baptiste Mouret Cours POO

Copie profonde (2)

Problème : on n’a que copié que la référence vers p

Méthode classique : on définit une méthode clone() dans

Jean-Baptiste Mouret Cours POO