Conception par Objet et Programmation Java

Ce matériel couvre les concepts fondamentaux des classes abstraites et des interfaces en programmation orientée objet avec Java. Il s'adresse aux étudiants en informatique ou développeurs souhaitant approfondir leur compréhension de ces notions essentielles pour la conception de logiciels modulaires et extensibles.

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. Elle peut contenir des méthodes et des champs classiques, ainsi que des méthodes abstraites qui ne fournissent que leur signature et leur type de retour, sans implémentation.

Syntaxe d'une classe abstraite :

abstract class A {
    public void foo() { …… }  // méthode définie dans A
    public abstract void bar(int n);  // méthode abstraite, non définie dans A
}

On peut déclarer une référence de type A :

A a;

Mais il est impossible d'instancier directement une classe abstraite :

a = new A();  // Erreur : instanciation interdite

Si une classe B hérite de A et définit toutes les méthodes abstraites de A, alors on peut instancier B :

a = new B();  // Correct car B n'est pas abstraite

Règles importantes :

• Une classe est abstraite dès qu'elle comporte au moins une méthode abstraite, même si le mot-clé abstract n'est pas explicitement écrit.
• Une méthode abstraite doit être déclarée public pour être redéfinie dans une classe dérivée.
• Une classe dérivée d'une classe abstraite n'est pas obligée de redéfinir toutes les méthodes abstraites. Si elle ne le fait pas, elle reste abstraite.
• Une classe dérivée d'une classe non abstraite peut elle-même être déclarée abstraite.

Intérêts des classes abstraites :

• Permettent de regrouper dans une même classe de base des fonctionnalités communes (méthodes non abstraites et champs) partagées par toutes les classes dérivées.
• Garantissent que certaines méthodes abstraites seront obligatoirement implémentées dans les classes dérivées instanciables.

Exemple d'utilisation d'une classe abstraite

abstract class Animal {
    public void dormir() {
        System.out.println("L'animal dort");
    }
    public abstract void crier();
}

class Chien extends Animal {
    public void crier() {
        System.out.println("Le chien aboie");
    }
}

Animal a;
// a = new Animal(); // Erreur : classe abstraite non instanciable
a = new Chien();
a.dormir();  // Affiche : L'animal dort
a.crier();   // Affiche : Le chien aboie

Les interfaces

Jusqu'à Java 7, une interface était considérée comme une classe abstraite ne contenant aucune méthode implémentée ni champ (sauf des constantes). Elle définit uniquement les signatures des méthodes et des constantes associées.

Depuis Java 8, une interface peut contenir des méthodes avec une implémentation grâce au mot-clé default. Ce changement vise à mieux supporter la programmation fonctionnelle.

Caractéristiques des interfaces :

• Une classe peut implémenter plusieurs interfaces, contrairement à l'héritage simple des classes abstraites.
• La notion d'interface s'ajoute à celle d'héritage, elle ne la remplace pas.
• 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 réimplémenter une interface déjà implémentée par sa superclasse.
• On peut utiliser des variables de type interface.

Syntaxe d'une interface :

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

Toutes les méthodes d'une interface sont abstraites par défaut, sauf si elles sont marquées default (avec une implémentation). Le modificateur de visibilité public et le mot-clé abstract sont facultatifs.

Exemple d'interface et d'implémentation

public interface Volant {
    void voler();
}

class Oiseau implements Volant {
    public void voler() {
        System.out.println("L'oiseau vole");
    }
}

Volant v = new Oiseau();
v.voler();  // Affiche : L'oiseau vole

Glossaire des termes clés

• Classe abstraite : classe qui ne peut pas être instanciée et qui peut contenir des méthodes abstraites sans implémentation.
• Méthode abstraite : méthode déclarée sans corps, à implémenter obligatoirement dans une classe dérivée non abstraite.
• Interface : type définissant uniquement des signatures de méthodes (et des constantes), pouvant contenir des méthodes par défaut avec implémentation depuis Java 8.
• Implémentation : définition concrète d'une méthode abstraite ou d'une méthode d'interface dans une classe dérivée.
• Héritage : mécanisme permettant à une classe de dériver d'une autre, héritant de ses méthodes et champs.
• Polymorphisme : capacité d'une référence à prendre plusieurs formes, notamment en référant à des objets de classes dérivées.

Points clés à retenir

• Une classe abstraite ne peut pas être instanciée directement, mais peut contenir des méthodes implémentées et abstraites.
• Une méthode abstraite doit être redéfinie dans une classe dérivée non abstraite.
• Les interfaces définissent un contrat de méthodes à implémenter, sans fournir d'état (champs), sauf constantes.
• Une classe peut implémenter plusieurs interfaces, ce qui favorise la modularité et la flexibilité.
• Depuis Java 8, les interfaces peuvent contenir des méthodes par défaut avec une implémentation.