Exceptions

Exceptions
Les Exceptions
Philippe Genoud
dernière mise à jour : 10/01/2017
© Philippe GENOUD UGA Janvier 2017 1

Exceptions Exceptions ???
 mécanisme utilisé très fréquemment dans le langage Java
 les exceptions sont rencontrées dans de nombreuses situations
C:>java throwtest 3
certaines exécutions i = 3
peuvent faire java.lang.ArrayIndexOutOfBoundsException: 3
at throwtest.b(throwtest.java:92)
apparaître (lever)
at throwtest.a(throwtest.java:65)
des exceptions at throwtest.main(throwtest.java:58)
try {
valSurface = Integer.parseInt(surface.getText());
instructions try catch }
dans les programmes catch (NumberFormatException execpt)
{
surface.setText("ENTIER !!!");
return; // on sort sans creer d'instance
}

 les exceptions sont rencontrées dans de nombreuses situations
Dans la documentation de certaines méthodes

 Mais alors qu’est-ce qu’une exception ?
 Un exception est un signal

 qui indique que quelque chose d'exceptionnel (par exemple une
erreur) s'est produit,
 qui interrompt le flot d'exécution normal du programme.
 lancer (throw) une exception consiste à signaler ce quelque chose,
 attraper
(catch) une exception permet d'exécuter les actions
nécessaires pour traiter cette situation.

Exceptions Mécanisme
 lorsqu'une situation exceptionnelle est rencontrée, une exception est lancée

 si cette exception n'est pas attrapée dans le bloc de code où elle a été lancée,
elle est propagée au niveau du bloc englobant,
 si celui-ci ne l'attrape pas elle est transmise au bloc de niveau supérieur et ainsi
de suite...
 si l'exception n'est pas attrapée dans la méthode qui la lance, elle est propagée
dans la méthode qui invoque cette dernière.
 si la structure de bloc de la méthode d'invocation ne contient aucune instruction
attrapant l'exception, celle-ci est à nouveau propagée vers la méthode de niveau
supérieur.
 si une exception n'est jamais attrapée :
 propagation jusqu'à la méthode main() à partir de laquelle l'exécution du

progamme a débutée,
 affichage d'un message d'erreur et de la trace de la pile des appels (call
stack),
 arrêt de l'exécution du programme.

Exceptions Mécanisme
public static void main (String[] args){
...
if (...) {
... 1 Dépassement d’index,
methodeX() arrêt de l’exécution normale
... et lancement de
} ArrayOutOfBoundsException
...
} 7 STOP 2 Transmission du contrôle au
bloc de niveau supérieur
public static void methodeX(){
... 6 3 Si il y a du code pour traiter
Point[] pts = new Point[10]; (attraper) l’exception reprise
... { du flot d ’exécution normal
Point b = barycentre(pts);
...
4 Sinon on recommence comme
}
en 2
...
}
5 Si aucun code dans la méthode
public static Point barycentre(Point[] pts){
pour traiter l’exception le
...
contrôle est transmis au niveau
if (...) {
de la méthode appelante et on
for (int i = 0; i <= pts.length; i++)
recommence comme en 2
{ 1 5
... pts[i] ... 6 Et ainsi de suite...
...
}
2
7 Jusqu’à ce que l’on aboutisse au
3 ... bloc du programme principal,
} 4 alors arrêt de l’exécution et
... impression de la pile des appels.
}
Exceptions Objets exceptions
 en JAVA les exceptions sont des objets
 toute exception doit être une instance d'une sous-classe de la classe
java.lang.Throwable
Récupérables le programme
possède deux sous- Throwable a la possibilité d'attraper ces
classes standards exceptions
non récupérables
erreurs "systèmes"
(plus de mémoire,
problèmes chargement Error Exception
dynamique...)
LinkageError RunTimeException IOException MyException1
pour définir de nouveaux

