Session Hiver 2023

Cours : Introduction à la programmation objets

Code : 420 –P25-AS
Les Exceptions
Exemple

public class TestException {

public static void main(java.lang.String[] args) {
int i = 3;
int j = 1;
try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("erreur division par zéro");
}
}
}

Une méthode qui désire gérer ce genre de problèmes peut indiquer qu’elle est disposée à
intercepter l’exception (instruction throws).

1. Les exceptions prédéfinies

- En Java, les exceptions sont de véritables objets.

- Ce sont des instances de classes qui héritent de la classe Throwable.
- Lorsqu’une exception est levée, une instance de la classe Throwable est créée. Voici un
aperçu de la hiérarchie des classes pour les exceptions.

Page 1/5
 Session Hiver 2023

Erreurs et Exceptions :

• Erreur: indications de problèmes irrécupérables dus au matériel ou au système d’exploitation

• Exception: erreurs résiduelles dans le programme qui peuvent être traitées par une sortie
propre ou une récupération (arithmétique, pointeurs, index, i/o, etc.)
- Les instances de la classe Error sont des erreurs internes à la machine virtuelle Java.
Elles sont rares et fatales.
- Les sous-classes de la classe Exception sont réparties en deux catégories :
- Les exceptions d’exécution (runtime) sont souvent l’effet du manque de robustesse
du code. Par exemple l’exception NullPointerException est levée lorsque l’on
manipule un objet non instancié (oubli de l’instruction new) ;
- Les autres exceptions correspondent à des événements anormaux échappant au
contrôle du programme. Par exemple, l’exception EOFException est levée si on
essaie de lire au-delà d’un fichier.

• Traiter les exceptions levées : les mots clés try, catch et finally :

• Intercepter une exception : le mot clé throws : Si une méthode est susceptible de lever
une exception et si elle ne peut pas la traiter, elle se doit de prévenir le système qu'elle
relaye cette tâche. Pour ce faire, on utilise le mot clé throws dans la définition de la
méthode. Ce mot clé permet d'avertir le système qu'une certaine catégorie d'exception
ne sera pas traitée en local (dans l'exemple suivant, l'ensemble des exceptions liées aux
entrées/sorties).

public void ma_methode (int x) throws IOEXception {

…
}
• Il est également possible de désigner l’interception de plusieurs exceptions :

public void ma_methode (int x) throws IOException, EOFException{

…}

Page 2/5
 Session Hiver 2023

2. 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. Pour se faire Java met à sa disposition le mot-clé throw (à ne
pas confondre avec throws). Pour le reste (try, catch, finally) le mécanisme est identique.

Exercices :

Exercice 1 :
Réaliser une classe EntNat permettant de manipuler des entiers naturels (positifs ou nuls).
Pour l’instant, cette classe disposera simplement :
• d’un constructeur à un argument de type int qui générera une exception de type
ErrConst (type classe à définir) lorsque la valeur reçue ne conviendra pas,
• d’une méthode getN fournissant sous forme d’un int, la valeur encapsulée dans un
objet de type EntNat.

Écrire un petit programme d’utilisation qui traite l’exception ErrConst en affichant un

message et en interrompant l’exécution.

Exercice 2 :

1. Définir la classe ExceptionNegative qui représente une exception. Cette classe comporte un seul
attribut de type entier nommé valeur et un constructeur avec un paramètre entier (permettant
d’initialiser l’attribut valeur).

Page 3/5
 Session Hiver 2023

2. Soit la classe Calcul suivante :

public class Calcul {

public int factoriel (int a){

int r=1;

for (int i=1;i<=a;i++)

r=r*i;

return r;
}

Rajouter le code permettant de lever une exception de type ExceptionNegative dans la

méthode factoriel si le paramètre passé en argument est négatif.

3. Modifier le code de la classe TestException afin de traiter l’exception et d’afficher la

valeur (négative) ayant conduit à sa levée.

public class TestException {

public static void main(String[] args) {

Calcul calcul = new Calcul();

calcul.factoriel(-3);

}
}

Exercice 3 :
Adapter la classe EntNat de l’exercice et le programme d’utilisation de manière à disposer
dans le gestionnaire d’exception du type ErrConst de la valeur fournie à tort au constructeur.

Exercice 4 :
Quels résultats fournit ce programme ?

class Erreur extends Exception

{ public int num ;
}
class Erreur_d extends Erreur
{ public int code ;
}
class A
{ public A(int n) throws Erreur_d
{ if (n==1) { Erreur_d e = new Erreur_d() ; e.num = 999 ; e.code = 12 ;
throw e ;

Page 4/5
 Session Hiver 2023

}
}
}
public class Chemin1
{
public static void main (String args[])
{ try
{ A a = new A(1) ;
System.out.println ("apres creation a(1)") ;
}
catch (Erreur e)
{ System.out.println ("** exception Erreur " + e.num) ;
}
System.out.println ("suite main") ;
try
{ A b = new A(1) ;
System.out.println ("apres creation b(1)") ;
}
catch (Erreur_d e)
{ System.out.println ("** exception Erreur_d " + e.num + " " + e.code) ;
}
catch (Erreur e)
{ System.out.println ("** exception Erreur " + e.num) ;
}
}
}
Que se passe-t-il si l’on inverse l’ordre des deux gestionnaires dans le second bloc try ?

Page 5/5