Hello,

Petite question. Hormis quand on veut faire de l'héritage multiples. Quelles sont les circonstances dans lesquelles vous préférez utiliser une interface qu'une classe abstraite ?

Je sais que se sont 2 choses différentes mais qui, au final, reviennent à implémenter ou  override les méthodes.

J'ai donc une vision un peu flou de l'utilité entre les 2.

-
Edité par Flingouin 6 mars 2020 à 13:11:00

Il y a bien plus de cas d'usage des interfaces que l'héritage multiple (qui n'existe pas en .NET "CLS").

Renseignez-vous sur la pléthore de Design Pattern qui prenne avantage de ce concept d'"Interface".

>vous préférez utiliser une interface qu'une classe abstraite ?

C'est plutôt l'inverse, on utilise les interfaces le plus possible car plus polyvalente.

On n'utilise la classe abstraite que lorsqu'elle donne un avantage sur les interfaces (implémentation par défaut, etc...).

Les 2 servent et elles ne sont pas strictement interchangeables.

Un exemple très concret :

- Mes classes doivent toute notifier un changement à la vue ? Elles doivent implémenter l'interface INotifyPropertyChanged

- L'implémentation de l'interface est complexe, redondante et identique au sein d'une série de classes ? Gérer un changement de comportement devient un sacré casse-tête et je préfère donc implémenter l'interface INotifyPropertyChanged dans une classe mère abstraite.

Dans ce cas l'avantage de la classe abstraite est une implémentation par défaut pour laquelle on veut éviter une redondance de code. Mais c'est le seul avantage, sinon autant implémenter une interface déjà prévue dans le framework et qui offre toute la souplesse requise.

Ensuite en restant à un niveau très basique, la question ne se pose pas que pour l'implémentation, mais aussi pour le passage en paramètre. Je peux très bien écrire une classe qui liste un certain type d'objets d'une certaine façon, avec un tri adapté, un accès adapté, un comportement adapté, etc... Il y en a déjà pas mal : Enumerable, List, ObservableCollection, Dictionary, etc... La question est : comment manipuler cet objet en s'attendant à un comportement "général" mais sans connaître le détail ? C'est la magie des interfaces comme IEnumerable ou IList qui vont permettre de passer en paramètre des objets ayant le comportement approprié, sans avoir besoin de savoir comment ça se passe, et sans écrire une méthode prenant en paramètre chaque type précis (ni écrire une méthode prenant en paramètre un objet trop général dont le type ne permettrait pas de garantir le comportement). C'est simple et souple, et robuste ! Une classe abstraite offrirait beaucoup moins de souplesse, il faudrait overrider à tout va. Avec les interfaces, l'objet doit obéir à une règle très générale, mais peu importe comment il s'y prend.

Je vous remercie pour vos lumières !

Je vais voir pour approfondir tous ça.