Cours: Programmation Java

Filière: 2 ème LSI

Enseignante: Dr. Majdoub Manel

2023-2024 Programmation JAVA 2eme SI 1

 Plan du cours

Chapitre 1 Introduction
Chapitre 2 Objets et Classes
Chapitre 3 Encapsulation et Surcharge
Chapitre 4 Héritage et Polymorphisme
Chapitre 5 Classes abstraites et Interfaces
Cha6
Chapitre Les collections
pitre
57
Chapitre Les exceptions

18/09/2023 POO 2eme SI 2

Chapitre VII: Les exceptions
Plan

• Les exceptions
• Les exceptions prédéfinies
• Les exceptions définies par l’utilisateur

18/09/2023 POO 2eme SI 4

Les exceptions

• Une 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.

18/09/2023 POO 2eme SI 5

 Exemples

public class TSTExcp1 {

Exemple1
public static void main (String[] args) {
int tabEnt[]={1,2,3,4};
tabEnt[4]=3; //erreur et arret
System.out.print("fin de main "); }}

java TSTExcp1 Exception in thread "main"

java.lang.ArrayIndexOutOfBoundsException: 4 at TSTExcp1.main(TSTExcp1.java:5)

public class TSTExcp2 { Exemple2

public static void main (String[] args)
{
int tabEnt[]={1,2,3,4};
try {tabEnt[4]=3;} java TSTExcp2
catch(Exception e){ Exceptionjava.lang.ArrayIndexOutOfBoundsException
System.out.println("Exception"+e);} :4
System.out.print("fin de main "); }} fin de main
18/09/2023 POO 2eme SI 6
Les exceptions

• Lorsqu’une erreur se produit dans une méthode, celle-ci crée un

objet Exception qui contient des informations sur l’erreur survenue :
– le type de l’erreur : objet null, dépassement de tableau, etc.
– la trace d’exécution du programme : la stack trace
• L’action de créer un objet Exception et de le passer au système
d’exécution est appelée lever/lancer une exception.

18/09/2023 POO 2eme SI 7

Les exceptions

• Les exceptions sont des objets comme les autres en Java (leur
gestion mise à part)
• Il est donc possible de créer ses propres exceptions et de les lancer
(throw) lors de l’exécution d’un programme.
• Une exception est un objet qui hérite de la classe
java.lang.Throwable
• Il existe deux sous-classes prédéfinies dans le JDK : java.lang.Error et
java.lang.Exception
• Les exceptions "classiques" sont des sous-classes de
java.lang.Exception

18/09/2023 POO 2eme SI 8

Types d’exceptions

IO Exception

18/09/2023 POO 2eme SI 9

Types d’exceptions

• Il existe de nombreuses classes d’exceptions prédéfinies en Java, que l’on

peut classer en trois catégories :
• Celles définies en étendant la classe Error : elles 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.
• Celles définies en étendant la classe Exception : elles 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.
• Celles définies en étendant la classe RuntimeException : elles
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.
18/09/2023 POO 2eme SI 10
Quelques exceptions prédéfinies

• 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.
• ArrayIndexOutOfBoundsException représente une tentative
d'accès à un élément de tableau 'hors limite', c'est à dire
d'indice inférieur à 0 ou supérieur ou égal à la dimension du
tableau.
• NumberFormatException : erreur lors de la conversion d’un
chaîne de caractères en nombre.
• ArithmeticException est générée lorsqu'un calcul provoque une
erreur. Par exemple, lors de la division par zéro d'un nombre
entier.

18/09/2023 POO 2eme SI 11

Traiter les exceptions levées

try {
//bloc de programme susceptible de provoquer une exception
}
catch (TypeException e)
{
//bloc de traitement de l'exception
}
finally {
/*Le block finally est un block optionnel contenant des
instructions qui seront toujours exécutées quelque soit le On
peut, par exemple, fermer un fichier contenant des instructions
qui seront toujours exécutées quelque soit le résultat du try */
}

18/09/2023 POO 2eme SI 12

Traiter les exceptions levées

• Le bloc try est exécuté jusqu'à ce qu'il se termine avec succès

ou bien qu'une exception soit levée.
• Les clauses catch sont examinées l'une après l'autre dans le but
d'en trouver une qui traite cette classe d'exceptions.
• Les clauses catch doivent donc traiter les exceptions de la plus
spécifique à la plus générale.
• Si une clause catch convenant à cette exception a été trouvée et
le bloc exécuté, l'exécution du programme reprend son cours.

18/09/2023 POO 2eme SI 13

Exemple

public class testException{

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(“Exception mathématique“);
}
catch (Exception e){
System.out.println(“Exception inconnue“);
}}}

18/09/2023 POO 2eme SI 14

La classe Throwable

• c'est la classe de base pour le traitement des erreurs

