Les classes abstraites

 Concept des classes abstraites

 Une classe abstraite est une classe qui ne permet pas l’instanciation
des objets de son type. C’est une classe incomplète puisqu’elle
contient certaines méthodes dont leurs corps sont définies dans la
classe dérivée. En effet, elle doit être héritée.
 Une classe abstraite comporte une ou plusieurs méthodes
abstraites, et elle peut comporter d'autres méthodes non abstraites.
 Une méthode abstraite est une méthode qui ne possède pas
d’instructions (corps). Elle comporte seulement une signature de
définition suivie du caractère point-virgule.
 Une méthode abstraite doit être précédée par le mot clé abstract.
Exemple :
public abstract double f();
 Les classes abstraites (2)

 Syntaxe

abstract class Personne {

public void affiche() {……} // affiche() est définie dans Personne

public abstract void determineAge (int n) ; //determineAge() est

//une méthode abstraite, elle n’est pas définie dans Personne.
}

 Utilisation

Personne p ; //on peut déclarer une référence sur un objet de type

//Personne ou dérivé.

p = new Personne (….); //Erreur, pas d’instanciation d’objets

//d’une classe abstraite.
 Les classes abstraites (3)

Une classe abstraite peut être utile pour imposer l'existence de certaines
méthodes dans des classes, sans savoir comment elles seront implémentées.

abstract class Graphique {

….
abstract void affiche();
}

class Rectangle extends Graphique{ class Cercle extends Graphique{

…. ….
public void affiche (){ public void affiche (){
Syso ("Je suis un rectangle") ;} Syso ("Je suis un cercle") ;}
} }

Une classe qui hérite d'une classe abstraite doit redéfinir les méthodes
abstraites, sinon elle est abstraite également.
En C++, les méthodes abstraites sont dites virtuelles pures :
virtual void methodeAbstraite() = 0;
 Les classes abstraites (4)
 Règles des classes abstraites
 Une classe est automatiquement abstraite si une de ses méthodes
est abstraite.
 On doit déclarer également une classe abstraite par le mot clé
abstract.
 Une méthode abstraite ne peut pas être privée, ce qui est logique
puisque son corps sera définit dans une classe dérivée.
 Les noms d’arguments muets doivent figurer dans la définition d’une
méthode abstraite.
public abstract void determineAge (int); //Erreur : nom argument
fictif est obligatoire
 Une classe dérivée d’une classe abstraite n’est pas obligée de
redéfinir toutes les méthodes abstraites, elle peut ne redéfinir
aucune, mais elle reste abstraite tant qu’il y a encore des
méthodes abstraites non implémentées.
 Une classe dérivée d’une classe non abstraite peut être déclarée
abstraite.
 Les classes abstraites (5)

 Règles des classes abstraites (2)

 Une classe abstraite est non instanciable (donc il n’est pas possible
d’utiliser les constructeurs de cette classe et donc on ne peut pas
créer des objet de son type.)
 Une classe dérivée d'une classe abstraite ne devient concrète que si
elle implémente toutes les méthodes abstraites de sa classe de
base.
 Une méthode abstraite ne possède pas de corps, mais doit être
implémentée dans les classes dérivées non abstraites :
abstract fonction (arguments); ce n'est qu'une signature .
 Une classe abstraite peut contenir des méthodes non abstraites et
des déclarations de variables ordinaires.
 Les classes abstraites (6)

 Intérêt des classes abstraites

 Les classes abstraites facilitent largement la conception orientée

objet.

 On peut placer dans une classe abstraite toutes les fonctionnalités

dont on souhaite disposer pour les classes descendantes :

 Soit sous la forme d’une implémentation complète de

méthodes (non abstraites) et de champs lorsqu’ils sont communs
à tous les descendants,

Soit sous forme d’interface des méthodes abstraites dont on est

alors sûr qu’elles existeront dans toute classe dérivée instanciable.
 Les classes abstraites (7)

Exemple :

 Considérons la hiérarchie des classes suivantes :

Surface () Graphique

Cercle Rectangle

On veut que les classes Cercle et Rectangle disposent de la méthode

surface() retournant la surface de la figure géométrique définie par la
classe.
 Les classes abstraites (8)

public abstract class Graphique {

private int x, y;
//Une classe abstraite ne peut pas être instanciée, mais elle peut avoir un
//constructeur :
public graphique ( int x, int y) {
this.x = x ; this.y = y ;}

//Voilà la méthode abstraite à compléter :

public abstract double surface();

//Toutes les méthodes ne sont pas abstraites :

public void affiche() {
System.out.println ("Le centre de l’objet se trouve dans :" + x+ " et " + y) ;
System.out.println ("La surface de l'objet est :" +this.surface()) ;
}
}
 Les classes abstraites (9)

