En programmation orientée objet, le choix entre interface et classe ne se joue pas sur un principe abstrait de « bonne pratique ». Il se joue sur la volatilité réelle des dépendances d’un module. Poser une interface devant chaque classe est un réflexe courant, mais le gain en découplage n’existe que si l’implémentation derrière cette interface a des raisons concrètes de changer.
Dispatch statique ou dynamique : ce que l’interface coûte réellement
Avant de parler d’architecture, il faut parler de mécanique. Toute interface introduit un niveau d’indirection. En Java ou C#, l’appel passe par une table de méthodes virtuelles. Le coût à l’exécution est marginal sur un appel isolé, mais il devient mesurable dans des boucles critiques ou des chemins chauds.
A lire aussi : Les inconvénients de l’automatisation en entreprise
Rust rend cette distinction explicite. Les traits y servent d’interface, mais le développeur choisit entre dispatch statique via les génériques et dispatch dynamique via les objets de trait (dyn Trait). Le dispatch statique permet au compilateur de monomorphiser le code, donc de l’optimiser comme un appel direct. Le dispatch dynamique passe par une vtable et impose des contraintes de taille et de durée de vie sur les objets manipulés.
Ce n’est pas un détail d’implémentation. C’est un arbitrage de conception qui conditionne la performance et la flexibilité du code. Nous rencontrons régulièrement des bases de code où l’ajout d’une interface n’a produit aucun bénéfice parce que la dépendance n’a jamais varié, tout en imposant une indirection permanente.
A voir aussi : Serveur LLM : définition et fonctionnement

Volatilité des dépendances : quand l’interface réduit le coût des changements
L’argument central en faveur des interfaces est le découplage. Un module métier dépend d’une abstraction, pas d’une implémentation concrète. Si l’implémentation change (nouveau fournisseur de paiement, migration de base de données, remplacement d’une API tierce), le module métier n’est pas touché.
Ce raisonnement ne tient que si la dépendance est effectivement volatile. L’inversion des dépendances a un vrai rendement aux frontières d’un système :
- Accès à une base de données ou à un stockage fichier, dont la technologie peut évoluer indépendamment du domaine métier
- Appels à des API tierces, soumis à des changements de version, de fournisseur ou de protocole
- Stratégies métier susceptibles de varier selon le contexte (calcul de tarification, règles de validation, moteurs de notification)
En revanche, une interface posée devant une dépendance stable ajoute du bruit architectural sans réduire le coût du changement. Un repository dont l’unique implémentation accède à PostgreSQL depuis la création du projet, sans perspective de migration, ne tire aucun bénéfice d’une interface dédiée. L’abstraction est là, elle double le nombre de fichiers à maintenir, et elle n’a jamais servi.
Inversion des dépendances et testabilité : deux mécanismes distincts
Un argument fréquent pour les interfaces est la testabilité. Remplacer une classe concrète par un faux (mock, stub, implémentation en mémoire) suppose de pouvoir injecter cette substitution. L’interface le permet, mais elle n’est pas la seule voie.
Le point technique à ne pas confondre : le principe d’inversion des dépendances n’est pas l’injection de dépendances. L’inversion est un choix de conception où l’abstraction appartient au module de haut niveau. L’injection est une technique de câblage, applicable même sans interface si le langage offre d’autres mécanismes (fonctions de premier ordre, modules paramétrés, génériques bornés).
Pour que la testabilité fonctionne, le code métier doit recevoir sa dépendance au lieu de l’instancier. Sans ce prérequis, ajouter une interface ne change rien : le couplage se déplace de la signature vers le constructeur.
Quand l’interface gêne les tests
Une interface trop fine, calquée sur l’API d’une infrastructure, oblige à mocker des détails internes. Le test devient fragile, couplé à la structure du faux plutôt qu’au comportement métier attendu. L’abstraction utile aux tests est celle qui expose un contrat métier, pas celle qui reproduit une API technique.
Méthodes par défaut dans les interfaces : souplesse et conflits
Les interfaces modernes ne sont plus de simples listes de signatures. En C#, une interface peut fournir des implémentations par défaut, ce qui permet de faire évoluer un contrat sans casser immédiatement les types existants. Java offre le même mécanisme depuis plusieurs versions.
Cette souplesse a un coût. Si deux interfaces sans lien hiérarchique déclarent une méthode par défaut avec la même signature, la classe qui les implémente doit résoudre le conflit explicitement. Le compilateur Java refuse de choisir arbitrairement. En C#, les règles de compatibilité dépendent du runtime et du type concret.
Ce mécanisme rapproche les interfaces des classes abstraites sur un point précis : elles portent désormais du comportement, pas seulement un contrat. La distinction entre les deux devient plus fine, et le choix doit se faire sur des critères concrets :
- L’héritage multiple de contrats reste possible avec les interfaces, pas avec les classes abstraites
- Une classe abstraite peut porter un état interne (champs), une interface ne le peut pas (hors mécanismes spécifiques au langage)
- Les méthodes par défaut dans les interfaces conviennent à l’évolution d’API partagées, pas à la modélisation d’un comportement riche avec état

Interface-based architecture : les limites d’une approche systématique
L’approche dite « Interface-based programming » pousse à lier chaque classe à une interface, y compris les DTOs, les entités et les objets-valeurs. L’objectif affiché est un code entièrement découplé de toute implémentation.
En pratique, cette approche dogmatique annule ses propres bénéfices. Quand chaque interface a exactement une implémentation, le ratio signal/bruit chute. La navigation dans le code devient plus lente, les refactorings plus coûteux (deux fichiers à modifier au lieu d’un), et l’abstraction ne protège de rien puisqu’elle duplique l’API concrète.
Le critère opérationnel reste la volatilité. Une interface se justifie quand elle protège un module contre un changement probable ou quand elle permet une substitution testable sur une frontière critique. Sur tout le reste, la classe concrète est plus lisible, plus directe et plus facile à maintenir.
Nous pouvons résumer la décision en une question : si cette interface était supprimée demain, quel module casserait pour une raison autre que la compilation ? Si la réponse est « aucun », l’interface n’apporte rien. L’architecture gagne en clarté quand chaque abstraction correspond à une décision de conception, pas à un automatisme.

