PROGRAMMATION JAVA

AU : 2021 - 2022
Auditoire : 2ème Année Licence Multimédia

DR. Jihen KHALFALLAH

jihen_khalfallah@yahoo.fr
 Plan
• Introduction
• Arbre des exceptions
• Exception contrôlée et non contrôlée
• Traitement d’une exception
• Lancement d’une exception
• Le mot-clé throws, throw
• Les exceptions personnalisées
• Exceptions prédéfinies en JAVA
• Le bloc finally
• Propagation des exceptions
• La classe Throwable.
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 2
 PLAN DU COURS
• Chapitre 1 : Introduction à la POO
• Chapitre 2 : Syntaxe du langage Java
• Chapitre 3 : Concept de classe et objet
• Chapitre 4 : Héritage
• Chapitre 5 : Les classes de base
• Chapitre 6 : La gestion des exceptions
• Chapitre 7 : Les flux d’entrée/sortie
• Chapitre 8 : Les collections
3
 PROGRAMMATION JAVA

Chapitre 6: La gestion des exceptions

Auditoire : 2ème Année Licence Multimédia

DR. Jihen KHALFALLAH

jihen_khalfallah@yahoo.fr
 Introduction (1)
 La robustesse d’un logiciel est sa capacité à fonctionner même en
présence d’erreurs.
 Mais même lorsqu’un programme est au point, son exécution peut
être interrompue brutalement à cause d’évènements exceptionnels
(types de données incorrects, fin prématurée de tableaux ou de
fichiers..etc).
Ces évènements sont appelés Exceptions.
Une exception est un évènement qui arrive durant l’exécution du programme et
qui perturbe le déroulement normal de celui-ci

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 5

 Introduction (2)
 Le concepteur d’un programme doit essayer dans un premier
temps de prévoir les erreurs possibles soit:
 En ajoutant des séquences de tests pour les empêcher,
 En mettant en place un système pour signaler un fonctionnement anormal
du programme en retournant des valeurs spécifiques
 Mais aucune de ces solutions n’est satisfaisante car
 il est très difficile de dénombrer toutes les erreurs possibles sans en
omettre aucune,
 l’écriture du code devient fastidieuse et complexe et sa maintenance
difficile à cause de son illisibilité(trop d’imbrications de tests)

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 6

 Arbre d’héritage des exceptions
 Error : classe prédéfinie en Java pour traiter les exceptions

Throwable

Error Exception

Runtime Exceptions
Exception contrôlées

Exceptions standard Exceptions personnalisées

(prédéfinies dans Java) (définies par le programmeur )

7
 Exceptions
 En Java, une erreur ne provoque pas l’arrêt brutal du programme mais la
création d’un objet d’une classe spécifiquement créée pour être associée à
des exceptions
 Java dispose d’un mécanisme très souple nommé gestion d’exceptions qui
permet de détecter et traiter les erreurs pouvant surgir lors de l’exécution
d’un programme.
 Ce mécanisme est utilisé pour traiter le fonctionnement anormal d’une
partie du code.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 8

 Exemple d’exception
public class TestException2 {

public static void main(String[] args) {

// Insert code to start the application here.
int i = Integer.parseInt (args [0]);
int j = Integer.parseInt (args [1]);
try {
System.out.println("résultat = " + (i / j));
}
}
Si l’utilisateur saisit un zéro comme deuxième valeur

Exception in thread "main" java.lang.ArithmeticException: / by zero at

TestException.main(TestException.java:6)

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 9

 Types d’exceptions
 Il existe deux types d’exceptions:
 Les exceptions contrôlées
 Les exceptions non contrôlées

 Un programme Java bien écrit qui contient une partie du code pouvant
générer (ou provoquer) une exception contrôlée doit essayer de la traiter
(ou récupérer) de l’une des deux manières suivantes
 En utilisant le bloc try\catch
 En utilisant le mot-clé throws

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 10

 Exceptions contrôlées
 Ce sont les exceptions qu’un programme bien écrit doit anticiper et
récupérer (dit aussi attraper, saisir ou traiter).