public class Cercle extends Graphique {

private double rayon =1 ;
public Cercle ( int x, int y, double r){
super(x,y) ; rayon = r ;}
public double surface (){
return (2* 3.14 *rayon) ; }
}

public class Rectangle extends Graphique {

private int larg, lng ;
public Rectangle ( int x, int y, int larg, int lon){
super (x,y) ; this.lng = lon ; this.larg = larg ;}
public double surface () {
return (lng*larg);}
}
 Les classes abstraites (10)
public class TestPoly2 {
public static void main (String [] args) {
Graphique [] tab = new Graphique [6];
//tab[0] = new Graphique (3,2);//Erreur, classe abstraite est non instanciable
//Même si la classe Graphique est abstraite, il est tout de même possible
//de déclarer des variables de ce type qui pourront recevoir des objets
//créés à partir des sous-classes concrètes :
tab[0] = new Cercle (3,2,7);
tab[1] = new Cercle (10,7,3) ;
tab[2] = new Rectangle (4,7,8,6) ;
tab[3] = new Rectangle (8,10,12,10);
tab[4] = new Cercle (8,5,3) ;
tab[5] = new Rectangle (10,17,3,8) ;
for (int i=0 ; i <=5 ; i++) { tab[i].affiche(); } }
}
Résultat ????
 Les interfaces
 Concept d’interface

Une interface est un ensemble d'opérations utilisées pour spécifier

un service offert par une classe.
Elle peut être vue comme une classe sans attributs (sauf les
constantes) et dont toutes les opérations sont spécifiées mais pas
définies à priori.
Elle peut être vue comme un contrat ou un modèle que doivent
offrir toutes les classes qui se réclament (implémentent) de cette
interface.

public interface Polygon{

public int surface();
public void deplace(int, int);
}
 Les interfaces (2)
Le corps d'une interface ressemble beaucoup à celui d'une classe
abstraite avec cependant les différences suivantes :
Une interface ne peut définir que des méthodes abstraites. Le
modificateur abstract n'est pas nécessaire.
Toutes les méthodes abstraites sont implicitement publiques même
si le modificateur public est omis.
Une interface ne peut pas contenir de méthodes statiques.
Une interface ne peut pas définir de champs d'instance.
Une interface peut cependant contenir des constantes déclarées
static et final (tous les champs sont implicitement static et final même
si les modificateurs correspondants sont omis).
Une interface ne définit pas de constructeur (on ne peut pas
l'instancier et elle n'intervient pas dans le chaînage des constructeurs).
 Les interfaces (3)

 Si l’on considère une classe abstraite n’implémentant aucune

méthode et aucun champ (sauf les constantes), on aboutit à la
notion d’interface.
 Une interface définit les entêtes d’un certain nombre de méthodes,
ainsi que des constantes.
 L’interface est plus riche qu’un simple cas particulier des classes
abstraites :
Une classe peut implémenter plusieurs interfaces (alors qu’une
classe ne pouvait dériver que d’une seule classe abstraite).
Les interfaces peuvent se dériver.
Une classe dérivée peut implémenter 1 ou plusieurs interfaces,
elle peut même réimplémenter une interface déjà implémentée par
la superclasse.
On pourra utiliser des variables de type interface.
 Les interfaces (4)
 Syntaxe
public interface I{
void f (int n); //public abstract est facultatif
void g (); //public abstract est facultatif
}

 Implémentation d’une interface

Lorsqu’on définit une classe, on peut préciser qu’elle implémente une
interface donnée en utilisant le mot clé « implements ».

public interface I1
{….}
public interface I2
{…}
public class A implements I1, I2
{…..A doit définir les méthodes de I1 et I2}
 Les interfaces (5)
Exemple 1 :

