POO Exceptions

5/12/2018 POO Exceptions - slidepdf.com

http://slidepdf.com/reader/full/poo-exceptions 1/57

CoursProgrammation Orientée Objet

1

Gestion des Exceptions

Dr. Lassaad BAATI

Dr. Lassaad BAATI



Problèmes des erreurs dans lesprogrammes

• erreur matérielle (imprimante débranchée,serveur en panne),

• contrainte physique (disque plein),

• erreurs de ro rammation cas non révu ar le

programme, division par zéro, ouverture d’unfichier qui n’existe pas),

• utilisateur récalcitrant (type de données rentrées

par l’utilisateur incorrect)



En cas de problèmes

• envoyer un message d’erreur,• sauvegarder l’ensemble du travail en

cours,

• permettre une sort e correcte uprogramme,

• revenir en arrière et effectuer un autre

traitement.



Comment faire

• Solution : tout prévoir (tester l’égalité àzéro du dénominateur avant une division,etc.)

• Problème : vous avez beau être un bonprogrammeur vous ne pouvez pas toutcontrôler – que faire dans le cas d’un mauvais type en

entrée, ou pour les cas non prévus par leprogramme ?



Introduction

• C’est un évènement qui se déclenchependant l’exécution d’un programme et quiperturbe le flux normal de l’ensemble des

5

.• En Java, une exception est une instance

de la classe Exception ou d’une de sessous-classes.

ISIGK . Dr. Lassaad BAATI



Déclenchement des exceptions

1. Erreur interne de Java

2. Erreur de programmation ou de déroulement

6

– Dépassement de borne, erreur d’E/S, erreur réseau ...

3. Appel d’une méthode qui lève une exception

4. Lancement volontaire d’une exception avec

throw




Exception

• Le mécanisme de gestion d’erreur le plusrépandu est celui des exceptions.

• Quand une erreur se déclenche dans une

méthode, celle-ci crée un objet (exception

7

object).Cet objet contient les informations sur l’erreur (type d’erreur,

état du programme à cet instant, etc).

• La création d’un objet exception et le fournir au

runtime est appelée « throwing an exception ».




Les exceptions

Constat : – même si programme au point toujours des bugs !! – gérer tous les cas possibles peut alourdir la programmation

1. Dissocier la détection d'une anomalie de son traitement.

2. Séparer la gestion des anomalies du reste du code meilleurelisibilité des programmes

introduction des exceptions



Définition

Définition : Le principe de l'exception est de capturer une erreur lorsqu'onsuppose qu'elle peut intervenir dans une partie de code.

try {…r= numérateur / dénominateur;

} catch (Exception e) { //traitement de l'exception

System.out.println("Exception: " + e);}



Déclenchement explicite