 Exemple : Une application invite l’utilisateur à entrer le nom d’un fichier.

L’utilisateur peut donner le nom d’un fichier qui n’existe pas. Dans ce cas une
exception du type java.io.FileNotFound sera lancée. Un programme
bien écrit devrait prévenir cette exception en signalant à l’utilisateur que le
fichier n’existe pas et en l’invitant à taper le nom d’un fichier existant.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 11

 Exceptions non contrôlées (1)

 Les exceptions non contrôlées sont celles qui ne peuvent être ni

anticipées ni récupérées . Elles sont de deux types:

1. Les exceptions de type Error

2. Les exceptions de type RuntimeException

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 12

 Exceptions non contrôlées (2)
1. Les exceptions de type Error
 Ce sont des évènements exceptionnels externes au programme et qui
ne peuvent pas être anticipées ou récupérées. Ils sont de type Error ou
ses sous-classes.

 Exemple: Supposons qu'une application puisse ouvrir un fichier

correctement mais ne puisse pas le lire à cause d’une erreur matérielle ou
du système d’exploitation.
L’incapacité de lire le fichier lancera une exception de type
java.io.IOError

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 13

 Exceptions non contrôlées (3)
2. Les exceptions de type RuntimeException
 Ce sont des évènements exceptionnels internes au programme et que le
programmeur ne peut ni anticiper ni récupérer.

 Exemple: Si dans une application, au lieu de passer le nom d’un fichier à

une méthode, on passe null, alors une exception du type
NullPointerException sera lancée

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 14

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 15
 Introduction (1)
• 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 produite, 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.

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 16

 Introduction (2)
 A tout moment, une instruction ou une méthode peut lever(lancer)
une exception
 Une méthode peut attraper (récupérer, saisir) une exception ou bien
la laisser se propager en la laissant remonter vers la méthode
appelante qui peut elle même l’attraper ou la laisser remonter

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 17

 Le bloc try-catch (1)
 La clause try s'applique à un bloc d'instructions correspondant au
fonctionnement normal mais pouvant générer des erreurs.

try {
……
}

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 18

