À quoi servent les interfaces si des classes abstraites existent déjà?

1. Héritage multiple. Une classe peut implémenter plusieurs interfaces, mais hériter d'une seule classe (y compris abstraite).

   interface IDrivable {}
   interface IFlyable {}
   
   class Car : IDrivable {} // Hérite seulement d'une classe (object implicitement)
   
   class FlyingCar : IDrivable, IFlyable {} // Implémente plusieurs interfaces
   

2. Contrat sans implémentation. Les interfaces définissent uniquement un contrat (méthodes, propriétés, événements, indexeurs) sans aucune implémentation. Les classes abstraites peuvent contenir une fonctionnalité partiellement implémentée et des champs.

   interface IShape
   {
       double GetArea(); // Déclaration seule
   }
   
   abstract class Shape
   {
       public abstract double GetArea(); // Déclaration
       public string Color { get; set; } // Implémentation de propriété
   
       public void DisplayColor()
       {
           Console.WriteLine($"Couleur : {Color}"); // Méthode implémentée
       }
   }
   

3. Couplage faible (loose coupling). Les interfaces favorisent un faible couplage entre composants, car le code dépend du contrat, et non de l'implémentation concrète. Cela facilite le remplacement d'une implémentation par une autre.
4. Séparation des rôles. Les interfaces permettent de définir des rôles ou capacités clairs qu'une classe doit posséder, indépendamment de son type principal ou de sa hiérarchie d'héritage.
5. Test. Les mocks et stubs pour les tests unitaires sont souvent créés à partir d'interfaces, et non de classes abstraites, car celles-ci peuvent avoir des dépendances ou une logique interne complexe.

En résumé : les interfaces offrent un mécanisme flexible pour définir des contrats et atteindre le polymorphisme sans les restrictions d'héritage d'une seule classe de base, tandis que les classes abstraites sont destinées à fournir une implémentation partielle et une fonctionnalité de base, qui sera complétée dans les classes dérivées.