Plan du Cours

Chapitre 1 : Introduction générale

Chapitre 2 : Les classes et les objets
Chapitre 3 : Les tableaux et les chaînes de caractères
Chapitre 4 : L'héritage et le polymorphisme
Chapitre 5 : Les classes abstraites et les interfaces
Chapitre 6 : Les exceptions

Cours de Programmation Orientée Objet 1

 Chapitre 5 :

Les classes abstraites et les

interfaces
1. Idée de base d’une classe abstraite
Une classe abstraite ne peut pas être instanciée

Utilité : définir un type abstrait qui regroupe des caractéristiques

communes à d'autres types. Elle sert :
Comme racine pour un sous-arbre d’héritage :
Dans lequel les sous-classes apporteront leurs
particularités
Favorise le polymorphisme

Au partage de certaines descriptions :

Variables d’instances (ou de classes) communes
Méthodes définissant un comportement par défaut
Cours de Programmation Orientée Objet 3
Une méthode d'une classe abstraite peut être abstraite(pas de
code)

Exemple : Forme3D: parallépipède, cylindre,…

Une classe abstraite : en cas de présence d’au moins une

méthode abstraite ou par choix pour interdire la création d’objet

Cours de Programmation Orientée Objet 4

2. Définition d’une classe abstraite en JAVA
Une classe abstraite est déclarée avec le mot clé abstract

Exemple : abstract class Document {

….}
Une classe abstraite ne peut jamais être instancier par l'opérateur
new
On peut déclarer des références de type classe abstraite
La méthode abstraite est aussi déclarée avec le mot clé abstract.
Exemple : abstract class ObjetGraphique
{abstract float surface ();
…}
Cours de Programmation Orientée Objet 5
Si une classe comporte une méthode abstraite elle doit être
déclarée abstraite

Une classe abstraite peut ne pas comporter de méthodes

abstraites

Toute classe concrète dérivée à partir d'une classe abstraite doit

