Programmation Orientée Objet avancée en JAVA

Prof. Rachida HANNANE

r.hannane@uca.ma

Faculté des Sciences Semlalia, Marrakech

Université Cadi Ayyad

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 1/24 1 / 24

 Gestion des exceptions

Gestion des exceptions

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 2/24 2 / 24

 Gestion des exceptions

Définition

Les exceptions représentent le mécanisme de gestion des erreurs

intégré

Exception : condition anormale survenant lors de l’exécution

Lors de l’écriture d’un programme, la prise en compte d’erreurs prend une

place très importante si l’on souhaite écrire un programme robuste

Par exemple, la simple ouverture d’un fichier peut provoquer beaucoup

d’erreurs telles que l’inexistence du fichier, un mauvais format, une
interdiction d’accès, une erreur de connexion au périphérique, ...

Pour que le programme soit robuste, il faut que toutes les erreurs
possibles soient détectées et traitées

Java propose un mécanisme de gestion des erreurs intégré, fondé sur la

notion d’exception

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 3/24 3 / 24

 Gestion des exceptions

Définition

Une exception est un objet qui peut être émis par une méthode si un
événement d’ordre exceptionnel (les erreurs rentrent dans cette catégorie)
se produit

La méthode en question ne renvoie alors pas de valeur de retour, mais

émet une exception expliquant la cause de cette émission

Il y a 5 mots clés d’instructions dédiées à la gestion des exceptions : try,

catch, finally, throw et throws

Les trois mots clés try, catch, finally permettent de détecter et de

traiter ces erreurs, et les deux autre throw et throws permettent de les
lever ou les propager

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 4/24 4 / 24

 Gestion des exceptions

Définition

La gestion d’erreurs par propagation d’exception présente deux atouts

majeurs :

I Une facilité de programmation et de lisibilité : il est possible de regrouper

la gestion d’erreurs à un même niveau. Cela évite des redondances dans
l’écriture de traitements d’erreurs et encombre peu le reste du code avec ces
traitements

I Une gestion des erreurs propre et explicite : certains langages de

programmation utilisent la valeur de retour des méthodes pour signaler
une erreur à la méthode appelante. Etant donné que ce n’est pas le rôle de
la valeur de retour de décrire une erreur, il est souvent impossible de
connaı̂tre les causes réelles de l’erreur. La dissociation de la valeur de retour
et de l’exception permet à cette dernière de décrire précisément la ligne de
code ayant provoqué l’erreur et la nature de cette erreur

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 5/24 5 / 24

 Gestion des exceptions

Classification des erreurs en Java

On peut distinguer quatre types de situations d’erreurs en Java :

1) Erreurs de compilation: Avant même de pouvoir exécuter le programme,

notre code source génère des erreur par le compilateur. Il faut alors réviser
et corriger le code pour ne plus avoir d’erreurs

2) Erreurs d’exécution: Alors que notre programme est en cours d’exécution, la

JVM étant mal configurée ou corrompue, le programme s’arrête ou se gèle. A
priori, c’est une erreur non pas due à notre programme, mais à la
configuration ou l’état de l’environnement d’exécution de notre
programme

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 6/24 6 / 24

 Gestion des exceptions

Classification des erreurs en Java

3) Exception non vérifiée: Alors que notre programme est en cours d’exécution,
une trace de la pile des exceptions est affichée, pointant vers une partie
de notre code sans gestion d’exception. Visiblement, nous avons utilisé du
code qui est capable de lever une exception non vérifiée (comme
NullPointerException). Il faut modifier le programme pour que cette
situation ne survienne pas

4) Exception vérifiée: Une trace de la pile des exceptions est affichée,

pointant vers une partie de notre code avec gestion d’exception.
Visiblement, nous avons produit du code qui est capable de lever une
exception vérifiée (comme FileNotFoundException) mais les données
passées à notre programme ne valide pas ces exceptions. Il faut alors revoir les
données passées en paramètre du programme

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 7/24 7 / 24

 Gestion des exceptions

Hiérarchie des exceptions

