Chapitre 6 :
Classes abstraites et interfaces
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 164
Classes abstraites
Définition :
Une classe abstraite est une classe à laquelle on ne peut pas
appliquer une opération d’instanciation :
Soit une classe A déclarée abstraite
Intérêt :
Permettre de définir un type abstrait, dont son instanciation
n’est pas intéressante, mais qui regroupe des caractéristiques
communes à d'autres types.
Déclaration : abstract class Nom_Classe { … }
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 165
Classes abstraites
Caractéristiques :
Elle peut contenir la même chose qu'une classe normale;
Ses enfants pourront utiliser tous ses éléments déclarés
(attributs et méthodes déclarés public ou protected).
Cependant, elle peut contenir des méthodes abstraites :
Elles n’ont pas de corps;
Elles ne sont pas exécutables
abstract type Nom_Méthode (…) ;
Exemple:
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 166
Classes abstraites
Conséquences :
Une classe abstraite peut ne pas comporter de méthodes
abstraites.
Si une classe comporte une méthode abstraite, alors elle doit
être déclarée abstraite.
Une classe abstraite peut hériter d’une autre classe abstraite
sans implémentation des méthodes héritées.
Toute classe concrète dérivée à partir d'une classe abstraite
doit implémenter toutes les méthodes qui sont encore
abstraites (sinon l'abstraction doit continuer). Cette
implémentation obéit aux règles de redéfinition de méthodes
Une classe abstraite ne peut pas être privée ou final
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 167
Classes abstraites
Exemple1:
On suppose que chaque forme géométrique est caractérisée
par deux méthodes sans paramètres qui calculent et
retournent le périmètre et la surface respectivement.
Un cercle est une forme géométrique caractérisée par un
rayon (de type réel) et un constructeur paramétré.
Un rectangle est une forme géométrique caractérisée par une
longueur (type réel), une largeur (type réel) et un constructeur
à deux paramètres.
Définir les classes Forme, Cercle et Rectangle.
Définir dans un programme principal permettant de créer un
tableau comportant un objet de chaque forme, puis afficher
son type, sa surface et son périmètre.
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 168
Classes abstraites
abstract class Forme {
public abstract float Perimetre();
public abstract float Surface();
}
class Cercle extends Forme {
private float Rayon;
public Cercle(float r) {
Rayon = r; }
public float Perimetre() {
return (float) (2 * Math.PI * Rayon); }
public float Surface() {
return (float)(Math.PI * Math.pow(Rayon,2)); }
}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 169
Classes abstraites
class Rectangle extends Forme {
private float Longeur, Largeur;
public Rectangle(float lo, float la) {
Longeur = lo; Largeur = la;
}
public float Perimetre() {
return (Longeur+Largeur)*2;
}
public float Surface() {
return Longeur*Largeur;
}
}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 170
Classes abstraites
public class pp {
public static void main(String[] args) {
Forme[ ] t = new Forme[2];
t[0] = new Cercle(3.5f);
t[1] = new Rectangle(15.7f, 9.8f);
for (int i = 0; i < 2; i++) {
if (t[i] instanceof Cercle)
SOP("L'objet est un cercle:");
else
SOP("L'objet est un rectangle:");
SOP("\tSon perimetre est: " + t[i].Perimetre());
SOP("\tSa surface est: " + t[i].Surface());
}
}
} Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 171
Classes abstraites
Exemple2 :
Définir les classes nécessaires pour l’exécution de ce programme
public class PP{
public static void main(String args[]) {
Figure[] T= new Figure[4];
T[0]= new Cercle(3.5); T[1]= new Rectangle(5, 2.8);
T[2]= new Carré(4.2); T[3]= ((Cercle)T[0]).agrandir(2.0);
for (int i=0; i< T.length; i++) T[i].affiche();
SOP(T[0].comparer(T[1]));//Formes différentes
SOP(T[0].comparer(T[3]));//Deux cercles
} }
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 172
Classes abstraites
abstract class Figure{
public abstract void affiche();
public abstract String comparer(Figure f);}
class Cercle extends Figure{
private double rayon;
public Cercle(double r) {rayon=r;}
public Cercle agrandir(double d){ return new Cercle(rayon+d);}
public void affiche(){ System.out.println("Cercle=("+rayon+")");}
public String comparer(Figure f){
if(f instanceof Cercle)
return "Deux cercles";
else
return "Formes différentes"; }
}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 173
Classes abstraites
class Rectangle extends Figure {
private double log, lag;
public Rectangle(double lo,double la){
log=lo;lag =la;}
public void affiche(){
SOP("Rectangle=("+log+","+lag+")");}
public String comparer(Figure f){
if(f instanceof Rectangle)
return "Deux rectangles";
else
return "Formes différentes";
}
}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 174
Classes abstraites
class Carre extends Figure
{
private double cote;
public Carré(double c) {cote=c;}
public void affiche(){
System.out.println("Carré=("+cote+")");}
public String comparer(Figure f){
if(f instanceof Carre)
return "Deux carrés";
else
return "Formes différentes";
}
}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 175
Interfaces
Définition
Une interface est une forme particulière de classe qui
comporte uniquement des propriétés abstraites.
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.
Déclaration
public interface Nom_Interface { … }
Exemple:
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 176
Interfaces
Intérêt
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).
Résoudre le problème de l'héritage multiple, interdit en Java,
par le concept d'interface.
Utilisation
Une classe utilise une interface en implémentant toutes ses
méthodes.
On dit que la classe X implémente l’interface I
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 177
Interfaces
Caractéristiques
Une interface et ses méthodes ne peuvent être que public ou
default
Une interface peut hériter d'une ou de plusieurs autres
interfaces.
Une classe peut implémenter plusieurs interfaces et une même
interface peut être implémentée par plusieurs classes.
L'implémentation est une forme d'héritage multiple.
Lors de la définition d'une classe, il est possible de combiner
l'héritage et l'implémentation d'interfaces (dans cet ordre).
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.
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 178
Interfaces
Exemple
Définir une interface Affichable comportant une méthode
void afficher().
Définir la classe Point qui implémente l'interface Affichable.
Définir les classes Cercle et Rectangle qui héritent de Forme
et qui implémentent Affichable.
Définir un programme principal permettant de créer un
tableau comportant un cercle et un rectangle, puis afficher
son type, sa surface et son périmètre.
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 179
Interfaces
interface Affichable {
void Afficher();
}
class Point implements Affichable {
private float x, y;
public Point(float a, float b) {
x = a; y = b; }
public void Afficher(){
System.out.println("Je suis un point"); }
}
abstract class Forme {
public abstract float Perimetre();
public abstract float Surface();
}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 180
Interfaces
class Cercle extends Forme implements Affichable {
private double Rayon;
public Cercle(double r) {
Rayon = r;
}
public void Afficher() {
System.out.println("Je suis un cercle");
}
public float Perimetre() {
return (float) (2 * Math.PI * Rayon);
}
public float Surface() {
return (float) (Math.PI * Math.pow(Rayon, 2));
}
} Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 181
Interfaces
class Rectangle extends Forme implements Affichable {
private float Longeur, Largeur;
public Rectangle(float lo, float la) {
Longeur = lo;
Largeur = la; }
public void Afficher() {
System.out.println("Je suis un rectangle");
}
public float Perimetre() {
return (Longeur + Largeur) * 2;
}
public float Surface() {
return Longeur * Largeur;
}
} Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 182
Interfaces
public class pp {
public static void main(String[] args) {
Forme[] t = new Forme[2];
t[0] = new Cercle(3.5f);
t[1] = new Rectangle(15.7f, 9.8f);
for (int i = 0; i < t.length; i++) {
if (t[i] instanceof Cercle) {
((Cercle) t[i]).Afficher();
else
((Rectangle) t[i]).Afficher();
SOP("perimetre:" + t[i].Perimetre());
SOP("surface:" + t[i].Surface());
}
}}
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 183
Interfaces
Exemple2
Définir un programme principal permettant de créer un
tableau comportant un point, un cercle et un rectangle, puis
afficher son type, sa surface et son périmètre (si possible).
Solution
t doit être de type Affichable à la place de Forme
public class pp2 {
public static void main(String[] args) {
Affichable[] t = new Affichable[3];
t[0] = new Point(1.7f, 3.8f);
t[1] = new Cercle(3.5f);
t[2] = new Rectangle(15.7f, 9.8f);
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 184
Interfaces
L’appel de Afficher sera sans casting,
Les appels de Périmètre() et Surface() seront avec casting.
for (int i = 0; i < t.length; i++) {
t[i].Afficher();
if (t[i] instanceof Cercle) {
SOP("perimetre:" + ((Cercle)t[i]).Perimetre());
SOP("surface:" + ((Cercle)t[i]).Surface());
}
if (t[i] instanceof Rectangle) {
SOP("perimetre:" + ((Rectangle)t[i]).Perimetre());
SOP("surface:" + ((Rectangle)t[i]).Surface());
}
} } }
Programmation Orientée Objets (Java) – T. BEN SAID 1IDSD – ENETCOM 185
