Classes et méthodes abstraites en Java : guide complet

Classes et méthodes abstraites en Java

Ce tutoriel fournit une exploration claire, pilotée par l'exemple, des classes et méthodes abstraites en Java, et explique comment l'abstraction est implémentée.

Classe abstraite Java

En Java, une classe abstraite ne peut pas être instanciée. Le mot-clé abstract marque la classe comme abstraite. Par exemple :

// créer une classe abstraite abstract class Language { // champs et méthodes } ... // essayer de créer un objet Language // lance une erreur Language obj = new Language();

Une classe abstraite peut contenir à la fois des méthodes concrètes (régulières) et des méthodes abstraites. Par exemple :

abstract class Language { // méthode abstraite abstract void method1(); // méthode régulière void method2() { System.out.println("This is regular method"); } }

Pour plus sur les méthodes régulières, voir Méthodes Java.

---

Méthode abstraite Java

Une méthode abstraite n'a pas de corps ; elle déclare un contrat que les sous-classes doivent remplir. Elle est définie avec le mot-clé abstract, par ex. :

abstract void display();

Faute de corps, l'instruction se termine par un point-virgule. Si une classe déclare une méthode abstraite, la classe elle-même doit être déclarée abstraite, sinon le compilateur lance une erreur :

// erreur // la classe devrait être abstraite class Language { // méthode abstraite abstract void method1(); }

---

Exemple : Classe et méthode abstraites Java

Bien que les classes abstraites ne puissent pas être instanciées directement, les sous-classes concrètes peuvent les étendre et utiliser leurs membres. Par exemple :

abstract class Language { public void display() { System.out.println("This is Java Programming"); } } class Main extends Language { public static void main(String[] args) { Main obj = new Main(); obj.display(); } }

Sortie

This is Java programming

Ici, la classe abstraite Language définit une méthode concrète display(). La sous-classe Main hérite cette méthode et l'invoque via son instance.

---

Implémentation des méthodes abstraites

Quand une classe abstraite déclare une méthode abstraite, chaque sous-classe concrète doit fournir une implémentation. Par exemple :

abstract class Animal { abstract void makeSound(); public void eat() { System.out.println("I can eat."); } } class Dog extends Animal { public void makeSound() { System.out.println("Bark bark"); } } class Main { public static void main(String[] args) { Dog d1 = new Dog(); d1.makeSound(); d1.eat(); } }

Sortie

Bark bark I can eat.

La sous-classe Dog implémente la méthode abstraite makeSound(), tout en héritant la méthode concrète eat().

Note : Si Dog ne redéfinit pas makeSound(), elle doit elle-même être déclarée abstraite.

---

Accès au constructeur des classes abstraites

Les classes abstraites peuvent définir des constructeurs comme les classes normales. Les sous-classes invoquent le constructeur de la superclasse en utilisant super(). Par exemple :

abstract class Animal { Animal() { // logique d'initialisation } } class Dog extends Animal { Dog() { super(); // initialisation additionnelle } }

Rappelez-vous que super() doit être la première instruction dans le constructeur de la sous-classe.

---

Abstraction en Java

Les classes et méthodes abstraites sont les outils principaux pour atteindre l'abstraction en Java. L'abstraction cache les détails d'implémentation inutiles, présentant seulement l'interface essentielle à l'utilisateur. Cela simplifie les systèmes complexes et favorise la flexibilité.

Par exemple, un frein de moto effectue la même fonction de haut niveau – ralentir la moto – tandis que son mécanisme interne peut différer selon les modèles.

Exemple 3 : Abstraction Java

abstract class MotorBike { abstract void brake(); } class SportsBike extends MotorBike { public void brake() { System.out.println("SportsBike Brake"); } } class MountainBike extends MotorBike { public void brake() { System.out.println("MountainBike Brake"); } } class Main { public static void main(String[] args) { MountainBike m1 = new MountainBike(); m1.brake(); SportsBike s1 = new SportsBike(); s1.brake(); } }

Sortie :

MountainBike Brake SportsBike Brake

Chaque sous-classe concrète fournit sa propre implémentation de brake(), illustrant comment l'abstraction découple l'interface de l'implémentation.

Note : Les interfaces peuvent aussi être utilisées pour atteindre l'abstraction en Java.

---

Points clés à retenir

• Utilisez le mot-clé abstract pour déclarer classes et méthodes abstraites.
• Une méthode abstraite n'a pas de corps ; elle se termine par un point-virgule.
• Les classes contenant des méthodes abstraites doivent elles-mêmes être abstraites.
• Les classes abstraites ne peuvent pas être instanciées directement.
• Les sous-classes concrètes héritent des classes abstraites et fournissent des implémentations pour les méthodes abstraites.
• Les sous-classes doivent redéfinir toutes les méthodes abstraites sauf si elles sont déclarées abstraites.
• Les membres statiques d'une classe abstraite sont accessibles via le nom de la classe :

  Animal.staticMethod();