ArrayIndexOutOfBounds
types d'exceptions, EOFException FileNotFoundException
Exception
en général on sous-classera
(directement ou indirectement)
java.lang.Exception MyException2

 Puisqu'elles sont des objets les exceptions peuvent contenir :

 des attributs particuliers,
 des méthodes.
 Attributs et méthodes standards (définis dans java.lang.Throwable)
contient un message
Throwable d'erreur décrivant
l'exception
String message
Constructeurs (sans et
Throwable cause
avec message d ’erreur)
Throwable()
Throwable(String s)
renvoie le message
Throwable(Throwable cause)
d'erreur décrivant
String getMessage()
l'exception
void printStackTrace()
Throwable getCause() affiche sur la sortie erreur
standard la liste des appels
Permet le « chaînage » de méthodes ayant conduit à
des exceptions l'exception (backtrace).

 La représentation des exceptions sous forme d'objets permet de mieux

structurer la description et le traitement des erreurs
"Because all exceptions that are thrown within a Java program

are first-class objects, grouping or categorization of exceptions
is a natural outcome of the class hierarchy. Java exceptions
must be instances of Throwable or any Throwable descendant.
As for other Java classes, you can create subclasses of the
Throwable class and subclasses of your subclasses.
Each "leaf" class (a class with no subclasses) represents
a specific type of exception and each "node" class (a class with
one or more subclasses) represents a group of
related exceptions. "
[The Java Tutorial, Campione &Walrath 97]

Exceptions Objets exception
 Structuration de la description des exceptions
En Java
Dans ce bon vieux C
#define EOF_ERROR 1 Exception

#define FILENOTFOUND_ERROR 2
#define ZIP_ERROR 3
IOException
Niveau d'abstraction qui permet de désigner

toutes les exceptions liées au E/S
FileNotFound
EOFException ZipException
Exception
Les exceptions étant des objets, leur structuration en une

hiérarchie de classes permet de les traiter à différents niveaux
d'abstraction (via polymorphisme)

Exceptions Objets exception
 On peut être amené à définir une hiérarchie de classes (sans nécessairement
définir de nouveaux attributs et nouvelles méthodes) uniquement dans un souci
de structuration et de typage des exceptions
class CompteException extends Exception {
private int noCompte;
Exception public CompteException(int c, String mess) {
super(mess);
noCompte = c;
}
CompteException public int noCompte() {

return noCompte;
int noCompte }
CompteException(c : int, mess :String) }
getNoCompte() : int
class CompteNotFoundException extends CompteException {
public CompteNotFoundException(int c, String mess) {
super(c,mess);
}
}
CompteNotFoundException CompteOpException class CompteOpException extends CompteException {

public CompteOpException(int c, String mess) {
super(c,mess);
}
}
DebiterException VirerException

Exceptions Traitement
 try{ … } délimite un ensemble d'instructions susceptibles de déclencher

une(des) exception(s) pour la(les)quelles une gestion est mise en œuvre
 cette gestion est réalisée par des blocs catch(TypeDexception e){ … }
qui suivent le bloc try
 permettent d'intercepter ("attraper") les exceptions dont le type est spécifié et
d'exécuter alors du code spécifique.
try {
String[] lireTexte(String nomfic){
String nomFichier;
...
System.out.print("nom fichier :");
...
nomFichier = LectureClavier.lireChaine();
FileReader f= new FileReader(
String[] text=lireTexte(nomFichier);
new File(nomfic));
for (int i = 0; i < text.length; i++) {
...
System.out.println(text[i]); Le fichier
...
} n'existe pas !
...
...
return ... ;
} création d’un objet
} FileNotFoundException
catch (FileNotFoundException e) { et arrêt de l'éxécution
e.printStackTrace(); normale
System.out.println(e.getMessage());
... Traitement local
} de l’erreur
...
Poursuite de
...
l ’exécution
 un bloc try est suivi par une ou plusieurs clauses catch qui permettent
d'intercepter ("attraper") les exceptions dont le type est spécifié (dans la clause
catch) et d'exécuter alors du code spécifique.
 un seul bloc catch peut être exécuté : le premier suceptible "d'attraper"