• Les méthodes de la classe Throwable:
– String getMessage(): lecture du message
– void printStackTrace(): affiche l’exception

18/09/2023 POO 2eme SI 15

Exemple

class testException{
public static void main (String[] args){
int i = 3 ; int j = 0 ;
try {
System.out.println ("résultat = " + (i/j)); getmessage
} / by zero
catch (ArithmeticException e){ e.toString()
System.out.println ("getmessage "); java.lang.ArithmeticException: / by zero
System.out.println (e.getMessage());
System.out.println (" e.toString()"); printStackTrace
System.out.println (e.toString()); java.lang.ArithmeticException: / by zero
System.out.println (" "); at
testexception.Testexception.main(Testexc
System.out.println ("printStackTrace");
eption.java:8)
e.printStackTrace() ; )
}
}}
18/09/2023 POO 2eme SI 16
Propagation des exceptions

• Quand une exception est levée (implicitement ou explicitement

par throw) dans un bloc try alors :
– Les instructions qui suivent l’exception levée dans try sont
ignorées
– Les instructions du catch approprié (selon le type
d’exception) sont exécutées
– Le programme reprend normalement avec l’instruction qui
suit le bloc

18/09/2023 POO 2eme SI 17

 Les exceptions définies par l’utilisateur

• Java offre au programmeur la possibilité de définir ses propres

exceptions.
• Ces exceptions doivent hériter d’une autre exception de la
hiérarchie des classes Java.
• Le programmeur doit lui-même lever ses exceptions.
• Le programmeur peut lever ses propres exceptions à l'aide du
mot réservé throw.
• throw prend en paramètre un objet instance de Throwable ou
d'une de ses sous-classes.
• Le mot-clé throw fait partie des mots-clés réservés du langage
Java, et il permet de forcer la génération d'une exception,
représentée par l'objet qu'on lui passe en paramètre.

18/09/2023 POO 2eme SI 18

Exemple 1

public class Personne { public class NegativeAgeException extends

private int age ; Exception { }
/ / doit être>= 0
public Personne ( int age ) { public class Personne {
this.age = age ; } private int age ;
public void setAge ( int age ) { public void setAge ( int age ) throws
this .age = age ; } NegativeAgeException {
} if ( age < 0 ) { throw (new NegativeAgeException ( ) ) ;
/ / sort de la methode }
this . age = age ; / / execute seulement si age >= 0 }

public class TestPersonne {

public static void main ( S t r i n g [ ] args ) {
Personne pers = new Personne ( 1 0 ) ;
t r y { pers . setAge ( −1 ); }
catch ( NegativeAgeException e )
{ e.printStackTrace ( ) ; }
18/09/2023
} } POO 2eme SI 19
Exemple 1

public class NegativeAgeException extends

Exception { }

public class Personne {

private int age ;
public void setAge ( int age ) throws
NegativeAgeException {
if ( age < 0 ) { throw (new NegativeAgeException ( ) ) ;
/ / sort de la methode }
this.age = age ; / / execute seulement si age >= 0 }

public class TestPersonne { Exécution

public static void main ( S t r i n g [ ] args ) { prog . NegativeAgeException
Personne pers = new Personne ( 1 0 ) ; at prog . Personne . setAge ( Personne .
t r y { pers . setAge ( −1 ); } java : 1 3 )
catch ( NegativeAgeException e ) at prog . TestPersonne . main (
{ e.printStackTrace ( ) ; } } } TestPersonne . j a v a : 8 )

18/09/2023 POO 2eme SI 20

Exemple2: Personnalisation du message d’erreur

public class NegativeAgeException extends Exception {

public NegativeAgeException ( String message )
{ super ( message ) ; } }
.....
public void setAge ( int age ) throws NegativeAgeException {
if ( age < 0 ) {
throw new NegativeAgeException ( " erreur : l’age doit etre > 0 ‘’) ; }
this . age = age ; }
......

public class TestPersonne {

Exécution
public static void main ( String [ ] args ) {
prog . NegativeAgeException : erreur : l ’age
Personne pers = new Personne ( 1 0 ) ;
doit etre > 0 , valeur entree : −1
t r y { pers.setAge ( −1 ); }
at prog . Personne . setAge ( Personne . java :
catch ( NegativeAgeException e )
1 3 ) at prog . TestPersonne . main (
{ e.printStackTrace ( ) ; } } }
TestPersonne . j a v a : 8 )

18/09/2023 POO 2eme SI 21

 Exercice

• Écrire une méthode (extraire) qui donne la sous-chaîne de

caractères se trouvant entre deux indices donnés d’une chaîne
de caractères donnée. Les caractères correspondant aux indices
seront inclus dans la sous-chaîne résultat.
• Définir une classe ChaineException pour représenter les
exceptions possibles.

18/09/2023 POO 2eme SI 22