Il est possible de déclencher explicitement une exception (on dira qu'onlève une exception) dans un bloc catch.

try {… if (denominateur==0) throw new Exception();

} catch (Exception e) { //traitement de l'exceptionSystem.out.println("Exception: " + e);throw e;

}

Il est possible de déclencher explicitement une exception en dehorsd'un bloc catch, il faut alors le déclarer au niveau de la signature de laméthode qui peut lever cette exception.



ExempleExemple

Définition d'une classe permettant de calculer la racine carrée d'un nb (dans ) nb 0

class sqrt {private r ;

Méthode susceptible

public sqrt (int x) throws ErrNeg {if (x<0) throw new ErrNeg() ;this.r = racinecarre(x);

}

public void affiche() { system.out.println("resultat="+r); }

}

class ErrNeg extends Exception{...}

envoyer une exception

lever une exception



Les exceptions

Passage de paramètres au gestionnaire d'exception :... if (x<0) throw new ErrNeg(x) ; ...

class ErrNeg extends Exception

{ ErrNeg(int a) {x =a ;}public int x ;

}

Poursuite de l'exécution –instruction System.exit() n'est pas obligatoire

–l'exécution peut se poursuivre avec les instructions suivant le bloc try



Lexiques: Acteurs et Actions• Operation

Une méthode qui peut lever une exception.

• Invoker (appel)

une méthode qui appelle des opérations et attrape les exceptionsrésultantes.

• Exception

13

ne escr p on comp e e conc se un v nemen anorma .

• Raise (lever une exception)ramène une exception de l’opération à l’”invoker”, appelé throw en Java. Unautre mot trés utilisé est emit.

• Handle (capturer)la réponse de “invoker” à l’exception, appelé catch en Java.

• Backtrack (retour différent de undo)Abilité à défiler la pile des “frames” à partir d’où les exceptions ont étéétendues, jusqu’à la 1ere position seine de la pile.




Lexique: Types d’Exceptions• Matériel / Hardwaregénérée par le CPU en réponse à une erreur (division par zéro,

dépassement/débordement, erreur de segmentation, etc).

• Programmes / Softwaredéfinie par le développeur pour représenter un nouveau type d’erreur. Cesexceptions portent souvent sur la sémantique.

14

• Erreur de domaine / Domain FailureLes entrées, ou les paramètres des opérations sont invalides ou inappropriés.

• Erreur de portée/ Range FailureL’opération ne peut pas continuer son exécution, ou sortie incorrecte.

• Suivi / MonitorDécrit le statut d’une opération en exécution, c’est un mécanisme pour la mise à jourd’exécution qui est plus simple que les subthreads.




Gestion traditionnelle des erreurs

• Renvoi d’une valeur de retour par lafonction – “Authentique” état d’erreur: booléen

•

15

– Retour par entier, cas particulier d’un retour

• Classiquement -1

– Autres mécanismes

• Renvoi dans les arguments




Défaillances approchetraditionnelle

• Le développeur doit penser à vérifier ses codes de retour• Tout sauf cohérent

– Différent selon les bibliothèques, les appels

• Lisibilité du code – Mélange traitement de donnée/cas d’erreur

16

• Erreur possiblement ignorée par le développeur• surcharge du code destiné au traitement normal à cause des

instructions traitant les exceptions qui lui sont entrelacées.

Le but des mécanismes de traitement d’exception intégrées aux

langages (Java, C++) est de – séparer clairement à l’écriture du code la partie “traitement normal”

de la partie “traitement des exceptions”

– et de forcer le programmeur à gérer les exceptions générées par lesméthodes qu’il utilise.ISIGK . Dr. Lassaad BAATI



Gestion des exceptions• La gestion des exceptions constitue une manière propre de gérer

les situations anormales. – Exception : Erreur soft qu’on peut capturer – Error : erreur sérieuse fin

• L’idée est de signaler les exceptions pour le processus courant enexécution

–

17

, . – Une exception survient au moment de l’exécution• Les exceptions peuvent opérer de façon asynchrone dans une

methode• 2 sous classes qui étendent throwable :

– Exception, – Error

• Un-handled Exception Error (erreur fatale)• RuntimeException




Lexique• throws

Permet d'indiquer que la méthode est suceptible de lever uneexception

• throwLever une exception au premier “handler” disponible dans la pile

d’appel.

18

• trymarque le début du bloc contenant l’ensemble des “exceptionhandlers”.

• catchsi le bloc try génère une exception de ce type, on bascule vers cebloc, pour exécuter les traitements adéquats.

• finallyappelé quand le bloc try conclut, et aprés la fin du bloc catch.




Exceptions

• 2 familles d’exceptions: – non fatales – fatales (provoquent l’arrêt du programme).



Hiérarchie des exceptions Java

java.lang

Object

20

ThreadDeath

Error

N u ll P oi nt er Ex c ep ti on I l le ga lA r gu m en tE x ce pt io n

RuntimeException

java.io.FileNotFoundException

IOException

Exception

Throwable




• Une exception est un objet de typeException

• Instancier par n’importe quelle sous-classed’Exception

• Hiérarchie RuntimeException et Error – Une hiérarchie d’exceptions non contrôlées

par le compilateur



Hiérarchie error: erreurs graves

• Exemples – NoSuchMethodError: la méthode référencée

n’est pas accessible

–



Hiérarchie RuntimeException

• Exemples – ArithmeticException: une erreur arithmétique

(division par 0…)

– ’tableau est en dehors des bornes autorisées.



Il n’est pas obligatoire de gérer lesexceptions de type RuntimeException

public class ZeroDivide{

static public void main(String[] args){

int b = 0;System.out.println("Resultat de ladivision : " + a/b);}

}

• Ce code se compile mais une exception apparaît au niveau del’exécution et le programme s’arrête. – Une ArithmeticException est une RuntimeException.

• Les RuntimeException ne sont pas vérifiées par le compilateur



Les autres exceptions doiventêtre prise en compte

public class TaperTouche{

static public void main(String[] args)

System.out.println("Tapez une touche pour terminer leprogramme");System.in.read();}

}