public interface Affichable{

public class Flottant implements Affichable {
void affiche() ;
private float val ;
}
public Flottant (float n){
public class Entier implements Affichable {
val = n ;
private int val ;
}
public Entier (int n) {val = n ;}
public void affiche() {
public void affiche() {
System.out.println ("Je suis un flottant
System.out.println ("Je suis un entier
de valeur " + val) ;
de valeur" + val) ;
}
}
}
}

public class TestInterface {

public static void main (String [] args) {
Affichable [] tab = new Affichable [2]; Résultat de l’exécution
tab[0] = new Entier (25);
- Je suis un entier de valeur 25
tab [1] = new Flottant (1.25);
tab [0].affiche(); - Je suis un flottant de valeur 1.25
tab [1].affiche (); }
}
 Les interfaces (6)
Exemple 2 :
public interface Perimetre { public float per(); }
public interface Surface { public float sur(); }
public interface Resultat { public void result(); }

public class Rectangle implements Perimetre, Surface, Resultat{

private float A, B; Rectangle implémente
public Rectangle (float a, float b) { A= a; B= b; } les interfaces Perimetre,
Surface et Resultat
public float per() { return(2*(A+B)); }
public float sur() { return(A*B); }
public void result() {
System.out.println("Perimetre= "+ per());
System.out.println("Surface = "+ sur()); }
}

public class Test1Interface {

public static void main (String [] args){
Rectangle R= new Rectangle (2.5f, 4.0f);
R.result(); }}
 Les interfaces (7)
 Interface et constantes

 Une interface peut renfermer aussi des constantes symboliques qui

seront accessibles à toutes les classes implémentant l’interface :

public interface I{
static final int max = 100 ;
void f (int n);
void g () ;
}

 Les constantes déclarées sont toujours considérées comme « static »

et « final »
 Les interfaces (8)
 Interface et dérivations

 L’interface est totalement indépendante de l’héritage : Une classe

dérivée peut implémenter une ou plusieurs interfaces.

 L'implémentation d'une ou plusieurs interfaces (implements) peut

être combinée avec l'héritage simple (extends).

 La clause implements doit suivre la clause extends.

interface I1 {…..}

interface I2 {…..}

class A implements I1 {……}

class B extends A implements I1, I2 {…..}

 Les interfaces (9)
Exemple 2 :
public interface Perimetre { public float per(); } Rectangle implémente
public interface Surface { public float sur(); } les interfaces Perimetre
public interface Resultat { public void result(); } et Surface

public class Rectangle implements Perimetre, Surface{

public float A, B;
public Rectangle (float a, float b) { A= a; B= b; }
public float per() { return(2*(A+B)); }
public float sur() { return(A*B); }
}
Square hérite
public class Square extends Rectangle implements Resultat{
de Rectangle
public Square (float a) { super(a, a); }
public void result() {
System.out.println("Perimetre= "+ per());
System.out.println("Surface = "+ sur()); }
}
public class Test2Interface {
public static void main (String [] args){
Square S= new Square(5.0f);
S.result(); }}
 Les interfaces (10)

Quelques propriétés d’interfaces :

 Lorsqu'une classe déclare une interface dans sa clause implements,

elle indique ainsi qu'elle s'engage à fournir une implémentation (c'est-
à-dire un corps ) pour chacune des méthodes de cette interface.

 Si une classe implémente une interface mais ne fournit pas

d'implémentation pour toutes les méthodes de l'interface, c-à-d elle
hérite des méthodes (abstraites) non implémentées , elle doit être
déclarée abstract.

 Si une classe implémente plus d'une interface, elle doit implémenter

toutes les méthodes de chacune des interfaces mentionnées dans la
clause implements (ou alors doit être déclarée abstract).
 Les interfaces (11)
Exemple :
public interface Affichage{ public void affiche(); }
public abstract class Figure implements Affichage{
public abstract double perimetre(); // Méthode abstraite
public abstract double surface(); // Méthode abstraite
}
//Pourquoi cette classe est abstraite??.
public class Cercle extends Figure {
public static final double PI = 3.14;
protected double rayon;
public Cercle(double rayon) { this.rayon= rayon; }
public double getRayon() { return rayon; }
public double perimetre() { return 2*PI*rayon; }
public double surface() { return PI*rayon*rayon; }
public void affiche() { ... }
}
//Pourquoi cette classe n’est pas abstraite??.
 Les interfaces (12)
 Conflits des noms

 Soit l’exemple suivant :

interface I1 { Supposons que la méthode « g () » est

void f(int n) ; présentée de 2 façons différentes dans I1 et I2
void g(); interface I1 {
} void g();
interface I2 { } // g est une méthode abstraite de I1
void f (float x); interface I2 {
void g(); int g();

} } // g est aussi une méthode abstraite de I2

class A implements I1, I2
class A implements I1, I2{
{/* Erreur car void g() et int g() ne peuvent pas
/*A doit implémenter la coexister au sein de la même classe*/
méthode g existante dans les
}
2 interfaces une seule fois*/
}
 Les interfaces Comparable et Cloneable
 l’interface Comparable
 L’interface Comparable, nécessite l’implémentation de la
méthode compareTo :
interface Comparable {
public int compareTo(Object o);
}
La méthode compareTo permet de comparer l’objet courant (this) à l’objet
o reçu en argument et de renvoyer un entier (dont la valeur exacte est
sans importance) :
 négatif (la valeur -1) si l’on considère que l’objet courant est "inférieur"
à l’objet o (au sens de l’ordre qu’on veut définir),

 nul (la valeur 0) si l’on considère que l’objet courant est égal à l’objet o
(il n’est ni inférieur, ni supérieur),

 positif (la valeur 1) si l’on considère que l’objet courant est "supérieur"
à l’objet o
 Les interfaces Comparable et Cloneable (2)
 l’interface Cloneable
 L’interface Cloneable : interface Cloneable {
public Object clone();
}
 Une classe qui veut que ses instances puissent être clonés
superficiellement devra implémenter l’interface Cloneable et redéfinir
la méthode clone() :
class XSurface implements Cloneable{
...
public Object clone() throws CloneNotSupportedException {
return super.clone();
}}
 Une classe qui veut que ses instances puissent être clonés en
profondeur devra implémenter l’interface Cloneable et redéfinir la
méthode clone() :
class XProfondeur implements Cloneable{
X x; . . .
public Object clone() throws CloneNotSupportedException {
XProfondeur xp = (XProfondeur) super.clone() ;
xp.x = (X)x.clone();
return xp; } }
 Les interfaces Comparable et Cloneable (3)
Exemple de l’interface Cloneable: Superficielle

public class Cellule implements Cloneable{

int[] t ; public class TesteCellule {
public Cellule(int n){
public static void main(String[] args) {
t= new int[n];
for(int i=0;i<n;i++) try{
t[i]=(int)(Math.random()*10);
} Cellule x = new Cellule(3); // x Objet Cellule
// Méthodes
public Object clone() throws x.afficher();
CloneNotSupportedException {
Cellule y = (Cellule) x.clone(); // y clone de x
return super.clone();
} y.afficher();
public void afficher(){
System.out.println(“les éléments du tableau: “); }catch (CloneNotSupportedException e){
for(int i=0;i<t.length;i++)
System.out.println( t[i]); throw new InternalError();
} }
} }
}
 Les interfaces Comparable et Cloneable (4)
Exemple de l’interface Cloneable: Profondeur

public class Cellule implements Cloneable {

int[] t ; public class TesteClone {
public Cellule(int n){
public static void main(String[] args) {
t= new int[n];
for(int i=0;i<n;i++) try{
t[i]=(int)(Math.random()*10);
} Cellule x = new Cellule(3); // x Objet Cellule
// Méthodes
public Object clone() throws x.afficher();
CloneNotSupportedException {
Cellule y = (Cellule) x.clone(); // y clone de x
Cellule tmp=(Cellule) super.clone();
tmp.t=(int [])this.t.clone(); y.afficher();
return tmp;
} }catch (CloneNotSupportedException e){
public void afficher(){
throw new InternalError();
System.out.println(“les éléments du tableau: “);
for(int i=0;i<t.length;i++) }
System.out.println( t[i]); }
}} }
 abstraction
L'abstraction permet de décrire des comportements via des méthodes
abstraites, en ne précisant que les entrées-sorties de ces méthodes.
Ces méthodes abstraites peuvent être définies dans des interfaces (où
toutes les méthodes sont abstraites) ou dans des classes abstraites (où au
moins une méthode est abstraite) qui sont des types de données abstraits.
 Membres de classe
Une classe est une description, à un niveau plus abstrait, des objets qui en
sont les instances.

Mais il peut être utile de décrire des données ou des comportements

véritablement communs à toutes les instances :
Attributs avec la même valeur pour toutes les instances
Méthodes s'exécutant de la même façon pour toutes les instances.

public class Quadrupède{

// attributs
int nbPattes = 4;
...
// méthodes
void classerParPoids(Quadrupède[] t){
...
}
}
Gestion des
exceptions
 La gestion des exceptions
Présentation
Une exception est un événement indiquant que quelque chose
d'exceptionnel (par exemple une erreur) est produite.
Elle interrompt le flot d’exécution normal du programme.
C’est un mécanisme permettant de reporter des erreurs vers les
méthodes appelantes.
C’est un événement exceptionnel risquant de compromettre le bon
déroulement du programme, par exemple :
Division par zéro,
Un débordement de tableau ou de pile,
La lecture d’une donnée erronée ou de fin de fichier prématuré.
Problème en C :
Prévoir une plage de valeurs dans la valeur de retour pour signaler
les erreurs.
Propager les erreurs “manuellement”
En Java comme en C++, le mécanisme de remonté d’erreur est gérée
par le langage.
 La gestion des exceptions (2)

Exemple 1 :
class Main {
public static void main(String[] args) {
System.out.println("Donner deux nombres");
Scanner sc=new Scanner(System.in);
int a=sc.nextInt(); int b=sc.nextInt();
int n = a/b; System.out.println(n); }}
Sortie
Donner deux nombres
2
0
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Main.main(TestNombre.java:7)
 La gestion des exceptions (3)
Exemple 2 :
import java.util.Scanner;
public class SommeMoyenne {
public static void main(String [] args){
double S=0; Scanner sc=new Scanner(System.in);
System.out.println("Entrez la taille du tableau:");
int N=sc.nextInt(); double []T=new double [N];
System.out.println("Entrez les éléments du tableau:");
for(int i=0;i<N;i++){ T[i+1]=sc.nextDouble(); S=S+T[i];}
double M=S/N;
System.out.println("La somme des éléments du tableau est:"+S+" et la
moyenne est:"+M);
}}
Sortie
Entrez la taille du tableau:
2
Entrez les éléments du tableau:
3
4
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
at SommeMoyenne.main(SommeMoyenne.java:8)
 La gestion des exceptions (4)
Le traitement des erreurs

Pour quelques langages, le traitement des erreurs n’est pas pleinement

intégré dans leurs mécanismes, ainsi :

Si les fonctions sont uniquement de la forme:

result = fct(arg): alors il faut tester sur les résultats qui pouvant être
d’une nature anormale.

Lorsque l’exécution se trouve dans un état anormal, le programme

peut s’interrompre brutalement en laissant l’environnement dans un
état incohérent.

Les systèmes modernes permettent de distinguer la « sortie »

normale des résultats d’une sortie distincte pour les erreurs.

En Java, par exemple, on peut afficher des résultats en utilisant

System.out et les erreurs en utilisant System.err .
 La gestion des exceptions (5)
Pour les méthodes Java, il y a deux possibilités pour « sortir » de
l’exécution:
 La voie normale, avec un éventuel retour de résultat.
 La voie exceptionnelle gérée par un mécanisme spécifique, qui est
le mécanisme des exceptions.
Ce mécanisme permet de définir par programme des conditions
d’erreurs.
Il est pleinement intégré à JVM pour récupérer des erreurs
d’exécution à savoir des divisions par zéro, des erreurs d’index
dans un tableau, ...
le mécanisme des exceptions en Java
Lorsqu’une condition d’erreur est détectée:
 On génère un objet particulier «une exception» contenant toutes
les informations nécessaires au diagnostic.
 Ensuite, l’objet est «jeté» dans la pile (dérive de Throwable).
 L’exécution sort de son déroulement normal et remonte la pile
jusqu’à l’obtention d’un code particulier chargé de récupérer
l’objet diagnostic.
 La gestion des exceptions (6)

Java est capable de générer tout type d’exceptions pour rendre

compte des incidents spécifiques à chaque situation.
Le programmeur pouvant ainsi définir ses propres exceptions, les
lancer et les récupérer.
En général, quand un programmeur écrit un code lançant une
exception, le compilateur s’assure qu’il y a vraiment un code
permettant de récupérer l’incident.
Si non, on remonte jusqu’au sommet de la pile et l’exception se traite
par un mécanisme par défaut. Ceci permet d’écrire un diagnostic dans
la sortie d’erreur standard.
 La gestion des exceptions (7)
Hiérarchie des exceptions
 La gestion des exceptions (8)
Error : décrit les erreurs internes ou le manque des ressources dans le
système d’exécution de Java (non récupérable).
Exception (récupérable): est séparée également en deux branches, les
exceptions dérivant de RuntimeException et les autres (Exceptions
contrôlées).
RuntimeException se produit toujours en raison d’une erreur de
programmation. Elle indique un problème d’exécution souvent
imprévisible, comme : un mauvais transtypage., un accès à un tableau
en dehors des limites.
Exemples:
NullPointerException : tenter d'accéder à un objet ou un tableau
de valeur nulle.
ArithmeticException : division entière par zéro.
ArrayIndexOutOfBoundsException : essai d’accès à un indice
n’existant pas dans le tableau.
ClassCastException : transtypage impossible à l’exécution.
 La gestion des exceptions (9)

Exceptions contrôlées : ce type d’exceptions a une cause externe à

votre programme, comme :
Lecture au-delà de la fin d’un fichier, accès un URL incorrecte,
recherche d’un objet classe en donnant un nom qui ne correspond à
aucune classe existante.
ClassNotFoundException: la demande de chargement
dynamique d’une classe est échouée à l’exécution.
InterruptedException: interruption d’un Thread.
java.io.FileNotFoundException: fichier non trouvé.
 java.net.MalformedURLException: erreur syntaxique de
description d’une URL.
 java.beans.PropertyVetoException: le refus de la modification
d’une propriété par une instance chargée de donner son avis.
 La gestion des exceptions (10)
Exemple 3 : Débordement de tableaux (dans main RuntimeException)
public class TestException1 {
public static void main (String[] args) {
int tabEnt[] = { 1, 2, 3, 4 };
tabEnt [4] = 0; // erreur et arrêt
// Exception de type java.lang.ArrayIndexOutOfBoundsException
// non contrôlée par le programme; erreur d’exécution
System.out.println ("Fin du main"); // le message n’apparaît pas
}
}

Exemple 4 : Division par zéro (dans main RuntimeException)

public class TestException2 {
public static void main( String[] args) {
int i = 3; int j = 0;
System.out.println("résultat = " + (i / j));
System.out.println ("Fin du main"); // le message n’apparaît pas
}}
 La gestion des exceptions (11)

 Structure de gestion d’exceptions : le bloc try… catch… finally

La syntaxe d’un bloc try… catch… finally :

try
{
... // Code pouvant entraîner une exception.
}
catch(Exception e)
{
... // Code prenant en compte une exception i.e. un objet de
// la classe ArithmeticException ou d’une classe dérivée.
}
finally
{
... // Le code d’un bloc try qui sera exécuter en dernier lieu.
}
 La gestion des exceptions (12)
 Structure de gestion d’exceptions : le bloc try… catch… finally (2)
Exemple 5: Débordement d’un tableaux (dans main RuntimeException)
public class TestException3 {
public static void main (String[] args) { Exemple de résultats d’exécution :
try {
int tabEnt[] = { 1, 2, 3, 4 }; Exception:
//Exception de type :java.lang.ArrayIndexOutOfBoundsException : 4
//ArrayIndexOutOfBoundsException Fin du main
// controlée par le programme
tabEnt [4] = 0; // l’exception se produit
//ici, et passe au catch
System.out.println ("Fin du try");
//non exécutée
} catch (Exception e) {
System.out.println ("Exception : " +e);
//Affichage du message précédent
}
System.out.println ("Fin du main");
// exécutée
}}
 La gestion des exceptions (13)

 Structure de gestion d’exceptions : le bloc try… catch… finally (3)

Exemple 6 : Division par zéro (dans main RuntimeException)

public class TestException 4{

public static void main(java.lang.String[] args) Exemple de résultats d’exécution :
{
int i = 3; Exception :
int j = 0; java.lang.ArithmeticException: / by
try { zero
System.out.println("résultat = " + (i / j)); Fin du main
}
catch (Exception e) {
System.out.println ("Exception : " + e);//Affichage du
//message
}
System.out.println ("Fin du main"); // exécutée
}
}
 La gestion des exceptions (14)
 Exception dans une méthode (pb)
public class TabException { public class TestTabException5 {
int[] tabEnt = new int[4]; public static void main (String[] args) {
public void initTableau () { try {
tabEnt[0] = 1; tabEnt[1] = 2; TabException t= new TabException();
tabEnt[2] = 3; tabEnt[3] = 4; t.initTableau();// l’exception se produit dans
tabEnt[4] = 5; // l’exception se //initTableau
//produit ici; non captée t.afficheableau(); // non exécutée
System.out.println("Fin de } catch (Exception e) {//exception captée ici
initTableau"); // non exécutée System.out.println ("Exception : " + e);
} // exécutée
public void afficheTableau () { }
for (int i=0; i < tabEnt.length; i++) { System.out.println ("Fin de main"); //exécutée
System.out.print (" " + tabEnt[i]); }
} }
System.out.println();
}
}

Résultat d’exécution :
Exception : java.lang.ArrayIndexOutOfBoundsException
Fin de main
 La gestion des exceptions (15)
 Exception dans une méthode (Solution)
class TabException1 { public class TestTabException1 {
int[] tabEnt = new int[4]; public static void main (String[] args) {
void initTableau () { TabException1 A = new TabException1();
try { A.initTableau(); // l’exception a été captée
tabEnt[0] = 1; tabEnt[1] = 2; A.afficheTableau(); // exécutée
tabEnt[2] = 3; tabEnt[3] = 4; System.out.println ("Fin de main");
tabEnt[4] = 5; // l’exception se produit ici // exécutée
} catch (Exception e) { // captée ici }
System.out.println ("Exception : " + e); }
//Exécutée
}
System.out.println("Fin de
initTableau"); // exécutée
} Exemples de résultats d’exécution :
void afficheTableau () { Exception :
for (int i=0; i < tabEnt.length; i++) { java.lang.ArrayIndexOutOfBoundsException
Fin de initTableau
System.out.print (" " + tabEnt[i]);
1234
} Fin de main
System.out.println();
}
}
 La gestion des exceptions (16)

Succession d’exécution des blocs d’exception

Lorsque le bloc try est exécuté:

1) Si aucune exception est lancée dans ce bloc:
 Le code du bloc catch n’est pas exécuté;
L’exécution continue avec le bloc suivant.

2) Si une exception est lancée:

 L’exécution du try est interrompue;
Le bloc du catch est exécuté;
L’exécution continue avec le bloc suivant de catch.
 La gestion des exceptions (17)
 Définition et lancement des exceptions utilisateurs (throws et throw)
1) Une classe d’exception est définit en héritant de la classe Exception se
trouvant déjà dans l’API java.
public class ErreurCoord extends Exception {
public String toString() {return " Erreur de construction"; }
// Retourne la description du problème
}
public class Point {
private int x,y;
public Point(int x, int y) throws ErreurCoord { 2)
if(x<0 || y<0) throw new ErreurCoord(); 3)
this.x = x; this.y = y;}
public void affiche() {
System.out.println("Je suis un point de coordonnées "+x+" "+y);
}}

2) On indique le type d’exceptions pouvant être rencontrées dans une