Une classe est considérée comme une classe d’exception dès lors qu’elle
hérite de la classe Throwable
Un grand nombre de classes d’exception sont proposées dans l’API pour
couvrir les catégories d’erreurs les plus fréquentes
Elles constituent un arbre hiérarchique utilisant la notion d’héritage

Object // la classe racine de toutes les classes

Throwable // la classe m è re de toutes les exceptions
Error // erreurs graves , abandon du programme
Exception // anomalies r é cup é rables
Ru n T i m e E xception // erreur à l ’ ex é cution
A r i t h m e t i c E x c e p t io n // division par z é ro par exemple
C l a s s C a s t Ex c ep ti o n // mauvaise conversion de classes ( cast )
IndexOutOfBoundsException // en dehors des limites ( tableau )
NullPointerException // r é f é rence nulle
IllegalArgumentException // transmission inappropri é d ’ argument
NumberFormatException // nombre mal form é
IOException // erreurs d ’ entr é es - sorties
FileNotFoundException // fichier inconnu

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 8/24 8 / 24

 Gestion des exceptions

Interception et traitement des exceptions

try, catch et finally

L’interception d’exceptions se fait par une sorte de ”mise sur écoute”

d’une portion de code. Pour cela on utilise le mot-clé try suivi du bloc à
surveiller.
I Si aucune exception ne se produit dans le bloc correspondant, le programme
se déroule normalement comme si l’instruction try était absente.
I Par contre, si une exception est levée, le traitement de l’exception est exécuté
puis l’exécution du programme reprend son cours après le bloc testé.
Il est également nécessaire de préciser quelles classes d’exception doivent être
interceptées dans le bloc testé.
L’interception d’une classe d’exception s’écrit grâce au mot-clé catch
suivi de la classe concerné, d’un nom de variable correspondant à l’objet
exception, puis du traitement.
La clause finally définit un bloc qui sera toujours exécuté, qu’une
exception soit levée ou non. Ce bloc est facultatif. Il est aussi exécuté si
dans le bloc try il y a une instruction break ou continue.

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 9/24 9 / 24

 Gestion des exceptions

Interception et traitement des exceptions

try, catch et finally

Le principe de capture d’exception permet de ne pas interrompre

l’exécution du programme.
Interception par bloc try - catch - finally

try
{
// quelques actions p ot en t ie ll em e nt risqu é es
}
catch ( SomeException se )
{
// que faire si une exception de ce type survient
}
catch ( Exception e )
{
// que faire si une exception d ’ un autre type survient
}
finally
{
// toujours faire ceci , quelle que soit l ’ exception
}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 10/24 10 / 24

 Gestion des exceptions

Interception et traitement des exceptions

try, catch et finally

Exemple : Division par zéro

public class ExcepExemple1 {
public static void main ( String [] args ) {
int i =4;
int j =0;
int x ;
x = i/j;
System . out . println ( " x = " + x );
System . out . println ( " Fin programme " );
}
}

I Si on exécute le programme, un message d’erreur s’affiche :

Exception in thread " main " java . lang . A r i t h m e t i c E x c e p t i o n : / by zero
at ExcepExemple1 . main ( ExcepExemple1 . java :8) Java Result : 1

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 11/24 11 / 24

 Gestion des exceptions

Interception et traitement des exceptions

try, catch et finally
Exemple : Traitement des exceptions
public class ExcepExemple {
public static void main ( String [] args ) {
int i =4;
int j =0;
int x ;
try
{
x = i / j ; // L ’ instruction qui cr é e l ’ exception
System . out . println ( " x = " + x );
}
catch ( Exception err ) // Appel du gestionnaire d ’ exception Exception
{
System . out . println ( " Division par z é ro " );
System . out . println ( " Message System : " + err . getMessage ());
}
System . out . println ( " Fin programme " );
}
}

I l’exécution du programme, nous affiche :

Division par z é ro
Message System : / by zero
Fin programme
Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 12/24 12 / 24
 Gestion des exceptions

Déclaration des exceptions

throws et throw

Il est nécessaire de déclarer, pour chaque méthode, les classes

