Section courante

A propos

Section administrative du site

Abstraction

L'abstraction est l'un des quatre piliers fondamentaux de la programmation orientée objet, avec l'encapsulation, l'héritage et le polymorphisme.

Elle consiste à se concentrer sur les caractéristiques essentielles d'un objet, tout en masquant les détails de son implémentation.

Autrement dit, l'abstraction répond à la question :

Elle permet ainsi de fournir une vue simplifiée et conceptuelle d'un système complexe.

Pourquoi l'abstraction est-elle indispensable ?

L'abstraction répond à des besoins fondamentaux en ingénierie logicielle :

Réduction de la complexité

Les détails techniques sont cachés derrière des concepts simples et compréhensibles.

Séparation des responsabilités

L'utilisateur d'un objet n'a pas besoin de connaître son fonctionnement interne.

Indépendance de l'implémentation

Une implémentation peut être modifiée sans impacter le code client.

Facilitation du travail en équipe

Les contrats sont clairement définis, même si les implémentations sont développées séparément.

Abstraction vs encapsulation

Bien que proches, ces deux notions sont distinctes :

Abstraction Encapsulation
Cache la complexité Cache les données
Définit un contrat Contrôle l'accès
« Quoi » « Comment »
Interfaces / classes abstraites Modificateurs d'accès

L'encapsulation protège, l'abstraction simplifie.

Les outils de l'abstraction en POO

L'abstraction est mise en ouvre principalement à l'aide de :

Les classes abstraites

Définition

Une classe abstraite est une classe :

Elle sert de base commune à des classes spécialisées.

Exemple simple

Voici un exemple en Java :

  1. abstract class Animal {
  2.  
  3.     protected String nom;
  4.  
  5.     public Animal(String nom) {
  6.         this.nom = nom;
  7.     }
  8.  
  9.     public abstract void crier();
  10.  
  11.     public void dormir() {
  12.         System.out.println("L'animal dort");
  13.     }
  14. }

Implémentation dans une classe concrète

Voici un exemple en Java :

  1. class Chien extends Animal {
  2.  
  3.     public Chien(String nom) {
  4.         super(nom);
  5.     }
  6.  
  7.     @Override
  8.     public void crier() {
  9.         System.out.println("Le chien aboie");
  10.     }
  11. }

Utilisation

Voici un exemple en Java :

  1. Animal animal = new Chien("Rex");
  2. animal.crier();
  3. animal.dormir();

Le code utilise l'abstraction (Animal), pas l'implémentation (Chien).

Les méthodes abstraites

Rôle

Une méthode abstraite :

Voici un exemple en Java :

  1. public abstract void deplacer();

Obligation d'implémentation

Toute classe concrète héritant d'une classe abstraite doit implémenter toutes les méthodes abstraites, sous peine d'être elle-même abstraite.

Les interfaces

Définition

Une interface définit un contrat pur :

Exemple d'interface

  1. interface Volant {
  2.     void voler();
  3. }

Implémentation

  1. class Oiseau implements Volant {
  2.  
  3.     @Override
  4.     public void voler() {
  5.         System.out.println("L'oiseau vole");
  6.     }
  7. }

Utilisation

Voici un exemple en Java :

Volant v = new Oiseau(); v.voler();

Classe abstraite vs interface

Classe abstraite Interface
Peut contenir des attributs Pas d'état
Méthodes concrètes possibles Contrat pur
Héritage simple Héritage multiple
Relation IS-A Capacité / rôle

Abstraction et polymorphisme

L'abstraction est le socle du polymorphisme :

  1. List<Animal> animaux = List.of(
  2.     new Chien("Rex"),
  3.     new Chat("Mina")
  4. );
  5.  
  6. for (Animal a : animaux) {
  7.     a.crier();
  8. }

Le comportement varie selon l'implémentation, pas selon le type de référence.

Abstraction et conception orientée objet

Programmation orientée interfaces

Principe clef :

  Programmer contre des abstractions, pas des implémentations

Exemple en Java :

  1. void faireVoler(Volant v) {
  2.     v.voler();
  3. }

Inversion des dépendances (SOLID)

L'abstraction est au cour du principe D de SOLID :

Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau, mais d'abstractions.

Mauvaises utilisations de l'abstraction

Une abstraction doit être justifiée par un besoin concret.

Bonnes pratiques

Exemple complet et réaliste

Voici un exemple de l'abstraction d'un système de paiement en Java :

  1. interface MoyenPaiement {
  2.     void payer(double montant);
  3. }
  4.  
  5. class CarteBancaire implements MoyenPaiement {
  6.     public void payer(double montant) {
  7.         System.out.println("Paiement par carte : " + montant);
  8.     }
  9. }
  10.  
  11. class Paypal implements MoyenPaiement {
  12.     public void payer(double montant) {
  13.         System.out.println("Paiement via Paypal : " + montant);
  14.     }
  15. }

Utilisation :

  1. void effectuerPaiement(MoyenPaiement moyen) {
  2.     moyen.payer(100);
  3. }

Abstraction et UML

Conclusion

L'abstraction est un outil fondamental pour maîtriser la complexité. Elle permet de concevoir des systèmes flexibles, évolutifs et robustes en séparant clairement ce qui est fait de la manière dont cela est fait.



Dernière mise à jour : Jeudi, le 1er janvier 2026