• Ce code ne compile pas parce que la méthode read() estsusceptible de lever une exception de type IOException



• L’appel d’une méthode qui lance uneexception (une méthode qui déclarequ’elle lance une exception) doit être pris

– Encapsuler l’appel dans un bloc try/catch



Contrôle de flot dans les blocsTry/catch

• Try {Instruction 1; // dans cette instruction il y a une possibilité de

levée d’exception

Instruction i1

Si le bloc Try réussit

} catch (Exception ex) {Instruction j;}

Instruction k;2



Contrôle de flot dans les blocTry/catch

• Try {Instruction 1; // dans cette instruction il y a une possibilité de

levée d’exception

Instruction i1

Si le bloc Try échoue

} catch (Exception ex) {Instruction j;}

Instruction k;3

2



Finally pour ce qui s’exécutedans tous les cas

• Try {Instruction 1;Instruction i;

• Try {Instruction 1;Instruction i;

} catch (Exception ex) {

Instruction j;} finally {

Instruction k;

}

Instruction k;

} catch (Exception ex) {

Instruction j;Instruction k;

}

Remarque: si le bloc try/catch a une instruction return finally s’exécute quand mêmeLe flot saute à finally puis revient à return



Extrait de la documentation dela classe read

• Method Detail read

• public abstract int read() throws IOException – Reads the next byte of data from the input stream. The value

byte is returned as an int in the range 0 to 255. If no byte isavailable because the end of the stream has been reached, the

- . available, the end of the stream is detected, or an exception isthrown. A subclass must provide an implementation of thismethod.

– Returns:• the next byte of data, or -1 if the end of the stream is reached.

– Throws:• IOException - if an I/O error occurs.



Deux manières de gérer les exceptions: laprendre en compte ou l’esquiver

import java.io.IOException;public class TaperTouche

{ static public void main(String[] args){ System.out.println("Tapez une touche pour terminer le programme");

ry{System.in.read();}catch(IOException e){

System.out.println("Une IOException a été détectée !");}}

}



L’esquiver

• Il s’agit de déclarer que vous lancez l’exception même sitechniquement ce n’est pas vous qui la lancez


s a c pu c vo ma n r ng args rows xcep on{System.out.println("Tapez une touche pour terminer leprogramme");System.in.read();

}}




static public void LireClavier throws IOException {System.out.println("Tapez une touche pour terminer le programme");

System.in.read();

}}