l'exception.
 chaque clause catch doit être déclarée avec un argument de type
Throwable ou une sous-classe de Throwable
 quand une exception est levée dans le bloc try, la première clause catch
dont le type de l'argument correspond à celui de l'exception levée est
invoquée
 clause catch dont l'argument est de même classe que l'exception levée,
 clause catch dont l'argument est une super-classe de la classe de

l'exception levée.
 l'ordre des blocs catch est donc très important.

Exemple : d’après "Programmation Java", J.F. Macary, N. Cédric, Ed. Eyrolles 1996
...
Exception de type :Except1 try {
Exception ou Except2 ou Except3
// séquence de code pouvant lever
//des exceptions de type Except1,
// Except2 ou Except3
...
}
Except1 catch (Except1 e1)
quel bloc catch {
va la traiter ? // e1 est l'exception qui a été levée
// dans le bloc try
? System.out.println(e1.getMessage());
e1.printStackTrace();
Except2 // ...
}
catch (Except2 e2)
{
// ...
}
{
// ...
}

...
Exception de type : try {
Exception Except1
...
}
GrandMère
Except1 type Except2 ? catch (Except2 e2)
{
// e2 est l'exception qui a été levée
// dans le bloc try
System.out.println(e2.getMessage());
Except2 // ...
}
type Except1 ? catch (Except1 e1)
{
// ...
}
{
// ...
}

