Quelqu’un peut-il décrire la différence exacte entre un couplage lâche et un couplage serré dans un paradigme orienté object?
Le couplage serré se produit lorsqu’un groupe de classes dépend fortement les uns des autres.
Ce scénario se produit lorsqu’une classe assume trop de responsabilités ou lorsqu’une préoccupation est répartie sur plusieurs classes plutôt que d’avoir sa propre classe.
Le couplage en vrac est obtenu grâce à une conception favorisant la responsabilité unique et la séparation des préoccupations.
Une classe faiblement couplée peut être consommée et testée indépendamment des autres classes (concrètes).
Les interfaces sont un outil puissant à utiliser pour le découplage. Les classes peuvent communiquer via des interfaces plutôt que d’autres classes concrètes, et n’importe quelle classe peut se trouver à l’autre extrémité de cette communication simplement en implémentant l’interface.
Exemple de couplage serré:
class CustomerRepository { private readonly Database database; public CustomerRepository(Database database) { this.database = database; } public void Add(ssortingng CustomerName) { database.AddRow("Customer", CustomerName); } } class Database { public void AddRow(ssortingng Table, ssortingng Value) { } }
Exemple de couplage lâche:
class CustomerRepository { private readonly IDatabase database; public CustomerRepository(IDatabase database) { this.database = database; } public void Add(ssortingng CustomerName) { database.AddRow("Customer", CustomerName); } } interface IDatabase { void AddRow(ssortingng Table, ssortingng Value); } class Database : IDatabase { public void AddRow(ssortingng Table, ssortingng Value) { } }
Un autre exemple ici .
Le chapeau est “faiblement couplé” au corps. Cela signifie que vous pouvez facilement retirer le chapeau sans apporter de modifications à la personne / au corps. Lorsque vous pouvez le faire, alors vous avez “couplage lâche”. Voir ci-dessous pour élaboration.
Pensez à votre peau. C’est collé à votre corps. Ça va comme un gant. Mais que faire si vous vouliez changer la couleur de votre peau du blanc au noir? Pouvez-vous imaginer à quel point il serait douloureux de décoller votre peau, de la teindre, puis de la coller sur etc. Changer votre peau est difficile car elle est étroitement liée à votre corps. Vous ne pouvez simplement pas faire de changements facilement. Il faudrait fondamentalement repenser un être humain pour rendre cela possible.
Dieu n’était pas un bon programmeur orienté object.
Maintenant, pensez à vous habiller le matin. Vous n’aimez pas le bleu? Pas de problème: vous pouvez mettre une chemise rouge à la place. Vous pouvez le faire facilement et sans effort car la chemise n’est pas vraiment liée à votre corps de la même manière que votre peau. La chemise ne sait pas ou se soucie de quel corps il se passe . En d’autres termes, vous pouvez changer de vêtements sans vraiment changer votre corps.
C’est le concept de base en quelques mots.
C’est important car les logiciels changent tout le temps. De manière générale, vous souhaitez pouvoir modifier facilement votre code.
par exemple exemples pratiques
En bref, un couplage lâche rend le code plus facile à modifier. Les réponses ci-dessus fournissent un code qui vaut la peine d’être lu à ce stade.
Atsortingbution d’images .
Dans la conception orientée object, la quantité de couplage fait référence à la façon dont la conception d’une classe dépend de la conception d’une autre classe. En d’autres termes, à quelle fréquence les changements dans la classe A sont-ils liés aux changements de classe B? Un couplage serré signifie que les deux classes changent souvent ensemble, un couplage lâche signifie qu’elles sont pour la plupart indépendantes. En général, un couplage lâche est recommandé car il est plus facile à tester et à maintenir.
Vous pouvez trouver cet article de Martin Fowler (PDF) utile.
Différence de programme entre couplage serré et couplage lâche?
Couplage serré entre les objects Java
class Traveler { Car c=new Car(); void startJourney() { c.move(); } } class Car { void move() { // logic... } }
Couplage lâche entre les objects Java
class Traveler { Vehicle v; public void setV(Vehicle v) { this.v = v; } void startJourney() { v.move(); } }
// ========================= Interface ====================== ==============
Interface Vehicle { void move(); }
// ==================== Interface de véhicule avec plusieurs classes Première classe ====
class Car implements Vehicle { public void move() { // logic } }
// =================== Deuxième classe ================
class Bike implements Vehicle { public void move() { // logic } }
En général, le couplage serré est mauvais mais la plupart du temps, parce qu’il réduit la flexibilité et la réutilisation du code, il rend les changements beaucoup plus difficiles, entrave la testabilité, etc.
L’object à couplage serré est un object qui nécessite une connaissance approfondie les uns des autres et qui dépend généralement beaucoup des interfaces des autres. Changer un object dans une application étroitement couplée nécessite souvent de modifier un certain nombre d’autres objects. Dans les petites applications, nous pouvons facilement identifier les modifications et il y a moins de chance de manquer quelque chose. Mais dans les grandes applications, ces interdépendances ne sont pas toujours connues par tous les programmeurs ou il y a des chances de manquer les changements. Mais chaque ensemble d’objects faiblement couplés ne dépend pas des autres.
En bref, le couplage lâche est un objective de conception qui vise à réduire les interdépendances entre les composants d’un système dans le but de réduire le risque que les modifications d’un composant nécessitent des modifications dans un autre composant. Le couplage lâche est un concept beaucoup plus générique destiné à accroître la flexibilité d’un système, à le rendre plus maintenable et à rendre l’ensemble du framework plus «stable».
Le couplage fait référence au degré de connaissance directe d’un élément par rapport à un autre. nous pouvons dire par exemple: A et B, seul B modifie son comportement uniquement lorsque A modifie son comportement. Un système faiblement couplé peut être facilement décomposé en éléments définissables.
Lorsque deux objects sont faiblement couplés, ils peuvent interagir mais ont très peu de connaissances les uns des autres.
Les conceptions faiblement couplées nous permettent de construire des systèmes OO flexibles capables de gérer les changements.
Le modèle de conception d’observateur est un bon exemple pour rendre les classes faiblement couplées, vous pouvez y jeter un coup d’oeil dans Wikipedia .
Si je comprends bien, cette architecture étroitement couplée n’offre pas beaucoup de flexibilité en matière de changement par rapport à une architecture faiblement couplée.
Mais dans le cas d’architectures faiblement couplées, de formats de messages ou de plates-formes d’exploitation ou de réorganisation de la logique métier, cela n’a pas d’impact sur l’autre extrémité. Si le système est arrêté pour une réorganisation, bien sûr, l’autre extrémité ne pourra pas accéder au service pendant un certain temps, mais à part cela, la fin inchangée peut reprendre l’échange de messages tel qu’il était avant la réorganisation.
Un extrait de mon blog sur le couplage:
Qu’est-ce que le couplage serré : –
Comme défini ci-dessus, un object étroitement couplé est un object qui doit connaître les autres objects et qui dépend généralement des interfaces des autres.
Lorsque nous modifions un object dans une application étroitement couplée, il faut souvent modifier certains objects. Il n’y a pas de problème dans une petite application, nous pouvons facilement identifier le changement. Mais dans le cas d’applications volumineuses, ces interdépendances ne sont pas toujours connues par tous les consommateurs ou autres développeurs ou il existe de nombreuses possibilités de modifications futures.
Prenons un code de démonstration du panier pour comprendre le couplage étroit:
namespace DNSLooseCoupling { public class ShoppingCart { public float Price; public int Quantity; public float GetRowItemTotal() { return Price * Quantity; } } public class ShoppingCartContents { public ShoppingCart[] items; public float GetCartItemsTotal() { float cartTotal = 0; foreach (ShoppingCart item in items) { cartTotal += item.GetRowItemTotal(); } return cartTotal; } } public class Order { private ShoppingCartContents cart; private float salesTax; public Order(ShoppingCartContents cart, float salesTax) { this.cart = cart; this.salesTax = salesTax; } public float OrderTotal() { return cart.GetCartItemsTotal() * (2.0f + salesTax); } } }
Des problèmes avec l’exemple ci-dessus
Le couplage serré crée certaines difficultés.
Ici, les méthodes OrderTotal()
nous donnent un montant complet pour les articles actuels des chariots. Si nous voulons append les fonctionnalités de remise dans ce système de panier. C’est très difficile à faire dans le code ci-dessus parce que nous devons apporter des modifications à chaque classe car elle est très étroitement liée.
Certains outils fournissent une dependency injection via leur bibliothèque, par exemple dans .net, nous avons ninject Library .
Si vous allez plus loin en Java, le spring offre ces possibilités.
Des objects faiblement couplés peuvent être créés en introduisant des interfaces dans votre code, ce que font ces sources.
Dites dans votre code que vous écrivez
Myclass m = new Myclass();
maintenant cette déclaration dans votre méthode dit que vous êtes dépendant de myclass
cela s’appelle un couplage myclass
. Maintenant que vous fournissez un object d’injection de constructeur ou d’injection de propriété et d’instanciation, il sera couplé de manière lâche.
Le couplage lâche signifie que le degré de dépendance entre deux composants est très faible. Ex.GSM SIM Le couplage serré signifie que le degré de dépendance entre deux composants est très élevé. ex. CDMA Mobile
Le couplage lâche est une réponse aux anciennes dépendances codées et aux problèmes connexes tels que la recompilation fréquente lorsque quelque chose change et que le code est réutilisé. Il insiste sur l’implémentation de la logique de travail dans les composants et évite d’y insérer du code de connexion spécifique à la solution.
Couplage libre = IoC Voir cela pour une explication plus facile.
Loose Coupling est le processus qui consiste à donner indirectement la dépendance à votre classe sans fournir toutes les informations sur la dépendance (à partir de l’interface) au cas où le couplage étroit que vous atsortingbuez directement à la dépendance n’est pas une bonne méthode de codage.
Il s’agit de taux de dépendance des classes par rapport à ceux qui sont si peu couplés et si étroitement couplés. Pour être clair dans l’ architecture d’orientation des services, les services sont faiblement couplés contre des classes monolithiques dont la dépendance mutuelle est volontaire
Le couplage serré signifie qu’une classe dépend d’une autre classe. Le couplage libre signifie qu’une classe dépend de l’interface rathar plutôt que de la classe.
Dans le couplage serré, il existe des dépendances codées en dur dans les méthodes. Dans le couplage en vrac, nous devons transmettre des dépendances en externe au moment de l’exécution au lieu de coder en dur.
Par exemple, nous avons un système qui peut envoyer la sortie de deux manières ou plus, comme JSON-Output, CSV-Output, etc.
Serré
public interface OutputGenerator { public void generateOutput(); } public class CSVOutputGenerator implements OutputGenerator { public void generateOutput() { System.out.println("CSV Output Generator"); } } public class JSONOutputGenerator implements OutputGenerator { public void generateOutput() { System.out.println("JSON Output Generator"); } } // In Other Code, we write Output Generator like... public class Class1 { public void generateOutput() { // Here Output will be in CSV-Format, because of hard-coded code. // This method tightly coupled with CSVOutputGenerator class, if we want another Output, we must change this method. // Any method, that calls Class1's generateOutput will return CSVOutput, because Class1 is tight couple with CSVOutputGenerator. OutputGenerator outputGenerator = new CSVOutputGenerator(); output.generateOutput(); } }
Dans l’exemple ci-dessus, si nous voulons modifier la sortie en JSON, nous devons trouver et modifier tout le code, car Class1 est étroitement lié à la classe CSVOutputGenerator.
Loose Coupled
public interface OutputGenerator { public void generateOutput(); } public class CSVOutputGenerator implements OutputGenerator { public void generateOutput() { System.out.println("CSV Output Generator"); } } public class JSONOutputGenerator implements OutputGenerator { public void generateOutput() { System.out.println("JSON Output Generator"); } } // In Other Code, we write Output Generator like... public class Class1 { public void generateOutput(OutputGenerator outputGenerator) { // if you want to write JSON, pass object of JSONOutputGenerator (Dependency will be passed externally to this method) // if you want to write CSV, pass object of CSVOutputGenerator (Dependency will be passed externally to this method) // Due to loose couple with class, we don't need to change code of Class1, because Class1 is loose coupled with CSVOutputGenerator or JSONOutputGenerator class // Any method, that calls Class1's generateOutput will desired output, because Class1 does not tight couple with CSVOutputGenerator or JSONOutputGenerator class OutputGenerator outputGenerator = outputGenerator; output.generateOutput(); } }
Si la création / existence d’un object dépend d’un autre object qui ne peut pas être adapté, son couplage étroit. Et, si la dépendance peut être adaptée, son couplage lâche. Prenons un exemple en Java:
class Car { private Engine engine = new Engine( "X_COMPANY" ); // this car is being created with "X_COMPANY" engine // Other parts public Car() { // implemenation } }
Le client de la classe Car
peut en créer un avec le moteur “X_COMPANY” UNIQUEMENT.
Pensez à briser ce couplage avec la possibilité de changer cela:
class Car { private Engine engine; // Other members public Car( Engine engine ) { // this car can be created with any Engine type this.engine = engine; } }
Maintenant, une Car
ne dépend pas d’un moteur de “X_COMPANY” car elle peut être créée avec des types.
Une note spécifique à Java: l’ utilisation d’interfaces Java uniquement pour découpler l’image n’est pas une approche de conception correcte. En Java, une interface a un but – agir comme un contrat qui fournit de manière insortingsitive un comportement / avantage de découplage.
Le commentaire de Bill Rosmus dans la réponse acceptée a une bonne explication.