Public class Main {static public void main(String[] args) throws IOException

{TaperTouche.LireClavier();

}• Si Main n’esquive pas l’exception ou ne l’encapsule

pas dans un bloc try/catch il y a une erreur decompilation.



Une RunTime exception peut êtreégalement intercepté et déclaré

public class ZeroDivide{

static public void main(String[] args){ int a = 3; int b = 0;

tr{System.out.println("Resultat de la division : " + a/b);System.out.println("Instructions suivant la division...");}catch(ArithmeticException e){System.out.println("Une exception s’est produite ! (ArithmeticException)");}

System.out.println("Instructions qui suivent le bloc catch...");

}}• Maintenant, la division par zéro ne provoque pas la fin du programme.



Créer ses propres classesd’exception

• Imposer à la classe de dériver de laclasse standard Exception

– Exem le transmission d’un messa e augestionnaire d’exception sous forme d’uneinformation de type chaîne.• La classe Exception dispose d’un constructeur

à un argument de type String dont on peutrécupérer la valeur à l’aide de la méthodegetMessage.



class MonZeroException extends Exception

{ public MonZeroException(String e){

super(e);}

}

public class laClauseThrows {

public static void main (String[] args)

{ try{System.out.println("je verifie le nombre donne en argument.");

LaClauseThrows.test(args); }

catch (MonZeroException e){

. . . get essage m t o e e a c asse rowa e

// e.printStackTrace(); méthode de la classe Throwable affiche l’état de la pile d’appels

}

}

public static void test(String [] args) throws MonZeroException{

int n=Integer.parseInt(args[0]);

if (n==0) throw new MonZeroException("j’ai vu un zero");

System.out.println("il n’y a pas eu d’exception pour zero");

}

}

}



Exemple transmission d’information au constructeur del’objet exception

class Point {private int x,y;public Point(int x, int y) throws ErrConst

{ if ((x<0) || (y<0)) throw new ErrConst(x,y);this.x =x; this.y=y;}

public void affiche() {System.out.println("Coordonnées:" +x+" "+y);}

}class ErrConst extends Exception {

public int abs;public int ord;

rr onst ( nt a s, nt or )this.abs = abs; this.ord=ord;}

}public class Exoinfo1 {

public static void main (String args[]) {try {Point a = new Point (1,4);

a.affiche();a = new Point (-3,5);a.affiche();

}catch (ErrConst e){System.out.println("Erreur construction point");System.out.println("coordonnees souhaitées"+e.abs+" "+e.ord);System.exit(-1);}

}}



public class TestExceptions {public static void main (String [] args) {

String test = "non";try {

System.out.println("Début de try");

prendreRisque(test);System.out.println("Fin de try");} catch (HorribleException he) {

System.out.println("Horrible exception");} finally {

System.out.println("finally");}

" "

Exercice

. .}

static void prendreRisque(String test) throws HorribleExeception {System.out.println("début de risque");if ("oui".equals(test)) {

throw new HorribleException();

}System.out.println("fin de risque");return;}

}Quel est le résultat quand test vaut « non » et quand test vaut « oui »?



Gérer plusieurs typesd’exceptions

public class plusieursCatchs {public static void main (String[] args){try{

System.out.println("je verifie le nombre donne enargument.");

• Les blocs catch doivent êtreordonnés du plus petit au plusgrand – Cela dépend de la hiérarchie

d’héritage

n n= n eger.parse n args ;if (n==0) throw new ZeroException("");if (n>0) throw new SupAZeroException("");if (n<0) throw new InfAZeroException("");}catch (ZeroException e){System.out.println("le nombre etait nul");}catch (SupAZeroException e){

System.out.println("le nombre etait superieur a zero");}catch (InfAZeroException e){System.out.println("le nombre etait inferieur a zero");}

}}



Syntaxe généralepublic void setProperty(String p_strValue) throws

NullPointerException

{

if (p_strValue == null) { throw new NullPointerException(“...”); }

}

//---------------------------------------------------

public void myMethod()

40

MyClass oClass = new MyClass();

try {

oClass.setProperty(“foo”);

oClass.doSomeWork();

} catch (NullPointerException npe) {

System.err.println(“Unable to set property: “+npe.toString());} finally {

oClass.cleanup();

}

}




Lancer une exception

• L’instruction throw exception, lance une exception – Ex: throw new UneException;

• Lorsqu’une méthode est susceptible de lancer uneexception ou de la propager, alors elle doit le sp´ecifierdans sa signature grâce au mot-clé throws suivi de la