donner un code aux méthodes abstraites héritées, si non elle doit
être déclarée abstraite (l'abstraction continue)

On ne peut pas combiner les modificateurs abstract et final

Cours de Programmation Orientée Objet 6

3. Les interfaces
Une interface est une forme particulière de classe qui comporte
uniquement des propriétés abstraites

Le concept d'interface est proposé par le langage JAVA pour

résoudre le problème de l'héritage multiple

Comparée à une classe, une interface correspond à un type

comportant uniquement des méthodes abstraites et des
constantes statiques (on a pas à préciser les modificateurs
abstract, final et static)

Les interfaces ne sont pas instanciables

Cours de Programmation Orientée Objet 7

L’utilisation des interfaces permet de :

Définir (regrouper) des propriétés qui peuvent être transférées

aux classes par un mécanisme particulier (l’implémentation)

Garantir aux ″clients″ d’une classe que ses instances peuvent

assurer certains services, ou qu’elles possèdent certaines
propriétés

Faire du polymorphisme avec des objets dont les classes

n’appartiennent pas à la même hiérarchie d’héritage
(l’interface joue le rôle de la classe mère)

Cours de Programmation Orientée Objet 8

 Une interface est définie d'une manière similaire à une classe
mais en utilisant le mot clé interface

La syntaxe de déclaration d'une interface est la suivante :

interface NomInterface { … }

Exemples :
interface Edition
{void editer();}

interface Affichage
{int MIN = 0;
int MAX=100;
void afficher();
} Cours de Programmation Orientée Objet 9
 4. Interfaces et héritage
Une interface peut hériter d'une ou de plusieurs autres interfaces.
Il s'agit d'une extension de propriétés sous forme de méthodes
abstraites et de constantes statiques.
Exemple :
interface InputStream // propriété d'accepter des caractères
{public int read(); }

interface OutputStream // propriété de fournir des caractères

{public void write(int n); }

interface DataStream extends InputStream, OutputStream

{public double readDouble();
public void writeDouble(double x);
Cours de Programmation Orientée Objet 10
}
5.Implémentation d’une interface

Une classe peut implémenter plusieurs interfaces, c'est à dire

avoir les même caractéristiques (ou propriétés) définies au
niveau de ces interfaces.

Réciproquement, une même interface peut être implémentée par

plusieurs classes

L'implémentation est une forme d'héritage multiple

Il est possible de combiner, lors de la définition d'une classe,

l'héritage et l'implémentation d'interfaces
Cours de Programmation Orientée Objet 11
Exemple :

interface Printable // propriété d'être imprimé

{public void print(); }

class MonStream implements DataStream, Printable

{
public void print() { …}
public int read() { …}
public void write(int n) { …}
public double readDouble(){ …}
public void writeDouble(double x) { …}
}

Cours de Programmation Orientée Objet 12

6.Les références de type interface

Il est possible de déclarer des références de type interface

afin de désigner des objets qui implémentent l'interface en
question. Les objets désignés peuvent être de types différents

L'opérateur instanceof peut être utilisé pour savoir si un objet

implémente une interface donnée

Cours de Programmation Orientée Objet 13

7.Applications : Le tri générique
L’exemple donné ci-après représente un tri générique. La
méthode tri() de la classe TriGénérique permet d’ordonner un
tableau d’objets de type quelconque. La seule propriété exigée
est que les éléments soient comparables par la méthode
inférieur (Object x, Object y) qui rend vrai si x est inférieur (en
un certain sens) à y.

Pour cela on utilise une interface Comparer qui définit le profil

de la procédure inférieur. La méthode tri() reçoit en paramètre
un objet comparateur op qui implémente cette interface.

Cours de Programmation Orientée Objet 14

interface Comparer //classe interface non instanciable
{ public boolean inférieur(Object x, Object y); }

class TriGénérique
{ public static void tri (Object [ ] T, Comparer op) //op une ref
{ for (int i=0; i<T.length-1; i++)
for (int j=i+1; j< T.length; j++)
if (op.inférieur (T[j],T[i]))
{
Object x=T[i];
T[i]=T[j];
T[j]=x;
}
}
}
Cours de Programmation Orientée Objet 15
Pour trier n’importe quel type d’objet selon n’importe quel
critère, il suffit d’implémenter l’interface Comparer au moyen
d’une classe convenable et de passer en paramètre du tri une
instance de cette classe.

On se propose d’utiliser la classe TriGénérique pour ordonner

des personnes. Une personne est caractérisée par un nom, un
âge et un poids.

Cours de Programmation Orientée Objet 16

class Personne
{
public String nom;
public int age, poids;
public Personne(String n, int a, int p)
{ nom=n; age=a; poids=p; }
}
Soit la population suivante :
Personne [] peuple = new Personne[4];
peuple[0] = new Personne("toto", 25, 80);
peuple[1] = new Personne("tutu", 53, 65);
peuple[2] = new Personne("tata", 15, 47);
peuple[3] = new Personne("jojo", 12, 30);

Cours de Programmation Orientée Objet 17

Questions :

Définir la classe ComparerAge qui implémente l’interface

Comparer

Définir la classe ComparerPoids qui implémente l’interface

Comparer

Définir la classe TestTriGénérique pour trier la population

sus-indiquée selon leurs ages puis selon leurs poids
(afficher les noms des personnes à l’issu de chaque tri)

Cours de Programmation Orientée Objet 18

 Solution :

class ComparerAge implements Comparer

{
public boolean inférieur(Object x, Object y)
{return((Personne)x).age<((Personne)y).age;}
}

class ComparerPoids implements Comparer

{
public boolean inférieur(Object x, Object y)
{return((Personne)x).poids<((Personne) y).poids;}
}
Cours de Programmation Orientée Objet 19
class TestTriGénérique
{ public static void main (String [] args)
{ Personne [] peuple = new Personne[4];
peuple[0] = new Personne("toto", 25, 80);
peuple[1] = new Personne("tutu", 53, 65);
peuple[2] = new Personne("tata", 15, 47);
peuple[3] = new Personne("jojo", 12, 30);

TriGénérique.tri(peuple, new ComparerAge() );

System.out.println("TRI SELON AGE");
for (int i=0; i<4; i++) //affich. Ordonné du tab
System.out.println(peuple[i].nom);
TriGénérique.tri(peuple, new ComparerPoids());
System.out.println("TRI SELON POIDS");
for (int i=0; i<4; i++)
System.out.println(peuple[i].nom);
} Cours de Programmation Orientée Objet 20
}
 Plan du Cours
Chapitre 1 : Introduction générale
Chapitre 2 : Les classes et les objets
Chapitre 3 : Les tableaux et les chaînes de caractères
Chapitre 4 : L'héritage et le polymorphisme
Chapitre 5 : Les classes abstraites et les interfaces
Chapitre 6 : Les exceptions

Cours de Programmation Orientée Objet 21

Chapitre 6:

Les exceptions
1.Problématique
Avec une programmation classique, une grande partie du code
est réservée à la détection et à la gestion des erreurs ou au
traitement de cas exceptionnels (division par zéro, impossibilité
d'ouvrir un fichier, mauvaise saisie de données,…)

Ces portions de code sont toujours fortement imbriquées dans le

reste du code et le programmeur a souvent des difficultés à
déterminer ce qu'il doit faire dans tel ou tel cas

Cours de Programmation Orientée Objet 23

Plusieurs inconvénients sont alors constatés :
La lisibilité du code diminue

Certains cas exceptionnels sont oubliés ou mal traités

Certaines erreurs d'exécution causent des résultats erronés ou

provoquent des interruptions non avisées

Solution : séparer les instructions qui traitent les exceptions du

reste du code

Cours de Programmation Orientée Objet 24

2.Principe de la gestion des exceptions en JAVA
Définir chaque type d'exception sous forme d'une classe (en
respectant une hiérarchie entre les classes)
Chaque méthode pouvant rencontrer un ou plusieurs types
d'exception, doit annoncer, au niveau de son entête, la ou les
classes d'exception appropriées
Lors de la rencontre d'un cas d'exception, la méthode en
question lance (crée et diffuse) un objet de la classe d'exception
appropriée
Chaque bloc d'instructions comportant l'appel d'une méthode
susceptible de lancer un objet exception doit être surveillé
Chaque bloc surveillé est suivi par des blocs qui captent et
traitent les objets exception à raison d'un bloc de traitement par
type d'exception attendue
Cours de Programmation Orientée Objet 25
3.Classes d’exception

Certaines exceptions sont prédéfinies par JAVA selon une

hiérarchie de classes. Cependant, le programmeur peut définir
ses propres classes d'exception. Toute classe définissant une
exception doit être dérivée de la classe java.lang.Exception

Il existe des exceptions d'erreurs prédéfinies par JAVA. Leurs

classes sont dérivées de la classe java.lang.Error. Ces
exceptions concernent des erreurs internes de la Machine
Virtuelle Java : il est fortement déconseillé de les intercepter

Cours de Programmation Orientée Objet 26

 Object

Throwable

Error Exception

LinkageError NoSuchMethodException IOException

ThreadDeath IllegalAccessException

VirtualMachineError RuntimeException

ArithmeticException IndexOutOfBoundsException

NullPointerException

Cours de Programmation Orientée Objet 27

4.Lancement d’une exception

Une exception est déclenchée avec le mot clé throw qui lance un
objet de la classe exception indiquée après l'avoir crée par new
Exemple :
class MonException extends Exception
{ }
class TestException
{
…
if ( erreurDétectée ) throw new MonException();
…
}

Cours de Programmation Orientée Objet 28

5.Propagation d’une exception
Toute méthode qui peut propager des exceptions doit contenir
dans la déclaration de son entête, le mot clé throws suivi des
noms de ces exceptions
Exemple :
public class Temps
{private int heures, minutes, secondes;
public Temps (int h, int m, int s)
{heures = h; minutes = m; secondes = s; }
public static void main(String args[])
{int h,m,s;
scanner x = new scanner (System.in);
h=x.nextInt(); m=x.nextInt(); s=x.nextInt();
Temps t = new Temps (h, m, s); }
} Cours de Programmation Orientée Objet 29
Soit la classe d’exception suivante :
class TempsException extends Exception
{
public String message;
public TempsException ( String m)
{ message = m;}
}

Modification du constructeur de la classe Temps de manière à ce

qu'il lance et propage une exception de type TempsException si
les heures, les minutes ou les secondes rendent le temps valide :

Cours de Programmation Orientée Objet 30

public Temps (int h, int m, int s) throws TempsException
{if (h>= 0 && h<=23)
heures = h;
else
throw new TempsException(″Heures erronées″);
if (m>= 0 && m<=59)
minutes = m;
else
throw new TempsException(″Minutes erronées″);
if (s>= 0 && s<=59)
secondes = s;
else
throw new TempsException(″Secondes erronées″);
}

Cours de Programmation Orientée Objet 31

6. Capture et traitement d’une exception
La gestion d'une exception (ou d'un objet exception déjà
lancé) nécessite :
La surveillance des instructions susceptibles de lancer des
objets exception en les mettant dans un bloc try{ }
La capture de chaque objet exception lancé dans un bloc
catch { } approprié au type de l'exception

Exemple :
Modification du code de la méthode main() de manière à ce
que l'exception TempsException soit traitée en affichant le
message suivant : "Temps Invalide" suivi par la raison de
l’erreur

Cours de Programmation Orientée Objet 32

public static void main(String args[])
{ int h, m, s;
scanner x;
try
{h=x.nextInt();
m=x.nextInt();
s=x.nextInt();
Temps t = new Temps(h,m,s);
}
catch (TempsException e)
{ System.out.println("Temps Invalide : " +
+e.message);
}
}

Cours de Programmation Orientée Objet 33

Il est possible de capturer dans un seul bloc catch plusieurs
exceptions, si la classe d'exception indiquée est une classe mère
de toutes les exceptions concernées
Exemple :
try { … }
catch (Exception e) //capturer tout type d'exception
{ … }

Les blocs catch{ } doivent être présentés selon la hiérarchie des

classes d'exception en question : du type élémentaire vers le type
général (sinon il y aura une erreur de compilation)

Cours de Programmation Orientée Objet 34

Exemple :

try { … }
catch (IOException e)
//capturer toutes les exceptions I/O
{…}
catch ( PasDeSolution e )
{…}

Cours de Programmation Orientée Objet 35

Une méthode qui relance un objet exception, doit déclarer la
propagation de cet objet dans son entête

Exemple :
void methode() throws IOException
{
try
{ … }
catch ( IOException e )
{ … throw e; }
}

Cours de Programmation Orientée Objet 36

Il est possible de définir un bloc finally { } qui, contrairement au
catch, n'est pas obligatoire, et qui permet de spécifier du code qui
sera exécuté dans tous les cas, qu'une exception survienne ou
pas.

Ce code sera exécuté même si une instruction return est

exécutée dans le catch ou le try !

Cours de Programmation Orientée Objet 37

Exemple :

try {
// Ouvrir un fichier
// Lire et écrire des données
}
catch ( IOException e )
{
System.out.println(e) ;
}
finally
{
// Fermeture du fichier
}

Cours de Programmation Orientée Objet 38