POO – Classes Abstraites et Interfaces
POO – Classes Abstraites et Interfaces
Programming (Object-Oriented Programming) · course
Voir tous les documents en programmationTous les travaux pratiques (TP) en programmation
Fiche de révisionFiche de cours
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document traite des classes abstraites et des interfaces en programmation orientée objet (POO). Il s'adresse aux étudiants et développeurs souhaitant comprendre ces concepts essentiels pour structurer et organiser leur code de manière efficace.
Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert uniquement de classe de base pour d'autres classes dérivées. Elle peut contenir des méthodes et des champs classiques, ainsi que des méthodes dites « abstraites » qui ne fournissent que la signature et le type de retour, sans implémentation.
Syntaxe :
abstract class A {
public void f() { ... } // méthode définie dans A
public abstract void g(int n); // méthode abstraite, non définie dans A
}
On peut déclarer une référence de type A ou dérivé :
A a;
// a = new A(); // Erreur : instanciation impossible d'une classe abstraite
Si une classe B dérive de A et définit toutes les méthodes abstraites, on peut alors instancier B :
a = new B(); // Possible car B n'est pas abstraite
abstract.public pour être redéfinie dans une classe dérivée.public abstract void g(int n);).Les classes abstraites facilitent la conception orientée objet en permettant :
abstract class Graphique {
private int x, y;
Graphique(int x, int y) {
this.x = x;
this.y = y;
}
void affiche() {
System.out.println("Le centre de l’objet se trouve dans : " + x + " et " + y);
}
public abstract double surface(); // méthode abstraite
}
// Classe dérivée 1
class Cercle extends Graphique {
private double rayon = 1;
Cercle(int x, int y, double r) {
super(x, y);
rayon = r;
}
void affiche() {
System.out.println("C’est un cercle de rayon " + rayon);
super.affiche();
}
double surface() {
return (rayon * rayon * 3.14);
}
}
// Classe dérivée 2
class Rectangle extends Graphique {
private int largeur, longueur;
Rectangle(int x, int y, int l1, int l2) {
super(x, y);
longueur = l1;
largeur = l2;
}
double surface() {
return (longueur * largeur);
}
}
// Classe de test
class TestPoly2 {
public static void main(String[] args) {
Graphique[] tab = new Graphique[6];
// tab[0] = new Graphique(3, 2); // Erreur : instanciation impossible d'une classe abstraite
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();
}
}
}
Remarque : Une classe abstraite peut ne contenir que des méthodes abstraites et aucun champ. Dans ce cas, on parle plutôt d'interface.
Une interface est une classe abstraite sans méthodes ni champs (sauf des constantes). Elle définit uniquement les signatures des méthodes et des constantes symboliques. Contrairement aux classes abstraites, une classe peut implémenter plusieurs interfaces.
public interface I {
void f(int n); // public et abstract sont implicites
void g(); // public et abstract sont implicites
}
Pour qu'une classe implémente une interface, on utilise le mot-clé implements :
public interface I1 { ... }
public interface I2 { ... }
class A implements I1, I2 {
// A doit définir toutes les méthodes de I1 et I2
}
interface Affichable {
void affiche();
}
class Entier implements Affichable {
private int val;
public Entier(int n) {
val = n;
}
public void affiche() {
System.out.println("Je suis un entier de valeur " + val);
}
}
class Flottant implements Affichable {
private float val;
public Flottant(float n) {
val = n;
}
public void affiche() {
System.out.println("Je suis un flottant de valeur " + val);
}
}
public class TestInterface {
public static void main(String[] args) {
Affichable[] tab = new Affichable[2];
tab[0] = new Entier(25);
tab[1] = new Flottant(1.25f);
tab[0].affiche();
tab[1].affiche();
}
}
Résultat de l'exécution :
Une interface peut contenir des constantes symboliques accessibles à toutes les classes qui l'implémentent :
public interface I {
void f(int n);
void g();
static final int max = 100;
}
Les constantes sont toujours static et final par défaut.
L'interface est indépendante de l'héritage classique. Une classe dérivée peut implémenter une ou plusieurs interfaces en plus de son héritage.
interface I1 { ... }
interface I2 { ... }
class A implements I1 { ... }
class B extends A implements I1, I2 { ... }
Une interface peut hériter d'une autre interface avec le mot-clé extends :
interface I1 {
void f(int n);
static final int max = 100;
}
interface I2 extends I1 {
void g(int n);
static final int min = 10;
}
Cette définition est équivalente à :
interface I2 {
void g(int n);
static final int min = 10;
void f(int n);
static final int max = 100;
}
Lorsqu'une classe implémente plusieurs interfaces ayant des méthodes portant le même nom mais avec des signatures différentes, des conflits peuvent survenir.
interface I1 {
void f(int n);
void g();
}
interface I2 {
void f(float x);
void g();
}
class A implements I1, I2 {
// A doit implémenter la méthode g() unique pour les deux interfaces
}
Si les méthodes ont des signatures incompatibles, par exemple :
interface I1 {
void g();
}
interface I2 {
int g();
}
class A implements I1, I2 {
// Erreur : void g() et int g() ne peuvent pas coexister dans la même classe
}