méthode de la classe Point par le mot clé throws.
3) On lance une exception par le mot clé throw new TypeException
(ErreurCoord()).
 La gestion des exceptions (18)
4) Ensuite pour récupérer une exception lancée par une méthode, on utilise
les instructions try et catch :
public class TestExcept {
public static void main(String args[]){
try{ //Instructions qui peuvent voir une exception déclenchée
Point a = new Point(1,4);
a.affiche();
a = new Point(-3,5);
a.affiche();
}
catch(ErreurCoord e)
{ //gestion de l’exception
System.err.println(e.toString());
}
}
}

Le mot-clé “Throw” permet de lancer une exception.

if (x<0 || y<0) throw new ErreurCoord();
Le mot-clé “Throws” s’utilise au niveau de la signature d’une méthode pour
préciser que celle-ci est susceptible de lancer une exception.
public Point(int x, int y) throws ErreurCoord {….}
 La gestion des exceptions (19)
Exemple complet
class EntNat{
private int n;
public EntNat(int m) throws ErrConst{ if (m<0) throw new ErrConst(m); n=m;}
public int getn() {return n;}
}
class ErrConst extends Exception {
private int errval;
public ErrConst(int valeur) {errval=valeur;}
public int getValeur() {return errval;}
}
public class TestExcept2 {
public static void main (String[] args){
try{
EntNat n1= new EntNat(20);
System.out.println("n1= "+n1.getn());
EntNat n2= new EntNat(-12);
System.out.println("n2 = "+n2.getn());
}catch (ErrConst e){
System.out.println("Erreur de construction avec valeur "+e.getValeur());
}
}}
 La gestion des exceptions (20)

