nombre de méthodes dans une interface

Je sais que cela peut sembler une question controversée, mais ce n’est vraiment pas censé être. Existe-t-il un nombre optimal de méthodes dans une interface?

Par exemple, je déteste personnellement une interface avec 20 méthodes. C’est juste difficile à mettre en œuvre. Le contrat semble difficile à maintenir. De même si le nombre de méthodes est juste 1. Cela me fait me demander si c’est vraiment une bonne abstraction.

Des pensées ?

Une interface doit avoir exactement autant de méthodes que nécessaire. Exemples:

java.lang.Iterable – 1 méthode
java.lang.Comparable – 1 méthode
java.util.Collection – 14 méthodes
java.util.List – 25 méthodes (y compris celles de Collection)

La réponse est donc: ne prenez pas le nombre comme critère pour votre interface. Au lieu de cela, placez les méthodes dans les interfaces où elles appartiennent logiquement.

Une étude bien connue suggère que le nombre d’éléments d’information que nous pouvons traiter à la fois est de sept, plus ou moins deux. Je trouve souvent que c’est une bonne règle pour ce type de question – dans ce cas, si l’interface est conçue pour gérer un ensemble de fonctionnalités liées, nous ne pourrons probablement pas comprendre la fonctionnalité en tant que solution unique. définir si c’est beaucoup plus que sept.

Toutefois, pour de nombreuses interfaces, un développeur n’a pas besoin de comprendre la fonctionnalité comme un seul ensemble associé. Dans ce cas, cette règle ne serait pas pertinente.

Les interfaces avec une méthode ont généralement leur fonction et vous pouvez les implémenter anonymement plus facilement. Ma règle d’or est autant de méthodes qu’il doit avoir . Cependant, de nombreuses méthodes dans une interface suggèrent généralement que vous puissiez la scinder en plusieurs autres interfaces, en particulier si elle concerne différentes zones de tâches (par exemple, une UserLoginAndAdministrationInterface devient une interface UserLogin et une interface UserAdministration). Vous pouvez implémenter autant d’interfaces que vous le souhaitez dans une classe et elles peuvent également être sous-classées. Donc, les séparer ne fait pas mal du tout.

Je serais plus préoccupé par le fait que l’interface est logiquement cohérente que par un nombre arbitraire de méthodes optimales. Cela dit, un grand nombre de méthodes pourraient indiquer un object “dieu”, qui devrait être refactoré. L’indication plus claire est que les méthodes ne sont pas cohérentes, mais le nombre de méthodes peut être plus facile à observer et vous conduire à un examen plus approfondi. Parfois, cependant, vous avez simplement besoin de nombreuses méthodes car vous voudriez effectuer de nombreuses opérations sur des objects de ce type. Un exemple de ceci serait quelque chose comme IEnumerable dans .NET. Je ne vois aucune raison valable de les séparer en interfaces séparées, mais il existe de nombreuses méthodes dans l’interface.

Une interface doit avoir exactement autant de méthodes que nécessaire .

Si ce nombre est grand, la justification doit être examinée attentivement, mais peut être valable.

D’autre part, il existe (au moins) une instance en Java où l’interface n’a pas besoin de méthodes (sérialisable) et n’en a donc aucune. Moins de méthodes, facilite certainement la mise en œuvre de l’interface mais peut toujours fournir une abstraction très utile. Il existe plusieurs interfaces avec une méthode.

Il n’y a pas de nombre optimal de méthodes dans une interface. Les interfaces sont utilisées pour toutes sortes de choses et ce qui est approprié dépend entièrement de quoi.

À un extrême, une interface peut être automatiquement générée par un code par un programme pour être utilisée par un autre programme et peut, pour une bonne raison, contenir 1 000 méthodes.

Pour un code lisible par les humains, les règles ne peuvent remplacer le jugement.

7 ± 2

Il n’y a pas de bonne ou de mauvaise réponse quant au nombre de méthodes acceptables pour une interface. Certains peuvent avoir zéro, d’autres un et probablement très peu en dépasseront jamais une centaine. La plus grande interface que j’ai jamais écrite était près de trente méthodes, mais c’était une façade pour les clients.

Cependant, je penserais qu’une interface comportant plus que 8-10 méthodes serait une possible fumée de code – juste quelque chose qui nécessiterait 5 secondes pour enquêter.

Les classes Abstract qui fournissent des implémentations par défaut ou throw NotImplementedException moyen de gérer de nombreuses méthodes lorsque vous n’avez besoin que d’en implémenter quelques- throw NotImplementedException . S’il n’y a qu’une seule méthode, c’est probablement correct, car il existe des méthodes qui n’attendent qu’un seul Iterface et appellent cette méthode. Il y a beaucoup de modèles, Vistor par exemple, qui n’a besoin que d’une méthode.

Ces vingt méthodes capturent quelque chose d’utile ensemble ou non. S’ils le font, vous devez tous les implémenter pour fournir une implémentation de ce qu’ils capturent. Il sera cohérent de les loger dans la même interface dans ce cas.

La réponse est: ne prenez pas le nombre comme critère pour votre interface. Au lieu de cela, placez les méthodes dans les interfaces où elles appartiennent logiquement et vous pouvez les utiliser dans différentes classes. Vous pouvez utiliser une méthode d’interface dans deux classes ou plus, alors n’hésitez pas à utiliser l’interface, c’est une bonne technique de programmation.