Qu'est-ce que le découplage et à quels domaines de développement peut-il s'appliquer?
J'ai récemment remarqué le découplage en tant que sujet dans une question et je veux savoir de quoi il s'agit et où il peut s'appliquer.
Par "où peut-il s'appliquer", je veux dire:
Est-ce pertinent uniquement lorsque des langages compilés comme C et Java sont impliqués?
Dois-je le savoir/l'étudier en tant que développeur web?
Le "couplage" est un terme qui décrit la relation entre deux entités dans un système logiciel (généralement des classes).
Lorsqu'une classe utilise une autre classe, ou communique avec elle, on dit qu'elle "dépend" de cette autre classe, et donc ces classes sont "couplées". Au moins l'un d'eux "connaît" l'autre.
L'idée est que nous devrions essayer de garder le couplage entre les classes dans nos systèmes aussi `` lâche '' que possible: d'où `` couplage lâche '' ou parfois `` découplage '' (bien qu'en anglais, `` découplage '' signifierait `` pas de couplage du tout '', les gens l'utilisent souvent pour impliquer un "couplage lâche" entre les entités).
Alors: qu'est-ce que le couplage lâche contre le couplage fort dans la pratique, et pourquoi devrions-nous faire des entités à couplage lâche?
Le couplage décrit le degré de dépendance entre une entité et une autre entité. Souvent des classes ou des objets.
Lorsque la classe A dépend fortement de la classe B, les chances que la classe A soit affectée lorsque la classe B est modifiée sont élevées. C'est un couplage fort.
Cependant, si la classe A dépend légèrement de la classe B, les chances que la classe A soit affectée de quelque manière que ce soit par un changement du code de la classe B sont faibles. Il s'agit d'un couplage lâche ou d'une relation "découplée".
Le couplage lâche est bon parce que nous ne voulons pas que les composants de notre système dépendent fortement les uns des autres. Nous voulons garder notre système modulaire, où nous pouvons changer une partie en toute sécurité sans affecter l'autre.
Lorsque deux parties sont lâchement couplées, elles sont plus indépendantes l'une de l'autre et sont moins susceptibles de se casser lorsque l'autre change.
Par exemple, lors de la construction d'une voiture, vous ne voudriez pas qu'un changement interne du moteur casse quelque chose dans le volant.
Bien que cela ne se produise jamais par accident lors de la construction d'une voiture, des choses similaires arrivent tout le temps aux programmeurs. Un couplage desserré est destiné à réduire le risque que de telles choses se produisent.
Un couplage fort se produit généralement lorsque l'entité A en sait trop sur l'entité B. Si l'entité A fait trop d'hypothèses sur le fonctionnement ou la construction de l'entité B, il existe un risque élevé qu'un changement dans l'entité B affecte entité A. En effet, l'une de ses hypothèses sur l'entité B est maintenant incorrecte.
Par exemple, imaginez qu'en tant que conducteur, vous fassiez certaines hypothèses sur le fonctionnement du moteur de votre voiture.
Le jour où vous achetez une nouvelle voiture avec un moteur qui fonctionne différemment (ou pour une raison quelconque, votre moteur a été remplacé), vos hypothèses précédentes seraient incorrectes. Si vous étiez du code sur un ordinateur, vous seriez maintenant un code incorrect qui ne fonctionne pas correctement.
Cependant, si toutes les suppositions qu'en tant que conducteur que vous avez faites sur les voitures sont les suivantes: A- elles ont des volants et B- elles ont des pédales de frein et de gaz, alors les changements dans la voiture ne vous affecteront pas, tant que vos quelques hypothèses restez correct. Il s'agit d'un couplage lâche.
ne technique importante pour réaliser un couplage lâche est l'encapsulation. L'idée est qu'une classe cache ses détails internes aux autres classes et offre une interface strictement définie pour que d'autres classes communiquent avec elle.
Ainsi, par exemple, si vous définissez une classe Car, son interface (méthodes publiques) serait probablement drive(), stop(), steerLeft(), steerRight(), getSpeed(). Ce sont les méthodes que d'autres objets peuvent invoquer sur les objets Car.
Tous les autres détails de la classe Car: comment le moteur fonctionne, le type de carburant qu'il utilise, etc. sont cachés aux autres classes - pour les empêcher d'en savoir trop sur Car.
Le moment où la classe A en sait trop sur la classe B: nous avons une relation fortement couplée, où la classe A dépend trop de la classe B et un changement de classe B est susceptible d'affecter la classe A. Rendre le système difficile à développer et maintenir.
Une relation entre deux entités, où elles se connaissent peu (uniquement ce qui est nécessaire) - est une relation faiblement couplée ou découplée.
Le découplage consiste généralement à voir si deux choses doivent ou non travailler en étroite collaboration ou peuvent être rendues indépendantes. L'indépendance est formidable car elle rend ces choses faciles à changer ou à utiliser ailleurs. Le découplage peut être appliqué dans de nombreux domaines, non seulement le développement, et cela est particulièrement vrai pour le découplage temporel, qui peut même être appliqué dans votre vie quotidienne (dans une certaine mesure). Notant également, il existe de nombreux types de couplage dans le développement de logiciels à considérer, et tous ne seront pas couverts dans la réponse. Vous devrez faire vos recherches.
Deux choses, A et B , sont couplées s'il y a une dépendance entre elles. Si A dépend de B, vous pouvez utiliser B sans prendre A en considération. Si vous souhaitez utiliser A, vous devrez également reporter B, car A en dépend.
Dans le développement de logiciels, généralement, vous ne pouvez pas supprimer complètement le couplage entre les composants. Le découplage dans ce contexte signifie normalement desserrer le couplage existant. Autrement dit, en vous assurant que chaque composant en sait le moins possible sur les autres composants qui l'entourent.
Il s'agit probablement du type de couplage le plus courant dans la nature:
//Inside a class meant to display info for a particular Facebook user.
void DisplayFriends(FacebookUser user, FacebookClient client)
{
Friend[] = (Friend[])client.GetConnection().ExecuteCommandForResult("getFriends:" + user.Name);
...
}
Ici, DisplayFriends fonctionne inutilement manuellement avec la connexion derrière le client Facebook afin d'obtenir ce dont il a besoin. La classe de DisplayFriends est couplée à la fois à FacebookClient et Connection. Si FacebookClient change soudainement le type de connexion qu'il utilise, l'application ne pourra plus obtenir les amis Facebook. Nous pouvons supprimer le couplage entre la classe DisplayFriends et Connection en demandant à FacebookClient de fournir ce dont nous avons besoin pour nous.
//Inside a class meant to display info for a particular Facebook user.
void DisplayFriends(FacebookUser user, FacebookClient client)
{
Friend[] = client.GetFriends(user);
...
}
Maintenant, peu nous importe comment FacebookClient obtient nos amis. Tout ce qui nous tient vraiment à cœur, c'est le fait que cela les obtienne. Tout changement apporté à son comportement interne n'endommagera pas notre propre classe.
Ce type de découplage peut être facilement réalisé en suivant la loi de Déméter pour les fonctions, qui dit (citant Wikipedia):
La loi de Déméter pour les fonctions exige qu'une méthode m d'un objet O ne puisse invoquer que les méthodes des types d'objets suivants:
- O lui-même
- paramètres de m
- Tous les objets créés/instanciés dans m
- Objets composants directs d'O
- Une variable globale, accessible par O, dans le cadre de m
Comme j'ai mentionné le couplage temporel au début de la réponse, je vais le décrire brièvement.
Le couplage temporel est normalement pris en compte lors de la conception d'applications qui exécutent des algorithmes en parallèle. Considérons deux unités exécutables (qu'il s'agisse d'instructions, de méthodes ou de tout ce que vous souhaitez considérer comme une unité), A et B. Nous disons que A est temporellement couplé à B si B doit être exécuté avant l'exécution de A. Si A n'est pas couplé temporellement à B, A et B peuvent être exécutés en même temps. Construisez votre propre exemple pour celui-ci: pensez aux choses habituelles que vous faites dans votre vie quotidienne. Y a-t-il deux choses que vous faites l'une après l'autre, mais que vous pourriez faire en même temps?
Enfin, pour répondre à votre dernier bit:
Dois-je le savoir/l'étudier en tant que développeur web?
Oui. Par exemple, l'un des modèles de conception les plus populaires pour le développement Web (MVC) concerne le découplage.
Les autres réponses décrivent bien ce qu'est le découplage. Je voulais discuter de votre dernière question.
Dois-je le savoir/l'étudier en tant que développeur web?
La réponse est un oui catégorique. Peu importe le type de développeur que vous êtes. Vous pouvez être développeur Web ou développeur de systèmes embarqués.
Supposons que vous ayez une classe qui génère des URL personnalisées qui sont placées sur votre page Web. Vous pourriez être tenté de demander à la classe d'écrire les URL directement sur la page, en les plaçant dans le href d'une balise a. Cela peut sembler plus simple au premier abord. Mais que se passe-t-il lorsque vous devez apporter une modification pour mettre les liens dans un e-mail et les envoyer à un utilisateur? Votre code actuel ne fonctionnerait pas car votre générateur d'URL est étroitement couplé au framework Web que vous utilisez.
La meilleure option serait d'avoir une classe de générateur d'URL qui renvoie l'URL sous forme de chaîne. Cela pourrait être utilisé par votre code Web et il pourrait également être utilisé par votre code de messagerie. Il peut sembler plus de travail d'avance pour avoir un code découplé, mais l'effort se paie au fil du temps.
Le fait d'avoir du code modulaire et découplé rendra votre code plus compréhensible, plus testable et plus maintenable, quel que soit le domaine de programmation dans lequel vous travaillez.