...
Exception de type : try {
Exception Except3
...
}
Except1 type Except3 ? catch (Except2 e2)
{
// e2 est l'exception qui a été levée
Une Except3 // dans le bloc try
est une Except2 System.out.println(e2.getMessage());
Except2 // ...
}
le bloc Except3 catch (Except1 e1)
ne peut jamais {
être atteint // ...
}
PetiteFille
Except3 d’ailleurs le catch (Except3 e3)
compilateur le signale {
// ...
}
c:>\Philippe\Java\Tests\>javac TestException.java
TestException.java:24: cath not reached
catch (Except3 e3) {
^
1 error

...
try {
Exception
L ’ordre des blocs //des exceptions de type Except1,
catch doit respecter // Except2 ou Except3
...
l’ordre inverse de }
Except1 l'ordre d’héritage catch (Except2
catch (Except3 m)
e3)
entre les classes {{
d’exception // ...
m est l'exception qui a été levée
} // dans le bloc try
System.out.println(m.getMessage());
catch (Except2 e2)
{ m.printStackTrace();
Except2 // ...est l'exception qui a été levée
//e2
} // dans le bloc try
le bloc Except3 catch (Except1 gm)
System.out.println(e2.getMessage());
ne peut jamais { e2.printStackTrace();
être atteint ////...
...
}}
Except3 catch (Except3 pf)
catch (Except1 e1)
{
{
// ...
// ...
}
c:>\Philippe\Java\Tests\>javac TestException.java }
TestException.java:24: cath not reached
catch (PetiteFille pf) {
^
1 error

 pas nécessaire d'avoir clause catch pour chaque type possible d'exception
pouvant être levée.
 si aucun bloc catch ne permet d'attraper l'exception, celle-ci est propagée
vers la méthode appelante qui a alors la charge de la traiter ou non
 si une exception n'est attrapée par aucune des méthodes présentes dans la pile des appels
alors un message d'erreur ainsi que la trace de la pile d'appels sont affichés et l'exécution du
programme est interrompue.
Exception
...
try { Except4

les
Except1 Except4
// des exceptions de exceptions
Except1 // type Except1 , Except2, de type
Except2 // Except3 ou Except4 Except4
... seront
Except3
Except2 } reportées au
Le bloc catch catch
catch (Except1
(Except1 e1)
e1)
{{
niveau de la
traitera toutes les
////... méthode
exceptions de type ...
}} appelante
Except1, Except2
Except3
ou Except3

finalisation
 les clauses catch sont suivies de manière optionnelle par un bloc finally
qui contient du code qui sera exécuté quelle que soit la manière dont le bloc
try a été quitté
 le bloc finally permet de spécifier du code dont l'exécution est garantie

quoi qu'il arrive :
 le bloc try s'exécute normalement sans qu'aucune exception ne soit levée
 la fin du bloc try a été atteinte,
 contrôle quitte le bloc try suite à une instruction return, continue, break
(d'ou parfois l'utilisation d'un bloc try avec un bloc finally sans clauses
catch).
 le bloc try lève une exception attrapée par l'un des blocs catch.
 le bloc try lève une exception qui n'est attrapée par aucun des blocs
catch qui le suivent.

finalisation
 interêt double :
 permet de rassembler dans un seul bloc un ensemble d'instructions qui
autrement auraient du être dupliquées
 permet d'effectuer des traitements après le bloc try, même si une exception
a été levée et non attrapée par les blocs catch
... ...
try { try {
// ouvrir un fichier // ouvrir un fichier
// effectuer des traitements // effectuer des traitements
// susceptibles //susceptibles
// de lever une exception // de lever une exception
// fermer le fichier }
} catch (CertaineException e)
catch (CertaineException e) {
{ // traiter l'exception
// traiter l'exception }
// fermer le fichier catch (AutreTypeException e)
} {
catch (AutreTypeException e) // traiter l'exception Le bloc finally est
{ } toujours exécuté
// traiter l'exception finally {
// fermer le fichier //fermer le fichier
} }

Exceptions Lancement
 l'instruction throw unObjetException permet de lancer une exception

 unObjetException doit être une référence vers une instance d'une
sous-classe de Throwable
 quand une exception est lancée,
1. l'exécution normale du programme est interrompue,
2. la JVM recherche la clause catch la plus proche permettant de traiter
l'exception lancée,
3. cette recherche se propage au travers des blocs englobants et remonte
les appels de méthodes jusqu'à ce qu'un gestionnaire de l'exception soit
trouvé,
4.tous les blocs finally rencontrés au cours de cette propagation sont
exécutés.

Exceptions Lancement
 Exemple : violation d’une précondition
class OperationBancaireException extends Exception 2. Définition d’une
{ nouvelle classe
/** d ’exception
* compte pour lequel l’opération a échouée
*/
private Compte c; 4. L ’exception doit
être signalée dans la
public OperationBancaireException(Compte c,String s) signature de la méthode
{
super(s);
public class Compte {
this.c = c;
protected double solde = 0; 1. L’opération ne
} peut être effectuée
...
}
que si le dépôt est
/** >= 0
* Dépôt d’argent sur le compte
* @param s la somme à déposer, s doit être >= 0
* @throws OperationBancaireException si s <=0
*/
throws OperationBancaireException {
public void créditer(double s) {
3. Si la précondition
n ’est pas vérifiée if (s < 0)
création et lancement throw new OperationBancaireException(this,
"dépôt incorrect");
d ’une exception
solde += s;
}
...
}

Exceptions Déclaration
 Toute méthode susceptible de lever une exception "normale" doit

 soit l'attraper,
 soit la déclarer explicitement, c'est à dire comporter dans sa

signature l'indication que l'exception peut être provoquée : clause
throws
 Les exceptions déclarées dans la clause throws d ’une méthode sont :

 les exception levées dans la méthode et non attrapées par celle-ci,
 les exceptions levées dans des méthodes appelées par la méthode et
non attrapées par celle-ci.

public class TestExcep {

class MonException extends Exception
{ public void method1() throws MonException
public MonException() {
{ throw (new MonException());
super(); }
}
public MonException(String s) public void method2()
{ {
super(s); method1();
} }
}
}
si on oublie une de traiter une exception le compilateur le signale :-)
BASH.EXE-2.02$ javac TestExcep.java Les exceptions

TestExcep.java:24: Exception MonException must be caught, contrôlées
or it must be declared in the throws clause of this method. doivent être soit
method1(); attrapées soit
^ relancées !
1 error
BASH.EXE-2.02$

public class TestExcep {

BASH.EXE-2.02$ javac TestExcep.java
TestExcep.java:24: Exception MonException must be caught, public void method1() throws MonException
or it must be declared in the throws clause of this method. {
method1();
throw (new MonException());
^
1 error }
BASH.EXE-2.02$
public void method2()
{
method1();
Pour avoir une compilation correcte il }
faut modifier méthode 2
}
soit en en déclarant explicitement que soit en "attrapant" l'exception

method2 est susceptible de lancer une
public void method2()
exception de type MonException {
try {
public void method2() throws MonException method1();
{ }
method1(); catch (MonException e)
} {
e.printStackTrace();
}
}

 plusieurs classes d ’exceptions peuvent être indiquées dans la clause throws

d’une déclaration de méthode
void methodeQuelconque() throws Except1,Except4 {

Exception try {
// séquence de code pouvant

// lever des exceptions
// de type Except1, Except2,
Except1 Except4 // Except3 ou Except4 Les exceptions de type
... Except1 et Except4 ne sont
} pas traitées dans le corps de
catch (Except2 m) la méthode, elles doivent
{ être déclarées dans la
Except2 // intercepte les exceptions clause throws
// de type Except2 et Except3
...
}
finally
Except3 {
// ...
}
}

 la classe utilisée pour les exceptions dans la clause throws peut être une
superclasse de la classe de l'exception effectivement lancée
Exception
void methodeQuelconque()
throws Except1, Except4
Except2, Except3, Except4 {
Except1 Except4
// séquence de code pouvant
// de type Except1,
Except2 // Except2, Except3 ou Except4
...
Les exceptions de type Except1 ,
Except2, Except3 et Except4 ne
} sont pas traitées dans le corps de
Except3 la méthode, elles doivent être
déclarées dans la clause throws

Exceptions Redéfinition de méthodes
public Class A {
void methodeX() throws Except1, Except4 {

Exception // séquence de code pouvant
// de type Except1,
Except1 Except4 Except5 // ou Except4
...
}
Except2
...
}
Except3
Lorsque l'on redéfinit la

public Class B extends A {
méthode peut-on lancer de
void methodeX() throws Except1, Except4 , Except5 {
nouveaux types d'exception ? super.methodeX();
...
NON !
// séquence de code pouvant lever une
// exception de type Except5
...
}
...
 La méthode redéfinie doit }
respecter le contrat défini

par la méthode originale.
Elle ne peut rajouter de
nouveaux types d'exception

Exceptions Redéfinition de méthodes
public Class A {
void methodeX() throws Except1, Except4 {

Exception // séquence de code pouvant
// de type Except1,
Except1 Except4 Except5 // ou Except4
...
}
Except2
...
}
Except3
La clause throws eut être "spécialisée"
Mais alors, la méthode redéfinie (typage covariant de la clause throws)
public Class B extends A {
doit-elle avoir nécessairement la
void methodeX() throws Except3
Except1, Except4 {
même clause throws ? ...
...
Pas // séquence de code pouvant lever une

// exception de type Except3 ou Except4
nécessairement ! ...
} public Class C extends A {

...
 La méthode redéfinie peut lancer} void methodeX() {
des exceptions spécialisant les // séquence de code ne levant
exceptions définies dans la // pas d'exception
...
clause throws de la méthode }
originale ...
}

 l'obligation de déclaration des exceptions présente un double intérêt

("Programmation Java", J.F. Macary, N. Cédric, Ed. Eyrolles 1996)
 celui qui écrit une méthode doit être conscient de toutes les exceptions
levées par les méthodes qu'il appelle. Pour ces exceptions il doit choisir
entre les traiter ou les déclarer. Il ne peut les ignorer.
 celui qui utilise la méthode apprend grâce aux clauses throws quelles
sont les exceptions susceptibles d'être levées par cette méthode et les
méthodes appelées.
 pour simplifier écriture des programmes (et permettre une extensibilité future)
les exceptions "standards" non pas besoin d'être déclarées
 exceptions définies comme sous classes de Error
 exceptions définies comme sous classes de RuntimeException

(exemple ArrayOutOfBoundException, NullPointerException...)

possède deux sous-classes Throwable

standards
récupérables
Error Exception
LinkageError RunTimeException IOException
non récupérables
erreurs "systèmes"(plus de
mémoire, problèmes
chargement dynamique...)
NonControlées (unchecked) Controlées (checked)

Pas d’obligation de déclaration Obligation de déclaration

Exceptions N’ignorez pas les exceptions
try{
...
} catch (SomeException e) {
}
Code très, très suspect…
Bloc catch vide, détruit la finalité des exceptions qui est de vous obliger à traiter les
conditions exceptionnelles qu’elles sont supposer représenter.
catch (SomeException e) { catch (SomeException e) {

System.out.println(…); // commentaire
e.printStackTrace(); // justifiant le fait de
System.exit(0); // ne rien faire
} }

Exceptions Intérêt
Séparation du code de gestion des
erreurs du code « normal »
 Exemple : écriture d’une méthode qui ouvre et charge en mémoire un fichier

d'après "The Java Tutorial" de Mary Campione et Kathy Walrath, ed. Adisson-Wesley
void readFile() {
open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
}
MAIS que se passe t'il si

• le fichier ne peut être ouvert ?
• si sa taille ne peut être déterminée ?
• si il n'y a pas assez de mémoire disponible ?
• si il se produit une erreur de lecture ?
• si le fichier ne peut être fermé ?

errorCodeType readFile { erreurs du code « normal »
initialize errorCode = 0;
open the file;
if (theFileIsOpen) {  ajouter dans le code de la méthode des
determine the length of the file;
if (gotTheFileLength) { instructions pour détecter, rapporter et
allocate that much memory; gérer les erreurs, utilisation de code
if (gotEnoughMemory) {
read the file into memory; d ’erreur en retour des fonctions
if (readFailed) {
errorCode = -1;
}  augmentation conséquente de la taille
} else {
errorCode = -2;
du code (de 7 lignes de codes on passe à 29 lignes,
} augmentation de plus de 400% !!)
} else {
errorCode = -3;  grande perte de lisibilité (le code devient un
} plat de spaghetti)
close the file;
if (theFileDidntClose && errorCode == 0) {  que faire pour les fonctions qui doivent
errorCode = -4;
} else { renvoyer un résultat ?
errorCode = errorCode and -4;
}
} else {
errorCode = -5;
 gestion des erreurs souvent
} négligée par les programmeurs
return errorCode;
}
erreurs du code « normal »
readFile {
try {
open the file;  Avantages du mécanisme
determine its size;
d ’exceptions
allocate that much memory;
read the file into memory;  concision
close the file;
 lisibilité
} catch (fileOpenFailed) {
doSomething;
} catch (sizeDeterminationFailed) {
doSomething;
} catch (memoryAllocationFailed) {
doSomething;
} catch (readFailed) {
doSomething;
} catch (fileCloseFailed) {
doSomething;
}
}

Exceptions Interêt
 pouvoir propager les erreurs en remontant la pile des appels de méthodes
 possibilité de mettre en oeuvre une procédure de traitement de l'erreur à
un niveau plus élevé que à l'endroit où elle s'est produite
Approche « classique » method1 { Avec les exceptions
call method2;
method1 { } method1 {
errorCodeType error; method2 { try {
error = call method2; call method3; call method2;
if (error) } } catch (exception) {
doErrorProcessing; method3 { doErrorProcessing;
else call readFile; }
proceed; } }
} method2 throws exception {
errorCodeType method2 { seule method1 intéressée par call method3;
errorCodeType error; }
les erreurs pouvant intervenir
error = call method3; method3 throws exception {
if (error)
dans readFile
call readFile;
return error; }
else
propagation automatique dans
proceed;
} la pile des appels, seules les
errorCodeType method3 { méthodes qui se soucient
errorCodeType error; des erreurs ont à les détecter
error = call readFile;
if (error) on est contraint de forcer
return error; method2 et method3 à
else
proceed; propager les codes d'erreur
} retournés par readFile

Exceptions nouveautés Java7
 Java 7 ajoute quelques nouveautés au langage Java pour faciliter la gestion des exceptions
 récupération de plusieurs types d'exception dans un même bloc catch

 évite d'avoir à répéter des blocs catchs identiques pour des
exceptions de types différents
 instruction "try-with-resources"
 évite d'avoir un bloc finally pour la fermeture des ressources
 gestion des types plus fine lors du "relancement" des exceptions

Exceptions
Catching Multiple Exception Types
a single catch block can handle more than one type of exception.
 reduce code duplication and lessen the temptation to catch an overly
broad exception.
catch (IOException ex) {

logger.log(ex);
throw ex;
Code duplication
}
catch (SQLException ex) {
logger.log(ex);
throw ex; catch (IOException|SQLException ex) {
} logger.log(ex);
throw ex;
}
Bytecode generated will be smaller (and thus superior) than compiling many catch blocks that
handle only one exception type each. A catch block that handles multiple exception types
creates no duplication in the bytecode generated by the compiler.

Exceptions The try-with-resources Statement
a try statement that declares one or more resources, i.e. an object that
must be closed after the program is finished with it.
 ensures that each resource is closed at the end of the statement.
static void copy(String src, String dest) throws IOException {

InputStream in = new FileInputStream(src);
try { Resources must implement the new
OutputStream out = new FileOutputStream(dest); java.lang.AutoCloseable interface.
try {
byte[] buf = new byte[8 * 1024]; InputStream, OutputStream, Reader, Writer
int n; (java.io), Connection, Statement, and
while ((n = in.read(buf)) >= 0) ResultSet (java.sql) have been retrofitted to
out.write(buf, 0, n); implement it
} finally {
out.close();
} static void copy(String src, String dest) throws IOException {
} finally { try (InputStream in = new FileInputStream(src);
in.close();
}
OutputStream out = new FileOutputStream(dest)) {
} byte[] buf = new byte[8192];
int n;
close methods of resources are
while ((n = in.read(buf)) >= 0) called in the opposite order of
out.write(buf, 0, n); their creation.
}
}

Exceptions
The try-with-resources Statement
public static void viewTable(Connection con) throws SQLException {
String query =
"select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";
try (Statement stmt = con.createStatement()) {
ResultSet rs = stmt.executeQuery(query);
while (rs.next()) {
String coffeeName = rs.getString("COF_NAME");
int supplierID = rs.getInt("SUP_ID");
float price = rs.getFloat("PRICE");
int sales = rs.getInt("SALES");
int total = rs.getInt("TOTAL");
System.out.println(coffeeName + ", " + supplierID + ", " + price +
", " + sales + ", " + total);
}
} catch (SQLException e) {
JDBCTutorialUtilities.printSQLException(e); A try-with-resources statement can have
} catch and finally blocks just like an
} ordinary try statement.
In a try-with-resources statement, any

catch or finally block is run after the
resources declared have been closed..

Exceptions Rethrowing Exceptions with
More Inclusive Type Checking
 Java
SE 7 compiler performs more precise analysis of rethrown
exceptions than earlier releases of Java SE.
 enables you to specify more specific exception types in the throws clause of a
method declaration.
class FirstException extends Exception { }

class SecondException extends Exception { }
...
public void rethrowException(String exceptionName) throws Exception {
try {
if (exceptionName.equals("First")) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (Exception e) {
throw e;
public void rethrowException(String exceptionName)
} throws FirstException, SecondException {
} try {
// ... Even though the exception parameter of
the catch clause, e, is type Exception, the
} compiler can determine that it is an
catch (Exception e) { instance of either FirstException or
throw e; SecondException
}
}
Exceptions En résumé
 lesexceptions rendent la gestion des erreurs plus simple et plus

lisible
 le code pour gérer les erreurs peut être regroupé en un seul endroit :
là où ont a besoin de traiter l'erreur
 possibilité
de se concentrer sur l'algorithme plutôt que de s'inquiéter
à chaque instruction de ce qui peut mal fonctionner,
 les
erreurs remontent la hiérarchie d'appels grâce à l'exécutif du
langage et non plus grâce à la bonne volonté des programmeurs.
Exceptions in Java : Bill Venners

javaworld juillet 1998
http://www.javawolrd.com/javaworld/jw-07-1998/jw-07-exceptions.html

Exceptions

Transféré par

Droits d'auteur :

Formats disponibles

Exceptions

Transféré par

Informations du document

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

Exceptions

Transféré par

Droits d'auteur :

Formats disponibles

Exceptions

© Philippe GENOUD UGA Janvier 2017 1

© Philippe GENOUD UGA Janvier 2017 2

© Philippe GENOUD UGA Janvier 2017 3

 Mais alors qu’est-ce qu’une exception ?

 Un exception est un signal

 lancer (throw) une exception consiste à signaler ce quelque chose,

© Philippe GENOUD UGA Janvier 2017 4

 lorsqu'une situation exceptionnelle est rencontrée, une exception est lancée

 propagation jusqu'à la méthode main() à partir de laquelle l'exécution du

© Philippe GENOUD UGA Janvier 2017 5

LinkageError RunTimeException IOException MyException1

pour définir de nouveaux

© Philippe GENOUD UGA Janvier 2017 7

 Puisqu'elles sont des objets les exceptions peuvent contenir :

© Philippe GENOUD UGA Janvier 2017 8

 La représentation des exceptions sous forme d'objets permet de mieux

"Because all exceptions that are thrown within a Java program

[The Java Tutorial, Campione &Walrath 97]

© Philippe GENOUD UGA Janvier 2017 9

#define EOF_ERROR 1 Exception

Niveau d'abstraction qui permet de désigner

Les exceptions étant des objets, leur structuration en une

© Philippe GENOUD UGA Janvier 2017 10

CompteException public int noCompte() {

CompteNotFoundException CompteOpException class CompteOpException extends CompteException {

© Philippe GENOUD UGA Janvier 2017 11

 try{ … } délimite un ensemble d'instructions susceptibles de déclencher

 clause catch dont l'argument est une super-classe de la classe de

 l'ordre des blocs catch est donc très important.

© Philippe GENOUD UGA Janvier 2017 13

© Philippe GENOUD UGA Janvier 2017 14

© Philippe GENOUD UGA Janvier 2017 15

© Philippe GENOUD UGA Janvier 2017 16

© Philippe GENOUD UGA Janvier 2017 17

// séquence de code pouvant lever

© Philippe GENOUD UGA Janvier 2017 18

 le bloc finally permet de spécifier du code dont l'exécution est garantie

 la fin du bloc try a été atteinte,

© Philippe GENOUD UGA Janvier 2017 19

© Philippe GENOUD UGA Janvier 2017 20

 l'instruction throw unObjetException permet de lancer une exception

© Philippe GENOUD UGA Janvier 2017 21

© Philippe GENOUD UGA Janvier 2017 22

 Toute méthode susceptible de lever une exception "normale" doit

 soit la déclarer explicitement, c'est à dire comporter dans sa

 Les exceptions déclarées dans la clause throws d ’une méthode sont :

© Philippe GENOUD UGA Janvier 2017 23

public class TestExcep {

si on oublie une de traiter une exception le compilateur le signale :-)

BASH.EXE-2.02$ javac TestExcep.java Les exceptions

© Philippe GENOUD UGA Janvier 2017 24

public class TestExcep {

soit en en déclarant explicitement que soit en "attrapant" l'exception

© Philippe GENOUD UGA Janvier 2017 25

 plusieurs classes d ’exceptions peuvent être indiquées dans la clause throws

void methodeQuelconque() throws Except1,Except4 {

// séquence de code pouvant

© Philippe GENOUD UGA Janvier 2017 26

© Philippe GENOUD UGA Janvier 2017 27