Programmation Orientée
Objet: Java
Sadok Ben Yahia, PhD
Faculté des Sciences de Tunis
[Link]@[Link]
1
Plan
● Introduction au monde Objet
● La langage Java: Introduction et caractéristiques
● Syntaxe et structures de contrôle
● Héritage
● Les exceptions
● Les Entrées/Sorties
● Connexion Java et les bases de données: l’API JDBC
2
Exception : Définition
❑ La gestion des erreurs dans un programme est une activité importante et
souvent complexe dans les langages classiques
❑ Au lieu de gérer les erreurs à l’aide des constantes (comme en C), on
peut créer dans nos programmes des classes supplémentaires d’exception
❑ Une exception est un objet particulier de la classe Exception ou d’une
des ses sous classes qui est crée au moment où une situation anormale
est détectée
❑ Les exceptions sont rencontrées dans de nombreuses situations
❑ Une exception est une sorte de signal qui indique qu’une erreur ou une
situation anormale est intervenue
❑ Une méthode ayant détecté une situation anormale déclenche une
exception. Cette exception sera capturée par le code
3
Exception : Exemple
❑
Certaines exécutions peuvent faire
apparaître (lever) des exceptions
try {
❑ utilisation des clauses try et catch
Int val=[Link](A[0]);
}
catch (NumberFormatException
except) {
[Link]("erreur");
return; // on sort sans créer
d’instance
}
4
Exception : 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 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
programme 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.
5
Exception : Objet Exception
❑ En Java, les exceptions sont des objets
❑ Toute exception doit être instance d’une sous-classe de la classe [Link]
6
Exception : Objet Exception
❑ En Java, les exceptions sont des objets
❑ Toute exception doit être instance d’une sous-classe de la classe [Link]
7
Exception : Traitement
try délimite un ensemble d’instructions susceptibles de déclencher une ou
●
plusieurs types d’exceptions pour lesquelles une gestion est mise en
oeuvre.
try{ ...
// code pouvant lever des exceptions
}
●catch : Cette gestion est réalisée par des blocs qui suivent le bloc try {...}.
Les blocs catch interceptent (attrapent) les exceptions dont le type est
spécifié afin d’exécuter du code spécifique à la gestion de l’erreur
catch(TypeDexception e)
{
...
}
8
Exception : Traitement
9
Exception : Traitement
class ExceptionCatch {
static int moyenne(String[] Résultats d’exécution
liste)
{ int somme = 0,entier, nbNotes = •java ExceptionCatch oups 15 12
0;
for (int i = 0; i < [Link];
i++) La 1 eme note n'est pas entiere
{ try { entier =
La moyenne est 13
[Link](liste[i]); somme
+= entier; •java ExceptionCatch oups 15.5
nbNotes++; La 1 eme note n'est pas entiere
}
catch (NumberFormatException e) { La 2 eme note n'est pas entiere
[Link]("La "+(i+1)+" [Link]: / by zero at
eme note "+ "n'est pas entiere"); [Link]([Link]
} ) at [Link]([Link]
}
return Somme/nbNotes; }
public static void main(String[]
argv)
{[Link]. println("La moyenne
est " + moyenne(argv)); } } 10
Exception : Traitement…
Un bloc try peut-être suivi de plusieurs clauses catch qui permettent
●
d’intercepter les exceptions dont le type est spécifié (dans la clause catch)
et d’exécuter alors du code spécifique à l’exception.
●Un seul bloc catch peut-être exécuté : le premier susceptible 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.
11
Exception : Traitement…
●L’ordre des blocs catch est donc important !
● Il n’est pas nécessaire d’avoir une clause catch pour chaque type
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.
● Cela permet de traiter différentes types d’exceptions à différents endroits
du programme.
● 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.
12
Exception : le bloc finally
❑ Le clauses catch sont suivies de manière optionnelle par un bloc finally
❑Le bloc finally 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
❑ 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.
13
Exception : Traitement…
❑ Intérêt double :
❑ permet de rassembler dans un seul bloc un ensemble
d’instructions qui autrement auraient pu ê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
14
Exception : Traitement…
...
...
try { try {
// ouvrir un fichier // ouvrir un fichier
// effectuer des traitements // effectuer des traitements
// susceptibles de lever une // susceptibles de lever une
// exceptions // exceptions
// fermer le fichier // fermer le fichier
... ...
} }
catch (CertainesExceptions e) {
catch (CertainesExceptions e) // traiter l’exception
{ }
// traiter l’exception catch (AutresExceptions e) {
// Fermer le fichier // traiter l’exception
} }
catch (AutresExceptions e) { finally {
// traiter l’exception // fermer le fichier
// Fermer le fichier} }
15
Exception : définition de exceptions
utilisateur…
● On peut définir nos propres exceptions au moyen de l’instruction throw
public class MyException extends Exception
{
…
}
● L’instruction throw(unObjetException) permet de lancer une exception
● unObjetException doit être une instance d’une sous-classe de Throwable
throw new MyException();
●Quand une exception est lancée,
● l’exécution du programme est interrompue,
● la JVM recherche la clause catch la plus proche permettant de traiter l’exception
lancée,
● 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é
(catch)
● Tous les blocs finally rencontrés au cours de cette propagation sont exécutés.
16
Exception : Traitement…
class
L’exception doit être
OperationBancaireExceptio déclarée dans la
n extends Exception { signature
/** class Compte {
de la méthode
* Compte pour lequel protected double solde = 0;
l’opération a échouée ..... L’opération ne
/** peut être effectuée
*/ que
private Compte c; si le dépôt est >= 0
public •Dépôt d’argent sur le compte
OperationBancaireExceptio * s, la somme a déposer, s doit être >= 0
* throws OperationBancaireException si s <=
n (Compte c, String s) { 0
super(s); */
This.c=c; public void créditer(double s) throws
} OperationBancaireException
{
if(s < 0) throw(new
OperationBancaireException (this, “dépôt
incorrect”)) ;
Si la pré-condition solde += s;
n’est pas vérifiée, }
création et }
lancement d’une
exception
17
Exception : Exemple
class ExceptionRien extends
Exception { public String la méthode moyenne indique ainsi qu'il est
toString() { return("Aucune note possible qu'une de ses instructions envoie une
n'est valide"); } }
exception de type ExceptionRien sans que
celle-ci soit attrapée par un mécanisme try-catch.
class ExceptionThrow {
static int moyenne(String[]
liste) throws ExceptionRien {
int somme=0,entier, nbNotes=0; on demande ainsi le lancement d'une instance
int i; de ExceptionRien. Une fois lancée, l'exception
for (i=0;i < [Link];i++) { se propagera. Ici, il y aura sortie de la méthode
try { moyenne, on se retrouve alors à l'appel de la
entier=[Link](liste[i]) méthode moyenne dans le main, appel qui se
; trouve dans un "bloc try" suivi d'un "bloc catch"
somme+=entier; nbNotes++; } qui attrape les ExceptionRien(s) : l'instruction de
catch (NumberFormatException e) { ce "bloc catch" est effectuée. Le programme
[Link]("La "+(i+1)+" reprend alors son cours normal (pour se
eme note n'est "+ "pas entiere"); terminer).
} }
public static void main (String[]
if (nbNotes==0) throw new A) {try { [Link]("La
ExceptionRien(); moyenne est "+moyenne(A)); }
return somme/nbNotes; } catch (ExceptionRien e)
{ [Link](e); } } }
18
Redéclenchement d'une exception
•Dans un gestionnaire d'exception, il est possible de demander que, malgré son
traitement, l'exception soit retransmise à un niveau englobant, comme si elle n'avait
pas été traitée. Il suffit pour cela de la relancer en appelant à nouveau l'instruction
throw.
19
Exception : Conclusion
Toute méthode susceptible de lever une
●
exception doit :
● Soit l’attraper,
●Soitla 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 exceptions 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.
si on oublie de traiter, une exception, une erreur
●
de compilation
20