d’exception qu’elle est susceptible d’émettre
Cette déclaration se fait à la fin de la signature d’une méthode par le
mot-clé throws, à la suite duquel les classes d’exceptions (séparées par une
virgule s’il en existe plusieurs) qui peuvent être générées sont précisées
throws permet de signaler à la JVM qu’un morceau de code, une
méthode, une classe... est potentiellement dangereux et qu’il faut
utiliser un bloc try...catch...
Il est suivi du nom de la classe qui va gérer l’exception
Une méthode avec une propriété throws peut définir les conditions
d’instanciation d’une exception et lancer cette dernière grâce au mot
clé throw suivi de l’instanciation
Une instanciation lancée par le biais de l’instruction throw doit être déclarée
avec throws au préalable !!
Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 13/24 13 / 24
 Gestion des exceptions

Déclaration des exceptions

throws et throw

Exemple : Utilisation de throws et throw

public class ExcepExemple {
public static double division ( double i , double j ) throws Exception /* On doit
citer le type d ’ exception à cr é er */
{
int x ;
if ( j ==0)
throw new Exception ( " Division par 0 " ); /* Cr é ation manuelle d ’ une
exception par une m é thode */
x=i/j;
return x ;
}
public static void main ( String [] args ) {
try
{
double y = division (1 ,0);
System . out . println ( " y = " + y );
}
catch ( Exception erreur )
{
System . out . println ( " Message : " + erreur . getMessage ());
}
System . out . println ( " Fin programme " );
}}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 14/24 14 / 24

 Gestion des exceptions

Déclaration des exceptions

throws et throw

Exemple : Utilisation de throws et throw

I L’exécution du programme, nous affiche :

Message : Division par 0
Fin programme

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 15/24 15 / 24

 Gestion des exceptions

Déclaration des exceptions

Nouvelles classes d’exceptions

En cas de nécessité, on peut créer de nouvelles classes d’exceptions et les

lancer avec throw
Elles descendent des classes Exception ou RunTimeException mais pas de
la classe Error
class MyException extends Exception
{
MyException ( String msg )
{
System . out . println ( " MyException lancee , msg = " + msg );
}
}

void someMethod ( boolean flag ) throws MyException

{
if (! flag )
throw new MyException ( " no flag " );
...
}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 16/24 16 / 24

 Gestion des exceptions

Le choix entre throws et catch

Si on appelle une méthode qui lève une exception non runtime, on utilise :

I catch si l’on peut reprendre sur l’erreur et faire quelque chose de

cohérent (appliquer une action corrective)

I Sinon throws pour propager l’exception vers celui qui a appelé la

méthode qui fera ce qu’il doit faire

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 17/24 17 / 24

 Gestion des exceptions

Exemple applicatif des exceptions

Exemple : Création de nos propos Gestionnaires d’Exception

1 Creation des classes Point, ConstructException, DeplaceException :
/** ** * * * * * * ******** class Point * * * * * * * * * * * * * * * * * * * */
public class Point {
private int x ;
private int y ;
public Point ( int x , int y ) throws C o n s t r u c t E x c e p t i o n
{
if (x <0 || y <0)
throw new C on st r uc t Ex c e p t i o n ( " Erreur de Construction " );
this . x = x ;
this . y = y ;
}
public void deplacer ( int dx , int dy ) throws D e p l a c e E x c e p t i o n
{
if (( x + dx ) <0 || ( x + dy ) <0)
throw new DeplaceE x c e p t i o n ( " Erreur de d é placement " );
this . x = this . x + dx ;
this . y = this . y + dy ;
}
}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 18/24 18 / 24

 Gestion des exceptions

Exemple applicatif des exceptions

Exemple : Création de nos propos Gestionnaires d’Exception

1 Creation des classes Point, ConstructException, DeplaceException :

/** ************* class ConsException * * * * * * * * * * * * * * * * */

class C o n s t r uc tE x ce p ti on extends Exception
{
public C o ns t ru ct E xc e pt io n ( String s ){
super ( s );
}
}

/** ************* class DepException * * * * * * * * * * * * * * * * */

class D e p l a ceException extends Exception {
public D e placeException ( String s ){
super ( s );
}
}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 19/24 19 / 24

 Gestion des exceptions

Exemple applicatif des exceptions

Exemple : Création de nos propos Gestionnaires d’Exception

