JAVA AVANCÉ
ENSEIGNANTE : MME HOUDA ANOUN
PLAN DU COURS
• Les exceptions
• La généricité
• Les collections
• Lambda expressions
• Jdbc
LES EXCEPTIONS
INTRODUCTION AUX EXCEPTIONS
• Les langages de programmation de haut niveau comme Java fournissent des mécanismes
permettant de gérer les erreurs qui peuvent intervenir lors de l’exécution du
programme. Le mécanisme de gestion d’erreurs le plus répandu est celui des exceptions.
• Les exceptions sont largement utilisées par les classes de la librairie standard de Java
• Quelques exemples d’erreurs :
• De bas niveau :
• accès hors limite d’un tableau
• division par 0
• mauvaise conversion (ex. convertir la chaine "abc202 " en entier)
• Erreurs logiques de plus haut niveau :
• dépiler une pile vide
• calcul de la factorielle d’un négatif etc
PREMIER EXEMPLE
public class Factorielle {
public static int factorielle(int n) throws Exception {
int res = 1;
if (n<0){
throw new Exception("La factorielle d’un nombre négatif n’est pas définie! ");}
for(int i = 1; i <= n; i++) {
res = res * i;}
return res;}
}
COMMENTAIRES
• Il est possible que la fonction factorielle ne soit pas capable d’effectuer sa tâche : si elle
reçoit un argument négatif
• La fonction factorielle ne sait rien du programme global, elle est incapable de traiter cette
erreur potentielle. Par conséquent, il est souhaitable qu’elle « transmette l’erreur » à un
niveau qui peut la traiter.
• Transmettre l’erreur = lever une exception
• Une exception en Java est un objet créé lorsqu’une condition anormale survient lors de
l’exécution d’un programme.
• L’objet contient des données membres qui mémorisent des informations sur la nature du
problème survenu (par ex. un message décrivant l’erreur dans notre cas)
• La déclaration throws Exception ajoutée à la signature de la méthode indique qu’il est
possible que cette méthode lance une exception
PREMIER EXEMPLE (SUITE)
public class TestFactorielle{ Scénario d’exécution normal :
public static void main(String[ ] args){
Scanner sc= new Scanner([Link]); Votre nombre? 3
[Link]("Votre nombre ?"); La factorielle de 3 est 6
int d= [Link]();
try{
int f=[Link](d);
Scénario avec traitement d’exception:
[Link]("La factorielle de "+d+ "est : "+f);
}
Votre nombre? -3
catch( Exception e){
La factorielle d’un nombre négatif n’est
[Link]([Link]());}
pas définie!
}}
HIÉRARCHIE DES EXCEPTIONS
CLASSES D’EXCEPTION PRÉDÉFINIES EN JAVA
Il existe de nombreuses classes d’exceptions prédéfinies en Java, classées en trois catégories :
• Classes dérivées de la classe Error : elles représentent des erreurs critiques qui ne sont pas censées
être gérées. Par exemple, une exception de type OutOfMemoryError est lancée lorsqu’il n’y a plus de
mémoire disponible dans le système.
• Exceptions non contrôlées (unchecked) : Classes dérivées de la classe RuntimeException : elles
représentent des erreurs de programmation, il est recommandé de les éviter en écrivant un code
robuste. Le programmeur n’est pas obligé de les gérer explicitement.
• l’exception NullPointerException est lancée si l’on tente d’accéder à un objet qui vaut null
• l’exception ArrayIndexOutOfBoundsException est lancée lorsqu'un indice invalide est utilisé pour accéder à
un tableau
• Exceptions contrôlées (checked) : Classes dérivées de la classe Exception (mais pas
RuntimeException) : elles représentent les erreurs qui doivent être gérées par le programme.
• une exception de type IOException est lancée en cas d’erreur lors de la lecture d’un fichier.
EXEMPLE : EXCEPTION NON-CONTRÔLÉE NON
GÉRÉE
public class Div {
public static int divint (int x, int y) {
return (x/y);
}
public static void main (String [] args) {
int c=0,a=1,b=0;
c= divint(a,b);
[Link]("res: " + c);
}}
Exception in thread "main" [Link]: / by zero
at [Link]([Link])
at [Link]([Link])
Une erreur (de type ArithmeticException) s'est produite à la ligne 5 de la méthode divint appelée
par la méthode main à la ligne 9. Cette erreur n’a pas été gérée (traitée) par le programme
EXEMPLE : EXCEPTION NON-CONTRÔLÉE GÉRÉE
public class Div {
public static int divint (int x, int y) {
return (x/y);
}
public static void main (String [] args) {
int c=0,a=1,b=0;
try{
c= divint(a,b);
[Link]("res: " + c);
}
catch(ArithmeticException e){
[Link]([Link]());}}} //traitement de l’exception lancée
/ by zero
EXEMPLE : EXCEPTION CONTROLÉE PAR LE
COMPILATEUR
Erreur de compilation :
CLASSE EXCEPTION
• La classe Exception est conçue pour être étendue par des classes d'exceptions spécifiques à une
application.
Constructeurs Méthodes (héritées de Throwable)
// Constructeur par défaut String getMessage() : renvoie le message
public Exception(); d’erreur qui décrit l’exception
void printStackTrace(): affiche l’historique
// Constructeur avec un message d'erreur de propagation de l’exception = la liste des
public Exception(String message); appels de méthodes qui conduisent à
l'endroit où l'exception est levée.
DÉFINITION D’UNE CLASSE D’EXCEPTION PERSONNALISÉE
public class ArgumentNegatifException extends Exception {
// attribut d’instance pour stocker la valeur de l’argument négatif
private int arg;
public ArgumentNegatifException(int arg, String m){
super(m); // appel au constructeur Exception(String message)
[Link]=arg;}
public int getArg( ){
return arg;}
}
EXEMPLE DE LEVÉE D’UNE EXCEPTION
PERSONNALISÉE
LEVÉE D’UNE EXCEPTION
• Plus une méthode est éloignée de la méthode main dans la pile d’exécution, moins
elle a une vision globale de l’application
• Une méthode peut donc lever une exception si elle ne sait pas comment la traiter, en
espérant qu’une méthode appelante en saura assez pour la traiter
• Lorsque l’on veut lancer une exception, on utilise le mot clé throw suivi d’une
instance de la classe d’exception à lever : throw new NomException(arg1, …., argn)
• Lorsqu’une exception est levée (en dehors d’un bloc try), l’exécution de la méthode
s’arrête et on remonte immédiatement dans la méthode appelante pour lui donner la
possibilité de traiter cette exception
SPÉCIFICATION DES EXCEPTIONS
• Une méthode doit déclarer explicitement les exceptions contrôlées qu’elle est
susceptible de lever (classe Exception ou une classe dérivée à part
RuntimeException):
public void maMethode(…) throws E1, E2 { … }
• Cela est utile pour l’appelant de cette méthode qui saura contre quelles exceptions
se prémunir
• Remarque : Toute redéfinition de maMethode devra respecter cette signature… mais
peut lever dynamiquement une exception plus spécifique (sous-classe)
• Il est facultatif de spécifier la levée des exceptions non contrôlées provenant des
hiérarchies Error et RuntimeException
PROPAGATION D’EXCEPTION
• La méthode qui appelle une méthode qui lance une exception contrôlée doit à son tour la propager ou la
traiter. Dans le cas contraire, le compilateur génère une erreur de syntaxe.
• Propagation de l’exception : static int sommeFactorielle(int [] tab) throws ArgumentNegatifException
• Si une exception est lancée, elle remonte vers la méthode appelante jusqu’à ce qu’elle soit traitée. Si elle
remonte jusqu’à la méthode main() sans être traitée par cette méthode :
• l’exécution du programme est interrompue
• le message associé à l’exception est affiché, avec une description de la pile des méthodes traversées par
l’exception
EXEMPLE : TRAITEMENT D’UNE EXCEPTION
TRAITEMENT D’UNE EXCEPTION
• Pour traiter une exception, il existe trois types de blocs de code qu’ont peut inclure dans la méthode qui
va se charger du traitement:
• try
• catch
• finally
• Le bloc try délimite le code qui est susceptible de lancer une ou plusieurs exceptions.
• Le bloc catch délimite le code qui est destiné à traiter les exceptions d’un type particulier qui pourraient
être lancées par le code du bloc try.
• Le bloc finally délimite un code qui sera toujours exécuté qu’il y ait ou non lancement d’exceptions par le
code du bloc try, c’est souvent utilisé pour libérer les ressources
SYNTAXE DES BLOCS TRY-CATCH-FINALLY
try {
// Code qui peut générer une exception
}
catch (ClasseException1 e1) {
// Traitement en cas d'exception de type ClasseException1
….
catch (ClasseExceptionk ek) {
// Traitement en cas d'exception de type ClasseExceptionk
}
finally { // bloc optionnel
//Bloc F : Bloc exécuté quelle que soit la situation
}
SCÉNARIO 1 : PAS DE LANCEMENT D’EXCEPTION
L’exécution commence au try {
début de try // Code qui peut lancer des exceptions
}
catch (ClasseException1 e) {
Après une sortie normale du bloc try, le // Code qui traite ClasseException1
bloc finally est exécuté, avant toute }
instruction return dans le bloc try
catch (ClasseException2 e){
// Code qui traite ClasseException2
}
Si aucune instruction
return ne se trouve ni finally {
dans try, ni dans finally, // Code à exécuter toujours
l’exécution continue à }
l’instruction qui suit
finally.
SCÉNARIO 2 : EXCEPTION LANCÉE PUIS ATTRAPÉE
L’exécution try {
commence au // Code qui peut lancer des exceptions
début de try
}
L’exécution s’arrête au point où s’est
produite l’exception. L’exécution catch (MyException1 e) {
continue au bloc catch qui correspond
à l’exception
// Code qui traite MyException1
}
catch (MyException2 e){
// Code qui traite MyException2
Après l’exécution du bloc }
catch, le contrôle passe au
bloc finally finally {
// Code à exécuter toujours
}
Si aucune instruction
return ne se trouve ni dans
catch, ni dans finally,
l’exécution continue à
l’instruction qui suit finally. 23
REMARQUE
• L’ordre des blocs catch est important! Les blocs catch sont évalués dans l'ordre dans
lequel ils sont déclarés, et le premier bloc catch correspondant au type de
l'exception levée est celui qui est exécuté.
• On doit commencer par la classe d’exception la plus dérivée (sous-classe) en
premier, et laisser la classe d’exception de base (superclasse) à la fin. Dans le cas
contraire, le code ne sera pas compilé.
• Justification : Si vous avez un bloc catch pour une sous-classe après un bloc catch
pour une superclasse, le bloc catch pour la sous-classe ne sera jamais exécuté
RELANCE D’UNE EXCEPTION
• Un bloc catch peut lui-même lever une exception :
Relance de la même exception Relance d’une nouvelle exception
catch (E1 e) catch (E1 e)
{ //traitement local { //traitement local
throw e; throw new E2(…);
} }
• Une exception peut être relancée vers le programme appelant en vue de terminer
son traitement
QUIZ 1
Qu’affiche ce code?
class Base extends Exception {}
class Derived extends Base {}
public class Main {
public static void main(String args[]) {
try {
throw new Derived();
}
catch(Base b) {
[Link]("Caught base class exception");
}
catch(Derived d) {
[Link]("Caught derived class exception");
}
}
}
QUIZ 2
• Qu’affiche ce programme?
int[ ][ ]m={{1, -1, 3}, {1, 2, 3}};
int s;
for (int i=0; i<[Link]; i++){
s=0;
try{
[Link]("Try : Tour de boucle :"+(i+1));
s=[Link](m[i]);
[Link]("La somme est :"+s);
}
catch(ArgumentNegatifException e){
[Link]("Problème dans l'argument : "+[Link]()+" "+[Link]());}
finally{
[Link]("Bloc Finally : "+s);
}
}
QUIZ 3
• Qu’affiche ce programme?
int[ ][ ]m={{1, -1, 3}, {1, 2, 3}};
int s = 0;
try{
for (int i=0; i<[Link]; i++){
[Link]("Try : Tour de boucle :"+(i+1));
s=[Link](m[i]);
[Link]("La somme est :"+s);
}
}
catch(ArgumentNegatifException e){
[Link]("Problème dans l'argument : "+[Link]()+" "+[Link]());}
finally{
[Link]("Bloc Finally : "+s);}
