Quelle est la différence entre le couplage lâche et le couplage serré dans le paradigme orienté objet ?

Question

Quelqu'un peut-il décrire la différence exacte entre le couplage lâche et le couplage serré dans le paradigme orienté objet ?

Answer 1

On parle de couplage étroit lorsqu'un groupe de classes est fortement dépendant les unes 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 au lieu d'avoir sa propre classe.

Le couplage lâche est obtenu grâce à une conception qui favorise la responsabilité unique et la séparation des préoccupations.

Une classe faiblement couplée peut être consommée et testée indépendamment d'autres classes (concrètes).

Les interfaces sont un outil puissant à utiliser pour le découplage. Les classes peuvent communiquer par le biais d'interfaces plutôt que d'autres classes concrètes, et n'importe quelle classe peut se trouver à l'autre bout de cette communication simplement en implémentant l'interface.

Exemple de couplage étroit :

class CustomerRepository
{
    private readonly Database database;

    public CustomerRepository(Database database)
    {
        this.database = database;
    }

    public void Add(string CustomerName)
    {
        database.AddRow("Customer", CustomerName);
    }
}

class Database
{
    public void AddRow(string Table, string Value)
    {
    }
}

Exemple de couplage lâche :

class CustomerRepository
{
    private readonly IDatabase database;

    public CustomerRepository(IDatabase database)
    {
        this.database = database;
    }

    public void Add(string CustomerName)
    {
        database.AddRow("Customer", CustomerName);
    }
}

interface IDatabase
{
    void AddRow(string Table, string Value);
}

class Database implements IDatabase
{
    public void AddRow(string Table, string Value)
    {
    }
}

Un autre exemple aquí .

Answer 2

Dans la conception orientée objet, le degré de couplage désigne la mesure dans laquelle 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 forcent-ils des changements connexes dans la classe B ? Un couplage étroit signifie que les deux classes changent souvent ensemble, un couplage lâche signifie qu'elles sont le plus souvent indépendantes. En général, le couplage lâche est recommandé car il est plus facile à tester et à maintenir.

Vous pouvez trouver ce document de Martin Fowler (PDF) utile.

Answer 3

En général, le couplage étroit est mauvais, mais la plupart du temps, car il réduit la flexibilité et la réutilisation du code, il rend les changements beaucoup plus difficiles, il entrave la testabilité, etc.

Un objet étroitement couplé est un objet qui doit en savoir beaucoup sur l'autre et qui est généralement très dépendant des interfaces de l'autre. La modification d'un objet dans une application à couplage étroit nécessite souvent la modification d'un certain nombre d'autres objets. Dans les petites applications, nous pouvons facilement identifier les modifications et il y a moins de risques de manquer quelque chose. Mais dans les grandes applications, ces interdépendances ne sont pas toujours connues de tous les programmeurs ou il y a des chances de manquer des changements. Mais chaque ensemble d'objets faiblement couplés n'est pas dépendant des autres.

En bref, nous pouvons dire que le couplage lâche est un objectif de conception qui cherche à réduire les interdépendances entre les composants d'un système dans le but de réduire le risque que les changements dans un composant nécessitent des changements dans n'importe quel autre composant. Le couplage lâche est un concept beaucoup plus générique destiné à augmenter la flexibilité d'un système, à le rendre plus facile à maintenir et à rendre l'ensemble du cadre plus "stable".

Le couplage se réfère au degré de connaissance directe qu'un élément a d'un autre. on peut dire par exemple que A et B sont des éléments de la même famille : A et B, seulement B change son comportement seulement quand A change son comportement. Un système faiblement couplé peut être facilement décomposé en éléments définissables.

Answer 4

Lorsque deux objets sont faiblement couplés, ils peuvent interagir mais ont très peu de connaissances l'un de l'autre. l'autre.

Les conceptions à couplage lâche nous permettent de construire des systèmes OO flexibles, capables de gérer le changement.

Le modèle de conception Observer est un bon exemple pour rendre les classes faiblement couplées, vous pouvez y jeter un coup d'œil dans le site suivant Wikipedia .

Answer 5

D'après ce que j'ai compris, une architecture à couplage étroit n'offre pas une grande souplesse de changement par rapport à une architecture à couplage lâche.

Mais dans le cas d'architectures à couplage lâche, les formats de messages, les plates-formes d'exploitation ou la refonte de la logique d'entreprise n'ont pas d'incidence sur l'autre extrémité. Si le système est arrêté pour être réorganisé, l'autre extrémité ne pourra bien sûr pas accéder au service pendant un certain temps, mais en dehors de cela, l'extrémité inchangée peut reprendre l'échange de messages comme avant la réorganisation.