 Le bloc try-catch (2)
 La clause catch s'applique à un bloc d'instructions définissant le traitement
d'un type d'erreur. Ce traitement sera lancé sur une instance de la classe
d'exception passée en paramètre.
Si une erreur se
try { produit ici…
…
}
catch (ExceptionType1 e1) {
Elle sera récupérée là.
…
}
catch(ExceptionType2 e2) {
…
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 19
 Le bloc try-catch (3)
Exemple :
public class TestException2 {

public static void main(String[] args) {

// Insert code to start the application here.
int i = Integer.parseInt (args [0]);
int j = Integer.parseInt (args [1]);

try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("Divion par zéro ");
}
}
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 20
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 21
 Arbre d’héritage des exceptions
Throwable

Error Exception

RunTime Exceptions
Exception contrôlées

Exceptions standard Exceptions personnalisées

(prédéfinies dans Java) (définies par le programmeur )

22
 Le mot-clé throws (1)
 Toute méthode pouvant lancer une exception contrôlée doit contenir
soit un bloc try/catch (si elle traite l’exception localement) ou bien
utiliser le mot-clé throws (si l’exception est traitée par une autre
méthode)
 Une exception contrôlée est une exception qui hérite de la classe
Exception et qui n’est pas une RuntimeException, elle peut être
standard (définie dans JDK) ou bien personnalisée.
 Nous avons vu comment utiliser le bloc try/catch, maintenant nous
allons voir l’utilisation de throws

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 23

 Le mot-clé throws (2)
Exemple :

public class TestThrows {

public static void main(String[] args)throws ArithmeticException
{
int i = Integer.parseInt (args [0]);
int j = Integer.parseInt (args [1]);
System.out.println("résultat = " + (i / j));
}
}

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 24

 Le mot-clé throw (1)
Le programmeur peut lancer lui-même des exceptions depuis les méthodes
qu’il écrit
 Il peut lancer des exceptions des classes d’exceptions fournies par le JDK
 Ou lancer des exceptions appartenant à de nouvelles classes d’exceptions,
qu’il a lui-même écrites, et qui sont mieux adaptées aux classes qu’il a
écrites
 Si on lance une exception dans une méthode avec throw, il faut
l'indiquer dans la déclaration de la méthode, en utilisant le mot-clé
throws.
 Syntaxe :
public void maMethode() throws IOException {
// ne traite pas l'exception IOException
// mais est susceptible de la générer
} 25
 Le mot-clé throw (2)
Exemple :
public class TestThrow throws ArithmeticExcpetion {
public static void main(String[] args){
int i = Integer.parseInt (args [0]);
int j = Integer.parseInt (args [1]);
if(j<0)throw new ArithmeticException();

System.out.println("résultat = " + (i / j));

}
}

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 26

 Les exceptions personnalisées (1)
 En cas de nécessité, on peut créer ses propres exceptions en créant
des sous classes de la classe Exception (par convention, le mot «
Exception » est inclus dans le nom de la nouvelle classe.
 il suffit ensuite d'utiliser le mot-clé throw, suivi d'un objet dont la
classe dérive de la classe créée.
 Syntaxe : throw new MonException("Exception
personnalisée !!!");

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 27

 Les exceptions personnalisées (2)
 Créer une classe héritant de la classe Exception:
class MonException extends Exception { }

 renvoyer l'exception levée à la classe appelante:

class Personneclass Personne {
public Personne(int num, int age) throws MonException
// méthode susceptible de déclencher l’erreur
{
if ( (num<0) || (age<0)) throw new MonException() ;
// lance une exception de type MonException
this.num = num ;
this.age = age ;
} }
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 28
 throw et throws
 Le mot-clé throw permet de soulever une exception

if (discr<0) throw new PasDeSolutionException();

……

 Le mot-clé throws s’utilise au niveau de la signature d’une

méthode pour préciser que celle-ci est susceptible de soulever
une exception

public double solution() throws PasDeSolutionException {

……

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 29

 Exercice :
 Supposons que l ’on souhaite manipuler des points ayant des coordonnées
non négatives. Nous utiliserons donc une classe Point ayant un constructeur à
deux arguments.
 Au sein de ce constructeur, on vérifiera la validité des coordonnées entrées par
l’utilisateur, si l’une d’entre elles est incorrecte, nous déclencherons une
exception à l’aide du mot-clé throw.
 L’instruction throw a besoin d’avoir un objet du type de l’exception
concernée
 Nous créerons donc une classe que nous appellerons
CoordonneesException qui dérive de Exception

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 30

 class Point
{
private int x;
private int y;

public Point(int x, int y) throws CoordonneesException

// méthode susceptible de déclencher l’erreur
{
if((x<0) || (y<0)) throw new
CoordonneesException();
this.x = x;
this.y = y;
}
} // lance une exception de type CoordonneesException

class CoordonneesException extends Exception {

// Créer une classe héritant de la classe Exception
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 31
 public class ExceptionPersonnalisée {

public static void main(String args[]){

int x = Integer.parseInt(args[0]);
int y = Integer.parseInt (args[1]);

try{
Point p = new Point (x,y);
}
catch(CoordonneesException e)
{
System.out.println(" coordonnée négative ");
}
}
}

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 32

 Exceptions prédéfinies en JAVA (1)
- Trois catégories :
1. Celles définies en étendant la classe Error :
• représentent des erreurs critiques qui ne sont pas censée être
gérées en temps normal
• Par exemple, une exception de type OutOfMemoryError est
lancée lorsqu’il n’y a plus de mémoire disponible dans le système
2. Celles définies en étendant la classe Exception :
• représentent les erreurs qui doivent normalement être gérées par le
programme
• Par exemple, une exception de type IOException est lancée en
cas d’erreur lors de la lecture d’un fichier

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 33

 Exceptions prédéfinies en JAVA (2)

3. Celles définies en étendant la classe RuntimeException

 représentent des erreurs pouvant éventuellement être gérée par le
programme
 L’exemple typique de ce genre d’exception est
NullPointerException, qui est lancée si l’on tente d’accéder au
contenu d’un tableau ou d’un objet qui vaut null

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 34

 Exceptions prédéfinies en JAVA (3)
- NullPointerException :
 accès à un champ ou appel de méthode non statique sur un objet valant
null
 utilisation de length ou accès à un case d’un tableau valant null
 référence nulle
- ClassCastException :
 tentative de forçage de type illégale
- NegativeArraySizeException:
 tentative de création d'un tableau de taille négative
- ArrayIndexOutOfBoundsException :
 dépassement de limite d'un tableau
- NumberFormatException :
 erreur lors de la conversion d’une chaîne de caractères en nombre
- ArithmeticException :
 division par zéro pour les entiers 35
 Le bloc finally (1)
 L'écriture d'un bloc finally permet au programmeur de définir un
ensemble d'instructions qui est toujours exécuté, que l'exception soit
levée ou non, capturée ou non.
 Le bloc finally s'exécute même si le bloc en cours d'exécution (try
ou catch selon les cas) contient un return, un break ou un continue.
Dans ce cas, le bloc finally est exécuté juste avant le branchement
effectué par l'une de ces instructions.
 La seule instruction qui peut faire qu'un bloc finally ne soit pas
exécuté est System.exit().
 Cependant, Java permet d’introduire, à la suite d’un bloc try, un bloc
particulier d’instructions qui seront toujours exécutées :
 Soit après la fin naturelle du bloc try, si aucune exception n’a été
déclenchée
 Soit suivi d'un ou plusieurs bloc catch
 Ce bloc est introduit par le mot-clé finally 36
 Le bloc finally (2)
 Un bloc finally est en général utilisé pour effectuer des nettoyages
(fermer des fichiers, une connexion, libérer des ressources...).
 Un bloc finally est facultatif

try {
// Ouvrir le fichier ❶ Erreur ici !
// Lire les données
// ……
}
catch (IOException i) {
System.out.println("Erreur I/O sur le fichier");
return;
}
finally { ❷ Retour aux instructions suivant la lecture
// Fermer le ficher
// Ce bloc sera systématiquement exécuté
// ……

❸ Bloc d’instructions toujours traité

Dr J. Khalfallah
} 2LM (ISITCom) – Programmation java 37
 Le bloc finally (3)
Exemple :
public class PropagationException{
public static void main(String[] args) {
try{
Object chaine="bonjour";
Integer i=(Integer)chaine;
// levée d'une ClassCastException
System.out.println("fin du programme");
}
finally{ System.out.println("on passe par le bloc
finally");
} Le catch n'est pas obligatoire (car ClassCastException
} est de type RuntimeException et donc c'est une exception non contrôlées).
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 38
 Propagation 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

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 39

 Exemple de propagation
public int ajouter(int a, String str)
throws NumberFormatException
int b = Integer.parseInt(str);
a = a + b;
return a;
}

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 40

 Exemple d'interception
public int ajouter(int a, String str) {
try {
int b = Integer.parseInt(str);
a = a + b;
}
catch (NumberFormatException e) {
System.out.println(e.getMessage());
}
return a;
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 41
 La classe Throwable (1)
 C’est la classe mères de toutes les exceptions et elle descend
directement de la classe Object.

 Ses principales méthodes sont :

 String getMessage( ) retourne le message
 void printStackTrace( ) affiche le message d’erreur et la pile des appels
de méthodes qui ont conduit au problème
 void printStackTrace(PrintStream s) Idem mais envoie le résultat dans un
flux

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 42

 Arbre d’héritage des exceptions
Throwable

Error Exception

RunTime Exceptions
Exception contrôlées

Exceptions standard Exceptions personnalisées

(prédéfinies dans Java) (définies par le programmeur )

43
 La classe Throwable (2)
 La classe Throwable définit un message de type String
qui est hérité par toutes les classes d'exception.
 Ce champ est utilisé pour stocker le message décrivant
l'exception.
 Il est positionné en passant un argument au constructeur.
 Ce message peut être récupéré par la méthode
getMessage().

Dr J. Khalfallah 2LM (ISITCom) – Programmation java 44

 La classe Throwable (3)
Exemple :
public class TestMethodesThrowable {
public static void main(String[] args) {
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("getmessage");
System.out.println(e.getMessage());
System.out.println(" ");
System.out.println("printStackTrace");
e.printStackTrace();
}
}
}
Dr J. Khalfallah 2LM (ISITCom) – Programmation java 45