Abstraction et utilisation des interfaces

Ce document traite de l'abstraction en programmation orientée objet, en se concentrant sur les classes abstraites et les interfaces. Il s'adresse aux étudiants en informatique ou en génie logiciel souhaitant comprendre ces concepts fondamentaux pour concevoir des applications modulaires et évolutives.

Les classes abstraites

Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert uniquement de base pour d'autres classes qui en héritent. Ce mécanisme facilite la conception orientée objet en permettant de définir des fonctionnalités communes sous forme de méthodes abstraites, dont l'implémentation sera assurée dans les classes dérivées.

Dans une classe abstraite, on trouve :

• Des méthodes et des champs classiques, hérités par toutes les classes descendantes.
• Des méthodes abstraites, qui ne contiennent que la signature (nom, paramètres, type de retour) sans code source. Ces méthodes doivent être obligatoirement redéfinies dans les sous-classes.

Le mot-clé abstract est utilisé pour déclarer une classe ou une méthode abstraite. Une classe possédant au moins une méthode abstraite doit elle-même être déclarée abstraite.

Remarques importantes :

• Une classe abstraite peut ne pas contenir de méthode abstraite.
• Une méthode abstraite ne doit pas contenir de code source.
• Une sous-classe non abstraite doit impérativement implémenter toutes les méthodes abstraites héritées, sinon une erreur de compilation est générée.
• Le mot-clé abstract ne peut pas être utilisé avec des attributs.

Syntaxe de déclaration

public abstract class NomClasseAbstraite {
    ...
    public abstract typederetour NomMethodeAbstraite(type param1, type param2, ...);
}

public class NomClasseFille extends NomClasseAbstraite {
    public typederetour NomMethodeAbstraite(type param1, type param2, ...) {
        // implémentation de la méthode abstraite
    }
}

Exemple

public abstract class Etudiant {
    ...
    public abstract double calculMoyenne();  // méthode abstraite sans code
    ...
}

public class Etudiant1et2 extends Etudiant {
    ...
    public double calculMoyenne() {
        return (note1 + note2) / 2;
    }
}

public class Etudiant3 extends Etudiant {
    ...
    public double calculMoyenne() {
        return ((note1 * 2) + notePFE) / 3;
    }
}

Les interfaces

Les interfaces permettent d'appliquer un mécanisme d'abstraction similaire aux classes abstraites, tout en autorisant l'héritage multiple. Une interface est un ensemble de constantes et de déclarations de méthodes, sans implémentation. Toute classe qui implémente une interface doit fournir le code de toutes les méthodes déclarées dans cette interface.

Une interface est déclarée avec le mot-clé interface et est implicitement abstraite. Une classe intègre une interface avec le mot-clé implements. Une classe peut implémenter plusieurs interfaces.

Syntaxe de déclaration

[public] interface nomInterface [extends nomInterface1, nomInterface2, ...] {
    // méthodes et constantes statiques
}

[Modificateurs] class nomClasse [extends superClasse]
[implements nomInterface1, nomInterface2, ...] {
    // méthodes et champs
}

Exemple

public interface InterfaceEtudiant {
    public void AfficherEtudiant();
    public void saisir();
    public double calculmoyenne();
    public void afficherMoyenne();
}

public class Etudiant implements InterfaceEtudiant {
    ...
    // implémentation de toutes les méthodes de l'interface
}

Remarques importantes sur les interfaces

• Une classe qui implémente une interface doit définir toutes les méthodes de cette interface, sinon une erreur est générée.
• Si la classe est abstraite, elle peut ne pas implémenter certaines méthodes, qui devront alors être définies dans ses sous-classes.
• Toutes les méthodes d'une interface sont implicitement abstraites, même si le mot-clé abstract n'est pas utilisé.
• Les attributs dans une interface sont toujours des constantes statiques (modificateurs static et final implicites).
• Une interface peut être publique ou d'accès package. Si elle est publique, ses méthodes sont implicitement publiques. Sinon, elles ont un accès package, accessible uniquement aux classes du même package.

Glossaire des termes clés

• Classe abstraite : classe qui ne peut pas être instanciée et qui peut contenir des méthodes abstraites à implémenter dans les sous-classes.
• Méthode abstraite : méthode déclarée sans corps, dont l'implémentation est obligatoire dans les classes dérivées non abstraites.
• Interface : ensemble de méthodes abstraites et de constantes, permettant l'héritage multiple et l'abstraction.
• Héritage multiple : capacité d'une classe à hériter de plusieurs interfaces simultanément.
• Modificateur abstract : mot-clé indiquant qu'une classe ou une méthode est abstraite.
• Implements : mot-clé utilisé par une classe pour indiquer qu'elle implémente une ou plusieurs interfaces.
• Constante : attribut statique et final défini dans une interface.
• Erreur de compilation : message généré lorsque les méthodes abstraites ne sont pas implémentées dans une classe concrète.

Points clés à retenir

• Une classe abstraite ne peut pas être instanciée directement.
• Les méthodes abstraites définissent uniquement la signature, sans code source.
• Une classe concrète doit implémenter toutes les méthodes abstraites héritées.
• Les interfaces permettent l'héritage multiple et contiennent uniquement des méthodes abstraites et des constantes.
• Une classe qui implémente une interface doit fournir le code de toutes ses méthodes, sauf si elle est abstraite.
• Les méthodes d'une interface sont implicitement publiques et abstraites.
• Les constantes dans une interface sont implicitement statiques et finales.