Qu'est-ce que le principe de responsabilité unique?
Dans la programmation et la conception informatiques, le principe de responsabilité unique est un concept qui défend l'idée que toute classe d'un programme ne doit remplir qu'une seule fonction dans une application plus large. Cette idée promeut en partie certains des idéaux de la programmation orientée objet, tels que l'encapsulation, car toute une classe se concentrera sur l'exécution d'une seule responsabilité et s'appuiera peu sur les classes extérieures. En même temps, il est quelque peu antithétique avec certains des concepts de la programmation orientée objet ancienne, car la fonction d’un seul objet est découplée des données gérées par l’objet, ce qui signifie qu’il serait peut-être nécessaire de construire de nombreux objets combinés pour conserver certaines données centrales. Le principe de responsabilité unique est à la base d’un type de modèle de conception appelé conception axée sur la responsabilité.
Un exemple du principe de responsabilité unique pourrait prendre la forme d’un combiné téléphonique traditionnel. Certains principes de conception considèrent le combiné comme un seul objet gérant à la fois les entrées de la ligne téléphonique et la transmission des sorties du haut-parleur. Dans un modèle de responsabilité unique, dans lequel un seul objet ne devrait avoir qu'une seule responsabilité, le combiné serait alors constitué de plusieurs objets distincts remplissant chacun une fonction unique, par exemple recevoir uniquement une entrée de la ligne téléphonique ou transmettre uniquement les données via l'écouteur.
L'un des avantages rendus possibles par le principe de responsabilité unique est un très haut niveau d'abstraction et de modularité. Dans l'exemple du combiné, l'entrée des lignes téléphoniques ou la manière dont le signal est transmis à l'utilisateur peuvent être modifiées sans affecter les classes voisines tant qu'elles respectent le même contrat d'interface. De plus, la réutilisabilité de certains composants peut être très élevée, car chaque classe est entièrement encapsulée et repose très peu, voire pas du tout, sur les objets environnants, se concentrant plutôt sur sa seule responsabilité.
Le principe de responsabilité unique peut entraîner une complication: un grand nombre de classes et d'objets qui fonctionnent tous sur les mêmes données. Cela peut signifier beaucoup de frais généraux et un processus de conception compliqué. Cela peut également rendre difficile le débogage d'un programme volumineux, car une seule partie du programme peut consister en des milliers de petits fichiers de classe.
Lorsque le principe de responsabilité unique est appliqué selon une conception axée sur la responsabilité, les données et les méthodes utilisées pour les manipuler sont séparées aux fins de la conception. Bien que cela crée une certaine liberté, une encapsulation et une modularité dans la conception, cela peut également générer un certain nombre de modèles et de conceptions intermédiaires qui doivent être utilisés pour faciliter la création de plusieurs classes essayant toutes d'interagir avec les données en même temps. D'autre part, si les données d'un objet et les méthodes utilisées pour les manipuler sont liées dans un seul objet multi-responsabilité, le code peut devenir plus difficile à modifier à mesure que les systèmes évoluent, se modifient ou deviennent plus complexes.