41

ste es types except on qu e e ance ou propage.

float f(float x, y, z) throws ArithmeticException

{

if( y + z == 0)

throw new ArithmeticException();

return x / (y + z);}

Sortir du programmeSi l’exception n’est pas levéeISIGK . Dr. Lassaad BAATI



Lancer une Exception (suite)

• Cas particulier : si l’exception lancée est uneinstance de RuntimeException ou de sessous-classes, il n’est pas nécessaire de lespécifier dans la signature de la méthode.

42

• Exemple :int fonction(...) //throws RuntimeException

{

if(...)

throw new RuntimeException();

return ...;

}




Capturer une exception

• Lorsqu’un bloc d’instructions contient l’invocation d’une méthodesusceptible de retourner des exceptions, il faut lui associer les traitementsparticuliers requis pour chaque type d’exception qu’il va capturer.

• Syntaxe :try

{

43

... // code générant des exceptions éventuelles}

catch(UneException e1) //rattraper une

{

... // code traitant les exceptions de typeUneException

}

catch(UneAutreException e1) //rattraper une autre

{

... // code traitant les exceptions de typeUneAutreException

}

... // autres blocs catchISIGK . Dr. Lassaad BAATI



Exemple: division par zero

ISIGK . Dr. Lassaad BAATI 44



Exemple: division par zero

void calculerDiviser()

{

float x, y, z;

... // saisie des valeurs de x, y et z

try

45

{return x / (y + z);

}

catch(ArithmeticException e)

{

System.out.println("Erreur: division par zéro");

e.printStackTrace();}

}




Relance d’une exception

• Si une méthode ne contient pas de bloc try-catch alors qu’elle invoque une méthodesusceptible de lancer une exception (dont letype ne dérive pas de RuntimeException) alors

46

elle relance elle-même automatiquementl’exception au niveau de la méthode qui l’ainvoquée.

• Dans ce cas, il faut qu’elle explicite dans sa

signature la liste des types des exceptionsqu’elle ne réceptionne pas.




Propagation d’une exception//Fonction où l’exception est généréevoid calculerDivier() throws ArithmeticException

{ //propagation de l’exception par throws

float x, y, z;

... // saisie des valeurs de x, y et z

{ return x / (y + z);

}

47

// fonction appelante

public float f(float x, y, z) throws ArithmeticException

{

try

{calculerDiviser();}

catch( ArithmeticException e)

{

System.out.println("Erreur: division par zéro");

e.printStackTrace();

}

}ISIGK . Dr. Lassaad BAATI



Propagation d’une exceptionthrows, décaler/propager une exception :

[<modificateur>] <type> <nomMéthode> ([<paramètres>]) throws <liste d'exceptions>

{ <corps de la méthode pouvant lever des exceptions > }

Les exceptions listées sont propagées/transmises à la méthode appelante si elles sontlevées dans le corps de la méthode traitée.

'

48

et la traite.

• Elle permet d'indiquer que la méthode est suceptible de lever une exceptionqu'elle ne capture pas par un try-catch

– ArithmeticException sera propagée/transmise à la méthode appelante si elleest levée.

– Donc il faut que les méthodes qui appelle la méthode solution• mettent éventuellement en place une mécanisme de capture try-catch

• ou qu'elles propagent elles aussi l'exception.




finally

• Si une exception est lancée dans un bloc try, cesont ses blocs catch associés qui essaientd’abord de la réceptionner.

• On peut rajouter un bloc finally { ... } après les

49

blocs catch. Ce qui est dans le bloc finally seraexécuté quoi qu’il arrive :

• soit après l’exécution normale du bloc try,• soit après l’exécution d’un bloc catch,• soit juste avant que l’on quitte la méthode à cause d’une

exception lancée mais non traitée dans la méthode.




Classement des exceptions

• Les exceptions en JAVA peuvent être classéesen : – Error

• Erreurs critiques non « gérables »

–

50

• Erreurs « gérables » (IOException, etc.)

– RuntimeException• Erreurs éventuellement « gérables »

– (NullPointerException)

Les exceptions qu’on crée étendent l’une desexceptions de ces groupes




Exceptions prédéfinies

• Il existe déjà une hiérarchie de classes héritant de laclasse Exception.

• Cette classe (et donc toutes ses dérivées) contient deuxconstructeurs : – un constructeur sans paramètre

51

– et un constructeur prenant une chaîne en paramètre quireprésente le texte explicitant l’erreur.

• Parmi les méthodes déclarées, il y a notamment lesméthodes (throwable)– String getMessage() qui retourne le message d’erreur

passé au constructeur

– et void printStackTrace() qui affiche le contenu de la piled’exécution.




La hiérarchie RuntimeException

• La classe RuntimeException hérited’Exception.

• Les classes suivantes héritent de

52

•ArithmeticException : erreur dans un calcularithmétique, division par zéro, ...

•IndexOutOfBoundsException : indice endehors des limites dans un tableau)

•NullPointerException : appel d’une méthodesur une variable ne référençant aucun objet

• ... ISIGK . Dr. Lassaad BAATI



La hiérarchie IOException

• La classe IOException hérite aussid’Exception.

• Elle regroupe les exceptions rapportées auxtraitements d’entrées-sorties.

53

• es sous-c asses sont :• EOFException,

• FileNotFoundException,

• InterruptedIOException,

• MalformedURLException,

• ObjectStreamException,• ...




Utilisation des exceptions

• Ne pas abuser des exceptions• Ne pas réceptionner une exception pour s’en débarrasser.

• Si on ne sait pas traiter une exception et qu’on pense qu’elle ne pourra pasêtre traitée à un niveau supérieur, écrire ceci :

» catch(Exception e) { throw new

» RuntimeException(e); }.

54

• Traiter l’exception au niveau qui convient le mieux.

• Quand c’est possible, réparer le problème correspondant à

l’exception et rappeler la méthode où elle a eu lieu. (sinon arrêter

le pgm)

• Il existe des cas où l’exception est partiellement traitable au

niveau courant et partiellement à des niveaux supérieurs.

• Effectuer le traitement au niveau courant, puis relancer l’exception (ou un

autre type d’exception) à un niveau supérieur.ISIGK . Dr. Lassaad BAATI



Exemplepublic void foo() {

try

{ /* marque le début du bloc try-catch */

int a[] = new int[2];

a[4] = 1; /* déclenche une exception dépassement del’index */

} catch ( ArrayIndexOutOfBoundsException e)

{

55

System.out.println("exception: " + e.getMessage());

e.printStackTrace();

}

}

/* Ce code peut etre compilé mais génère une exception en

exécution et déclenche l’arrêt du programme */

public int[] bar() {

int a[] = new int[2];

for (int x = 0; x <= 2; x++) { a[x] = 0; }

return a;

}ISIGK . Dr. Lassaad BAATI



Étapes : try…catch…finally

• Chaque bloc try doit avoir au moins un bloc catch ou unbloc finally attaché.

• Si une exception est levée durant le bloc try :

– Le reste du bloc try est ignoré.

56

– S’il y a un bloc catch qui correspond à l’exception levée, il seraexécuté.

– S’il y a un bloc fnally, il sera aussi exécuté.

• S’il n’y a pas d’exceptions levées, et il n’y a pas

d’instruction System.exit() : – Le JVM passe au bloc finally.




Conclusion

• La gestion des exceptions permet de dissocier leprogramme principal de la gestion des erreurs, ou desarrêts brusques du programme.

• Ce n’est pas une nouvelle structure de contrôle enplus des if, while, for, switch.

• La gestion des erreurs ralentit considérablement lavitesse du programme

– Les exceptions doivent rester exceptionnelles!

Documents

POO Exceptions