POO – Classes Abstraites et Interfaces

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.

Les classes abstraites

Concept des classes abstraites

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

Règles des classes abstraites

• Une classe comportant au moins une méthode abstraite est abstraite, même sans le mot-clé abstract.
• Une méthode abstraite doit être déclarée public pour être redéfinie dans une classe dérivée.
• Les arguments des méthodes abstraites doivent avoir un nom (exemple correct : public abstract void g(int n);).
• Une classe dérivée d'une classe abstraite n'est pas obligée de redéfinir toutes les méthodes abstraites. Elle reste abstraite tant que des méthodes abstraites ne sont pas implémentées.
• Une classe dérivée d'une classe non abstraite peut être déclarée abstraite.

Intérêt des classes abstraites

Les classes abstraites facilitent la conception orientée objet en permettant :

• De définir des méthodes et champs communs à toutes les classes dérivées (implémentation complète).
• De déclarer des méthodes abstraites dont on est certain qu'elles seront implémentées dans toutes les classes dérivées instanciables.

Exemple de classe abstraite

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.

Les interfaces

Concept 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.

• Une interface est plus riche qu'une simple classe abstraite.
• Une classe peut implémenter plusieurs interfaces.
• Les interfaces peuvent elles-mêmes hériter d'autres interfaces.
• Une classe dérivée peut implémenter une ou plusieurs interfaces, y compris celles déjà implémentées par sa superclasse.
• On peut utiliser des variables de type interface.

Syntaxe

Définition d’une interface

public interface I {
    void f(int n); // public et abstract sont implicites
    void g();      // public et abstract sont implicites
}

Implémentation d’une interface

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
}

Exemple d’interface et d’implémentation

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 :

• Je suis un entier de valeur 25
• Je suis un flottant de valeur 1.25

Interface et constantes

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.

Interface et dérivations

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;
}

Conflits de noms entre interfaces

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
}

Glossaire des termes clés

• Classe abstraite : Classe qui ne peut pas être instanciée et qui peut contenir des méthodes abstraites.
• Méthode abstraite : Méthode déclarée sans corps, à implémenter dans une classe dérivée.
• Interface : Ensemble de méthodes abstraites et de constantes, sans implémentation, pouvant être implémentée par plusieurs classes.
• Implémentation : Action pour une classe de fournir le code des méthodes définies dans une interface.
• Héritage : Mécanisme permettant à une classe de dériver d'une autre, héritant de ses méthodes et attributs.
• Polymorphisme : Capacité d'un objet à prendre plusieurs formes, notamment via des classes abstraites ou interfaces.
• Constante symbolique : Valeur fixe définie dans une interface, accessible à toutes les classes qui l'implémentent.

Points clés à retenir

• Une classe abstraite ne peut pas être instanciée directement, elle sert de base aux classes dérivées.
• Les méthodes abstraites dans une classe abstraite doivent être redéfinies dans les classes concrètes.
• Une interface ne contient que des méthodes abstraites et des constantes, sans implémentation.
• Une classe peut implémenter plusieurs interfaces, contrairement à l'héritage simple des classes abstraites.
• Les interfaces peuvent hériter d'autres interfaces, permettant une hiérarchie d'abstractions.
• Les conflits de méthodes entre interfaces doivent être résolus lors de l'implémentation dans une classe.