2 Utilisation des classes Point, ConstructException, DeplaceException :
/** ** * * * * * * ******** class ExcepExemple2 * * * * * * * * * * * * * * * * * * * */
public class ExcepExemple2 {
public static void main ( String [] args ) {
try {
Point p1 = new Point (1 ,2);
p1 . deplacer (1 , 1);
p1 . deplacer ( -5 , -4);
Point p2 = new Point (1 ,3);
}
catch ( C o ns t ru ct E xc e pt io n e ){ System . out . println ( e . getMessage ());}
catch ( DeplaceException e ){ System . out . println ( e . getMessage ());}
System . out . println ( " Fin du programme " );
}
}

I l’exécution du programme, nous affiche :

Erreur de d é placement
Fin du programme

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 20/24 20 / 24

 Gestion des exceptions

Exemple applicatif des exceptions

Exemple : Utilisation du mot clé finally

2 Utilisation des classes Point, ConstructException, DeplaceException :
/** ** * * * * * * ******** class ExcepExemple2 * * * * * * * * * * * * * * * * * * * */
public class ExcepExemple2 {
public static void main ( String [] args ) {
try {
Point p1 = new Point (1 ,2);
p1 . deplacer (1 , 1);
p1 . deplacer (5 , 4);
Point p2 = new Point (1 ,3);
}
catch ( C o ns t ru ct E xc e pt io n e ){ System . out . println ( e . getMessage ());}
catch ( D eplaceException e ){ System . out . println ( e . getMessage ());}
finally { System . out . println ( " La partie Finally " );}
System . out . println ( " Fin du programme " );
}
}

I l’exécution du programme, nous affiche:

La partie Finally
Fin du programme

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 21/24 21 / 24

 Gestion des exceptions

Autre exemple applicatif des exceptions

Dans l’exemple ci-dessous, le programme demande à l’utilisateur de saisir le

numéro d’un mois et affiche à l’écran le nom de ce mois

public class ExempleExcepti o n

{
public static String month ( int mois ) throws I n d e x O u t O f B o u n d s E x c e p t i o n
{
if (( mois < 1) || ( mois > 12))
{
throw new I n d e x O u t O f B o u n d s E x c e p t i o n ( " le numero du mois qui est "
+ mois + " doit ^ e tre compris entre 1 et 12 " );
}
if ( mois == 1) return " Janvier " ;
else if ( mois == 2) return " F é vrier " ;
...
else if ( mois == 11) return " Novembre " ;
else return " D é cembre " ;
}
}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 22/24 22 / 24

 Gestion des exceptions

Autre exemple applicatif des exceptions

Les exceptions qui peuvent être levées par le programme précédent sont
traitées

public class E x e m p l e T r a i t e m e n t E x c e p t i o n {
public static void main ( String [] args ) {
System . out . println ( " Entrez le numero d ’ un mois : " );
try {
Scanner input = new Scanner ( System . in );
int numero = input . nextInt ();
System . out . println ( E x e m p l e E x c e p t i o n . month ( numero ));
} catch ( I n d e x O u t O f B o u n d s E x c e p t i o n e ) {
System . err . println ( " Numero incorrect : " + e . getMessage ());
} catch ( I n p u t M i s m a t c h E x c e p t i o n e ) {
System . err . println ( " Entr é e incorrecte : " + e . getMessage ());
} catch ( IOException e ) {
System . err . println ( " Erreur d ’ acc è s : " + e . getMessage ());
}
}
}

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 23/24 23 / 24

 Gestion des exceptions

Autre exemple applicatif des exceptions

Trois classes d’exception sont traitées dans cet exemple :

I IndexOutOfBoundsException (levé par la méthode month) se produit si le

numero entré par l’utilisateur est inférieur à 1 ou supérieur à 12 ;

I InputMismatchException (levé par la méthode nextInt) qui se produit si le

texte entré par l’utilisateur n’est pas convertible en entier ;

I IOException (levé par la méthode nextInt) qui se produit si il y a eu une

erreur d’accès au périphérique d’entrée.

Dans chacun de ces cas, le traitement consiste à afficher le message d’erreur

associé à l’exception.

Prof. R. HANNANE (FSSM) Programmation Orientée Objet avancée en JAVA 24/24 24 / 24