Comment attraper une exception ?

Si une exception n’est pas attrapée dans le bloc où elle a été lancée,
elle est transmise au bloc de niveau supérieur (récursivement).
 Si une 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
(récursivement).
 Si une exception n’est jamais attrapée:
 Propagation jusqu’à la méthode main();
 Affichage des messages d’erreurs et la pile d’appels;
 Arrêt de l’exécution du programme;
 La gestion des exceptions (21)

 Gestion de plusieurs exceptions et transmission d’information

public class ErrCoord extends Exception { public class ErrDep extends Exception {
private int abs, ord; private int depx, depy;
public ErrCoord (int abs, int ord) { public ErrDep (int depx, int depy) {
this.abs = abs; this.depx = depx;
this.ord = ord; this.depy = depy;
} }
public int getAbs() public int getDepx() {
{ return abs;} return depx;}
public int getOrd() public int getDepy() {
{return ord;} return depy;}
} }
 La gestion des exceptions (22)
 Gestion de plusieurs exceptions et transmission d’information (suite)
public class Point { public class TestExcept3 {
private int x,y; public static void main(String args[]) {
public Point(int x, int y) throws ErrCoord { try{ //Instructions qui peuvent voir une
if(x<0 || y<0) throw new ErrCoord(x,y); //exception déclenchée
this.x = x; Point a = new Point(1,4);
this.y = y; a.affiche();
} a.deplace(-3,5);
public void deplace(int dx,int dy) throws ErrDep { a = new Point(-3,5);
if((x+dx<0) || (y+dy<0)) throw new a.affiche();
ErrDep(dx,dy); }catch (ErrCoord e){ //gestion de l’exception
x+=dx; System.out.println("Erreur de
y+=dy; construction"+e.getAbs()+" "+e.getOrd());
} System.exit(-1);
public void affiche() { }catch (ErrDep e)
System.out.println("Je suis un point de { System.out.println("Erreur de deplacement
coordonnées "+x+" "+y); "+e.getDepx()+" "+e.getDepy());
} System.exit(-1);
} } //l’exécution se poursuit ici s’il n’y a pas
//d’erreurs
System.out.println("Fin du programme");
}}
 La gestion des exceptions (23)
Quelques propriétés des exceptions
– Les exceptions sont des objets, donc elles contiennent:
Attributs « variables » particuliers,
Méthodes particulières,
Attributs et méthodes standards:
String getMessage()
void printStacktrace()
…
– Chaque bloc « try » est suivi d’un ou de plusieurs blocs de « catch »
permettant d'attraper les exceptions, dont le type est spécifié, et
d’exécuter le code spécifique.
– Un seul bloc de catch peut être exécuté, c’est le premier susceptible
d’attraper l’exception.
Chaque clause catch se déclare avec un argument de type Throwable
ou classe dérivée de Throwable
Lorsqu’une exception est lancée dans le bloc try, la première clause
dont le type d’argument correspond à celui de l’exception lancée est
appelée.
Remarque: l’ordre des blocs de « catch » est important.
 La gestion des exceptions (24)
Exemple
class Erreur extends Exception { }
class Erreur1 extends Erreur { }
class Erreur2 extends Erreur { }
class A{
public A (int n) throws Erreur{
try{ if (n==1) throw new Erreur1();
if (n==2) throw new Erreur2();
if (n==3) throw new Erreur();
}catch ( Erreur1 e){System.out.println("Exception Erreur1 dans A");}
catch (Erreur e){ System.out.println("Exception Erreur dans A"); throw(e); }
}}
public class TestExcep{
public static void main (String[] args) { int n;
for (n=1; n<=3; n++){
try {A a=new A(n);
}catch (Erreur1 e){System.out.println("Exception Erreur1 dans main");
}catch (Erreur2 e){System.out.println("Exception Erreur2 dans main");
}catch (Erreur e){System.out.println("Exception Erreur dans main");}
System.out.println("-----------------");}
System.out.println("fin de main");
}}
 Les Classes enveloppes
 Les classes enveloppes (wrappers en anglais) vont permettre de
manipuler les types primitifs comme des objets.
 Chacun des 8 types primitifs (boolean, byte, char, short, int, long,
float et double) possède une classe correspondante, appelée classe
enveloppe, qui généralise le type.
 Les 8 classes enveloppes sont:
 Boolean,
 Byte,
 Character,
 Short,
 Integer,
 Long,
 Float
 Double.
Ces classes enveloppes sont définies dans java.lang et peuvent donc
être utilisées sans importation.
 Les Classes enveloppes (2)
 Toutes les classes enveloppes disposent d’un constructeur recevant un
argument d’un type primitif :
Integer nObj = new Integer (12) ;// nObj contient la référence à un objet
// de type Integer encapsulant la valeur 12
Double xObj= new Double (5.25) ;// xObj contient la référence à un objet
// de type Double encapsulant la valeur 5.25
 Elles disposent toutes d’une méthode de la forme xxxValue (xxx
représentant le nom du type primitif) qui permet de retrouver la valeur
dans le type primitif correspondant :
int n = nObj.intValue() ; // n contient 12
double x = xObj.doubleValue() ; // x contient 5.25
Ces classes enveloppes sont finales (on ne peut pas créer de classes
dérivées) et inaltérables, puisque les valeurs qu’elles encapsulent ne sont
pas modifiables. Les six classes à caractère numérique dérivent de la
classe Number.