Qu'est-ce que "couplage lâche?"Veuillez donner des exemples

je n'arrive pas à analyser le concept de "couplage lâche."Je suppose qu'il n'aide pas que le mot "lâche" a habituellement une connotation négative, donc j'oublie toujours que l'accouplement lâche est une bon chose.

est-ce que quelqu'un peut montrer un code" avant "et" après " (ou un pseudo-code) qui illustre ce concept?

155
demandé sur Md. Alamin Mahamud 2008-10-22 22:23:09

21 réponses

Considérer un simple panier application qui utilise un CartContents classe pour garder une trace des articles dans le panier et une classe de Commande pour le traitement d'un achat. L'ordre doit déterminer la valeur totale du contenu dans le panier, il pourrait le faire comme ceci:

Exemple À Couplage Étroit:

public class CartEntry
{
    public float Price;
    public int Quantity;
}

public class CartContents
{
    public CartEntry[] items;
}

public class Order
{
    private CartContents cart;
    private float salesTax;

    public Order(CartContents cart, float salesTax)
    {
        this.cart = cart;
        this.salesTax = salesTax;
    }

    public float OrderTotal()
    {
        float cartTotal = 0;
        for (int i = 0; i < cart.items.Length; i++)
        {
            cartTotal += cart.items[i].Price * cart.items[i].Quantity;
        }
        cartTotal += cartTotal*salesTax;
        return cartTotal;
    }
}

noter comment la méthode OrderTotal (et donc la classe D'ordre) dépend de la mise en œuvre détails sur les CartContents et les classes CartEntry. Si nous devions essayer de changer cette logique pour tenir compte des rabais, nous aurions probablement à changer les 3 classes. En outre, si nous changeons à l'aide d'une liste de collecte pour garder la trace des articles que nous aurions à changer la classe de commande aussi bien.

maintenant voici une meilleure façon de faire la même chose:

Exemple Moins Couplé:

public class CartEntry
{
    public float Price;
    public int Quantity;

    public float GetLineItemTotal()
    {
        return Price * Quantity;
    }
}

public class CartContents
{
    public CartEntry[] items;

    public float GetCartItemsTotal()
    {
        float cartTotal = 0;
        foreach (CartEntry item in items)
        {
            cartTotal += item.GetLineItemTotal();
        }
        return cartTotal;
    }
}

public class Order
{
    private CartContents cart;
    private float salesTax;

    public Order(CartContents cart, float salesTax)
    {
        this.cart = cart;
        this.salesTax = salesTax;
    }

    public float OrderTotal()
    {
        return cart.GetCartItemsTotal() * (1.0f + salesTax);
    }
}

La logique qui est spécifiques à la mise en œuvre de la ligne panier ou chariot de collecte ou la commande est restreint à la classe. Nous pourrions donc changer l'implémentation de n'importe laquelle de ces classes sans avoir à changer les autres classes. Nous pourrions aller encore plus loin dans ce découplage en améliorant la conception, en introduisant des interfaces, etc., mais je pense que vous voyez l'intérêt.

155
répondu Wedge 2013-04-15 13:06:11

de nombreux produits intégrés (en particulier par Apple) tels que iPods , iPads sont un bon exemple d'accouplement serré: une fois la batterie meurt, vous pourriez aussi bien acheter un nouvel appareil parce que la batterie est soudée fixe et ne se lâche pas, ce qui rend le remplacement très coûteux. Un joueur vaguement couplé permettrait de changer sans effort la batterie.

Le même va pour le développement de logiciels: il est généralement (beaucoup) mieux d'avoir un code vaguement couplé pour faciliter l'extension et le remplacement (et pour rendre les pièces individuelles plus faciles à comprendre). Mais, très rarement, dans des circonstances spéciales, un assemblage serré peut être avantageux car l'intégration étroite de plusieurs modules permet une meilleure optimisation.

140
répondu Konrad Rudolph 2018-07-04 14:50:42

J'utiliserai Java comme exemple. Disons que nous avons une classe qui ressemble à ceci:

public class ABC
{
   public void doDiskAccess() {...}
}

quand j'appelle la classe, je dois faire quelque chose comme ça:

ABC abc = new ABC();

abc. doDiskAccess();

jusqu'ici, tout va bien. Maintenant, disons que j'ai une autre classe qui ressemble à ceci:

public class XYZ
{
   public void doNetworkAccess() {...}
}

il ressemble exactement le même que ABC, mais disons qu'il fonctionne sur le réseau au lieu de sur le disque. Alors maintenant, écrivons un programme comme celui-ci:

if(config.isNetwork()) new XYZ().doNetworkAccess();
else new ABC().doDiskAccess();

ça marche, mais c'est un peu lourd. Je pourrais simplifier cela avec une interface comme celle-ci:

public interface Runnable
{
    public void run();
}

public class ABC implements Runnable
{
   public void run() {...}
}

public class XYZ implements Runnable
{
   public void run() {...}
}

maintenant mon code peut ressembler à ceci:

Runnable obj = config.isNetwork() ? new XYZ() : new ABC();

obj.run();

vous voyez comme c'est propre et simple à comprendre? Nous venons de comprendre le premier principe de base du couplage lâche: l'abstraction. La clé ici est de s'assurer que ABC et XYZ ne dépendent d'aucune méthode ou variable des classes qui les appellent. Qui permet ABC et XYZ doivent être des API complètement indépendantes. En d'autres termes, ils sont "découplés" ou "faiblement couplés" des classes parentales.

mais que faire si nous avons besoin de communication entre les deux? Nous pouvons alors utiliser d'autres abstractions comme un "Event Model pour nous assurer que le code parent n'a jamais besoin de se coupler avec les API que vous avez créées.

47
répondu 64BitBob 2011-05-02 13:13:55

Désolé, mais ce "couplage lâche" n'est pas un problème de codage, c'est un problème de conception. Le terme " couplage lâche "est intimement lié à l'état souhaitable de" haute cohésion", étant opposé mais complémentaire.

assemblage lâche signifie simplement que les éléments de conception individuels doivent être construits de manière à réduire la quantité d'informations inutiles qu'ils doivent connaître sur les autres éléments de conception.

haute cohésion est un peu comme " l'assemblage serré", mais la cohésion élevée est un état où les éléments de conception qui ont vraiment besoin de savoir les uns sur les autres sont conçus de sorte qu'ils travaillent ensemble de manière propre et élégante.

le point est, certains éléments de conception doivent connaître les détails sur d'autres éléments de conception, de sorte qu'ils doivent être conçus de cette façon, et pas accidentellement. Les autres éléments de la conception ne devraient pas connaître les détails des autres éléments de la conception, de sorte qu'ils devraient être conçus de cette façon, à dessein, plutôt que de façon aléatoire.

la mise en œuvre de ce qui est laissé comme un exercice pour le lecteur :) .

36
répondu David M. Karr 2008-10-22 18:30:12

code étroitement couplé repose sur une mise en œuvre concrète. Si j'ai besoin d'une liste de chaînes dans mon code et je le déclare comme ceci (en Java)

ArrayList<String> myList = new ArrayList<String>();

alors je suis dépendant de l'implémentation ArrayList.

si je veux changer cela en code couplé lâche, je fais ma référence un type d'interface (ou autre abstrait).

List<String> myList = new ArrayList<String>();

cela m'empêche d'appeler toute méthode sur myList c'est spécifique à L'implémentation ArrayList. Je suis limité aux méthodes définies dans L'interface List. Si je décide plus tard que j'ai vraiment besoin d'une LinkedList, Je n'ai besoin de changer mon code qu'à un seul endroit, où j'ai créé la nouvelle liste, et pas à 100 endroits où j'ai fait des appels vers des méthodes ArrayList.

bien sûr, vous peut instancier une liste de tableaux à l'aide de la première déclaration, et de retenir-vous de ne pas utiliser toutes les méthodes qui ne font pas partie de L'interface de liste, mais l'utilisation de la deuxième déclaration rend le compilateur vous garder honnête.

33
répondu Bill the Lizard 2008-10-22 18:43:18

vous pouvez penser à l'accouplement (serré ou lâche) comme étant littéralement la quantité d'effort qu'il vous faudrait pour séparer une classe particulière de sa dépendance sur une autre classe. Par exemple, si chaque méthode dans votre classe avait un petit enfin bloc en bas où vous avez fait un appel à Log4Net pour enregistrer quelque chose, alors vous diriez que votre classe était étroitement liée à Log4Net. Si votre classe à la place contenait une méthode privée appelée LogSomething qui était le seul endroit qui a appelé le Log4Net component (et les autres méthodes toutes appelées LogSomething à la place), alors vous diriez que votre classe était vaguement couplée à Log4Net (parce qu'il ne faudrait pas beaucoup d'efforts pour retirer Log4Net et le remplacer par quelque chose d'autre).

23
répondu MusiGenesis 2008-10-22 18:36:28

le degré de différence entre les réponses ici montre pourquoi ce serait un concept difficile à saisir mais pour le dire aussi simplement que je peux le décrire:

pour que je sache que si je te lance une balle, alors tu peux l'attraper, je n'ai vraiment pas besoin de savoir quel âge tu as. Je n'ai pas besoin de savoir ce que tu as mangé au petit déjeuner, et je me fiche de savoir qui était ton premier amour. Tout ce que j'ai besoin de savoir c'est que tu peux attraper. Si je le sais, alors je n'ai pas de soins si sa vous je suis lancer une balle pour vous ou votre frère.

avec des langages non dynamiques comme c# ou Java etc, Nous réalisons ceci via des Interfaces. Donc disons que nous avons l'interface suivante:

public ICatcher
{
   public void Catch();
}

Et maintenant, disons que nous avons les classes suivantes:

public CatcherA : ICatcher
{
   public void Catch()
   {
      console.writeline("You Caught it");
   }

}
public CatcherB : ICatcher
{
   public void Catch()
   {
      console.writeline("Your brother Caught it");
   }

}

maintenant CatcherA et CatcherB mettent en œuvre la méthode Catch, de sorte que le service qui nécessite un receveur peut utiliser l'un ou l'autre de ces et ne pas vraiment donner une importance à laquelle il est. Donc un service étroitement couplé pourrait instanciate directement un catched i.e.

public CatchService
{
   private CatcherA catcher = new CatcherA();

   public void CatchService()
   {
      catcher.Catch();
   }

}

ainsi le CatchService peut faire exactement ce qu'il a prévu de faire, mais il utilise Cathera et sera toujours L'utilisateur Cathera. Elle est codée, donc elle reste là jusqu'à ce que quelqu'un la reforme.

Maintenant, prenons une autre option, appelée injection de dépendance:

public CatchService
{
   private ICatcher catcher;

   public void CatchService(ICatcher catcher)
   {
      this.catcher = catcher;
      catcher.Catch();
   }
}

ainsi le calss qui instanciates CatchService peut faire

CatchService catchService = new CatchService(new CatcherA());

ou

CatchService catchService = new CatchService(new CatcherB());

cela signifie que le service de capture n'est pas étroitement lié à CatcherA ou CatcherB.

il existe plusieurs autres stratégies pour des services de couplage lâche comme celui-ci, comme l'utilisation d'un cadre de recherche des causes, etc.

23
répondu Owen 2008-10-22 23:50:58

définition

essentiellement, le couplage est la mesure dans laquelle un objet ou un ensemble d'objets donné dépend d'un autre objet ou d'un autre ensemble d'objets pour accomplir sa tâche.

Haut De Couplage

Pensez à une voiture. Pour que le moteur démarre, une clé doit être insérée dans l'allumage, tourner, l'essence doit être présente, une étincelle doit se produire, les pistons doivent tirer, et le moteur doit prendre vie. Vous pourriez dire qu'un moteur de voiture est fortement couplé à plusieurs autres objets. C'est un couplage élevé, mais ce n'est pas une mauvaise chose.

Accouplement Lâche

pensez à un contrôle d'utilisateur pour une page Web qui est responsable de permettre aux utilisateurs d'afficher, de modifier et de voir un certain type d'information. Le contrôle unique pourrait être utilisé pour permettre à un utilisateur d'afficher une nouvelle information ou d'éditer une nouvelle information. Le contrôle doit pouvoir être partagé entre deux chemins différents - Nouveau et éditer. Si le contrôle est écrit de telle manière qu'il nécessite un certain type de données à partir des pages qui le contiendront, alors vous pourriez dire qu'il est trop couplé. Le contrôle ne devrait pas avoir besoin de quoi que ce soit de sa page contenant.

12
répondu Tom 2008-10-22 18:36:16

c'est un concept assez général, donc les exemples de code ne vont pas donner une image complète.

un gars ici au travail m'a dit, "les motifs sont comme des fractales, vous pouvez les voir quand vous zoomez très près, et quand vous zoomez jusqu'au niveau de l'architecture."

Lire la brève page wikipedia peut vous donner un sens de cette généralité:

http://en.wikipedia.org/wiki/Loose_coupling

en ce qui concerne un exemple de code spécifique...

voici un accouplement lâche avec lequel j'ai travaillé récemment, de la part de Microsoft.Pratique.CompositeUI stuff.

    [ServiceDependency]
    public ICustomizableGridService CustomizableGridService
    {
        protected get { return _customizableGridService; }
        set { _customizableGridService = value; }
    }

ce code déclare que cette classe a une dépendance sur un Customizabregridservice. Au lieu de simplement renvoyer directement à la mise en œuvre exacte du service, il indique simplement qu'il nécessite une certaine mise en œuvre de ce service. Puis au moment de l'exécution, le système résout cette dépendance.

Si ce n'est pas clair, vous pouvez lire une explication plus détaillée ici:

http://en.wikipedia.org/wiki/Dependency_injection

Imaginez que ABCCustomizableGridService soit l'imlpermentation que j'ai l'intention de brancher ici.

si je le veux, je peux l'enlever et le remplacer par XYZCustomizableGridService, ou StubCustomizableGridService sans changement à tous à la classe avec cette dépendance.

si J'avais directement référencé ABCCustomizableGridService, alors j'aurais besoin d'apporter des changements à cette/ces référence (s) afin d'échanger dans une autre implémentation de service.

7
répondu rice 2008-10-22 18:39:08

Couplage a à faire avec des dépendances entre les systèmes, ce qui pourrait être des modules de code (fonctions, des fichiers ou des classes), des outils dans un pipeline, client-serveur de processus, et ainsi de suite. Moins les dépendances sont Générales, plus elles sont "étroitement liées", car changer un système exige changer les autres systèmes qui en dépendent. La situation idéale est celle du" couplage lâche " où un système peut être modifié et les systèmes qui en dépendent continueront de fonctionner sans modification.

la manière générale de réaliser un accouplement lâche passe par des interfaces bien définies. Si l'interaction entre deux systèmes est bien définie et respectée des deux côtés, il devient plus facile de modifier un système tout en veillant à ce que les conventions ne soient pas enfreintes. Dans la pratique, il arrive souvent qu'aucune interface bien définie ne soit établie, ce qui entraîne une conception négligée et un couplage serré.

quelques exemples:

  • Application dépend d'une bibliothèque. Sous l'accouplement serré, app casse sur les nouvelles versions de la lib. Utilisez Google pour"DLL enfer".

  • L'application Client lit les données d'un serveur. Sous couplage serré, les modifications au serveur nécessitent des corrections du côté client.

  • deux classes interagissent dans une hiérarchie orientée objet. Dans le cas d'un couplage serré, les changements à une classe exigent que l'autre classe soit mise à jour pour correspondre.

  • plusieurs outils de ligne de commande communiquent dans un tuyau. S'ils sont étroitement couplés, les modifications apportées à la version d'un outil en ligne de commande causeront des erreurs dans les outils qui lisent sa sortie.

6
répondu Parappa 2008-10-22 23:20:07

deux composants sont couplés higly quand ils dépendent de la mise en œuvre concrète de l'autre.

supposons que j'ai ce code quelque part dans une méthode de ma classe:

this.some_object = new SomeObject();

maintenant, ma classe dépend D'un objet, et ils sont fortement couplés. D'autre part, disons que j'ai une méthode InjectSomeObject:

void InjectSomeObject(ISomeObject so) { // note we require an interface, not concrete implementation
  this.some_object = so;
}

alors le premier exemple peut juste utiliser injecté un objet. ceci est utile pendant test. avec le fonctionnement normal, vous pouvez utiliser lourd, base de données-using, réseau-using classes etc. lors de tests réussissant une implémentation légère et simulée. avec du code couplé, vous ne pouvez pas faire ça.

vous pouvez rendre certaines parties de ce travail plus facile en utilisant des conteneurs d'injection de dépendances. Vous pouvez en savoir plus sur DI sur Wikipedia: http://en.wikipedia.org/wiki/Dependency_injection .

il est parfois facile d'aller trop loin. à un moment donné, vous devez rendre les choses concrètes, ou votre programme sera moins lisible et compréhensible. Donc, utilisez ces techniques principalement à la frontière des composants, et savoir ce que vous faites. Assurez-vous que vous profitez de l'accouplement lâche. Si non, vous n'avez probablement pas besoin de cela en ce lieu. L'ai peut rendre votre programme plus complexe. Assurez-vous de faire un bon compromis. En d'autres termes, maintenir un bon équilibre. As toujours lors de la conception de systèmes. bonne chance!

4
répondu Paweł Hajdan 2008-10-23 06:44:30

Envisager une application Windows avec FormA et FormB. FormA est la forme primaire et il affiche FormB. Imaginez FormB ayant besoin de transmettre les données à son parent.

si vous avez fait ceci:

class FormA 
{
    FormB fb = new FormB( this );

    ...
    fb.Show();
}

class FormB 
{
    FormA parent;

    public FormB( FormA parent )
    {
        this.parent = parent;
    }     
}

FormB est étroitement couplé à FormA. FormB ne peut avoir d'autre parent que celui de type FormA.

si, d'un autre côté, vous avez demandé à FormB de publier un événement et de vous abonner à cet événement, FormB pourrait repousser les données grâce à cet événement, à quelque abonné que ce soit. Dans ce cas, donc, FormB ne sait même pas qu'il répond à son parent; par le couplage lâche l'événement fournit il est tout simplement parler aux abonnés. N'importe quel type peut maintenant être un parent de FormA.

rp

3
répondu rp. 2008-10-22 18:38:04

En informatique, il est un autre sens de "couplage lâche" que personne n'a posté ici, donc... J'espère que vous me donnerez des voix pour que ce ne soit pas perdu en bas du tas! Le sujet de ma réponse fait certainement partie de toute réponse complète à la question... À savoir:

le terme" Loose Coupling " est entré pour la première fois dans le calcul comme un terme utilisé comme adjectif concernant l'architecture CPU dans une configuration multi-CPU. Son homologue le terme "couplage". Le couplage lâche est quand les CPU ne partagent pas beaucoup de ressources en commun et le couplage serré est quand ils le font.

le terme" système " peut prêter à confusion ici, alors veuillez analyser la situation attentivement.

habituellement, mais pas toujours, les CPU multiples dans une configuration matérielle dans laquelle ils existent dans un système (comme dans les boîtes" PC " individuelles) seraient étroitement couplés. À l'exception de certains systèmes super-haute performance qui ont les sous-systèmes qui partagent la mémoire principale entre les "systèmes", tous les systèmes divisibles sont vaguement couplés.

les termes" étroitement couplé "et" faiblement couplé "ont été introduits avant les CPU multi-filetés et multi-noyaux ont été inventés, de sorte que ces termes peuvent avoir besoin de quelques compagnons pour bien articuler la situation actuelle. Et, en effet, aujourd'hui, on peut très bien avoir un système qui encompases les deux types dans un système global. En ce qui concerne les systèmes logiciels, il y a deux architectures communes, une de chaque variété, qui sont assez communes celles-ci devraient être familliar.

D'abord, comme il s'agissait de savoir de quoi il s'agissait, quelques exemples de systèmes à couplage lâche:

  • VaxClusters
  • Clusters Linux

en revanche, certains exemples étroitement couplés:

  • Semi-Conducteur-Multi-Processing (SMP) Operating systèmes-p.ex. Fedora 9
  • Multi-thread Cpu
  • Multi-Core CPUs

dans l'informatique d'aujourd'hui, il n'est pas rare que les deux systèmes fonctionnent dans un seul système global. Par exemple, prenez les processeurs Pentium dual ou quad core modernes fonctionnant avec Fedora 9 - ce sont des systèmes de calcul étroitement couplés. Puis, combinez plusieurs D'entre eux dans un Cluster Linux faiblement couplé et vous avez maintenant à la fois lâche et étroitement couplé l'informatique passe!!! Oh, ce n'est pas du matériel moderne, merveilleux!

3
répondu Richard T 2008-10-23 17:56:41

couplage se réfère à la façon dont les différentes classes sont étroitement liées les unes aux autres. Étroitement couplé classes contiennent un nombre élevé d'interactions et dépendances.

les classes à couplage lâche sont le contraire en ce sens que leurs dépendances les unes par rapport aux autres sont réduites au minimum et reposent plutôt sur les interfaces publiques bien définies les unes par rapport aux autres.

Legos, les jouets qui s'emboîtent serait considéré comme faiblement couplé parce que vous pouvez juste briser les morceaux ensemble et construire n'importe quel système que vous voulez. Cependant, les pièces d'un puzzle sont étroitement liées. Vous ne pouvez pas prendre une pièce d'un puzzle (système) et la briser dans un autre puzzle, parce que le système (puzzle) est très dépendant des pièces très spécifiques qui ont été construits spécifiques à ce "design"particulier. Les legos sont construits de façon plus générique pour qu'ils puissent être utilisés dans votre maison Lego, ou dans mon Lego Alien Man.

référence: https://megocode3.wordpress.com/2008/02/14/coupling-and-cohesion/

3
répondu user1263981 2016-10-03 11:59:17

en langage simple, vaguement couplé signifie qu'il ne dépend pas d'un autre événement à se produire. Il exécute indépendamment.

3
répondu Ravindra Miyani 2017-04-17 20:56:15

quelques longues réponses ici. Le principe est très simple. Je soumets la déclaration d'ouverture de wikipedia :

"couplage Lâche décrit à la résilience de la relation entre deux ou plusieurs systèmes ou organisations avec une sorte de relation d'échange.

chaque extrémité de la transaction rend ses exigences explicites et fait peu d'hypothèses au sujet de l'autre extrémité."

2
répondu Ben 2008-12-31 13:10:23

je propose un Test très simple test de couplage de Code :

  1. la pièce de code A est étroitement liée à la pièce de code B s'il existe une modification possible à la pièce de code B qui forcerait des changements dans la pièce de code A afin de maintenir l'exactitude.

  2. la pièce de code a n'est pas étroitement liée à la pièce de code B s'il n'y a pas de modification possible à la pièce de code B qui ferait changer en pièce nécessaire.

cela vous aidera à vérifier combien de couplage il y a entre les morceaux de votre code. pour le raisonnement sur ce voir ce billet de blog: http://marekdec.wordpress.com/2012/11/14/loose-coupling-tight-coupling-decoupling-what-is-that-all-about /

2
répondu Marek Dec 2012-11-14 21:51:19

lorsque vous créez un objet d'une classe en utilisant le mot-clé new dans une autre classe, vous faites en fait l'assemblage serré (mauvaise pratique) à la place vous devriez utiliser l'assemblage lâche qui est une bonne pratique

- - - A.java - - -

package interface_package.loose_coupling;

public class A {

void display(InterfaceClass obji)
{
    obji.display();
    System.out.println(obji.getVar());
}
}

- - - B.java - - -

package interface_package.loose_coupling;

public class B implements InterfaceClass{

private String var="variable Interface";

public String getVar() {
    return var;
}

public void setVar(String var) {
    this.var = var;
}

@Override
public void display() {
    // TODO Auto-generated method stub
    System.out.println("Display Method Called");
}
}

- - - InterfaceClass - - -

package interface_package.loose_coupling;

public interface InterfaceClass {

void display();
String getVar();
}

- - - MainClass - - -

package interface_package.loose_coupling;

public class MainClass {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    A obja=new A();
    B objb=new B();
    obja.display(objb);     //Calling display of A class with object of B class 

}
}

explication:

dans l'exemple ci-dessus, nous avons deux classes A et b

Classe B implémente l'Interface c'est à dire InterfaceClass.

InterfaceClass définit un Contrat de classe B dans InterfaceClass ont des méthodes abstraites de la classe B qui peut être l'accès par tout autre classe par exemple A.

dans la Classe A Nous avons la méthode d'affichage qui peut excepté l'objet de la classe qui implémente InterfaceClass (dans notre cas c'est la Classe B). Et sur cet objet la méthode de la classe A appelle display() et getVar() de la Classe B

dans MainClass nous avons créé objet de la Classe A et B. et appelant méthode d'affichage de A en passant objet de la Classe B c'est-à-dire objb. La méthode d'affichage de A sera appelée avec l'objet de la classe B.

parle maintenant d'accouplement lâche. Supposons qu'à l'avenir vous devez changer le nom de la Classe B à ABC alors vous n'avez pas à changer son nom dans la méthode d'affichage de la Classe B, il suffit de faire l'objet de nouveau (ABC class) et le passer à la méthode d'affichage dans MailClass. Vous n'avez pas à changer quoi que ce soit dans la Classe Un

réf: http://p3lang.com/2013/06/loose-coupling-example-using-interface /

1
répondu Abhishek Aggarwal 2015-01-06 08:56:39

Vous pouvez en savoir plus sur le concept générique de "couplage lâche" .

en bref, c'est une description d'une relation entre deux classes, où chaque classe connaît le moins l'autre et chaque classe pourrait potentiellement continuer à travailler très bien que l'autre soit présente ou non et sans dépendre de la mise en œuvre particulière de l'autre classe.

0
répondu Franci Penov 2008-10-22 18:34:29

peut-être que la meilleure métaphore est le mariage.

Quand vous n'êtes pas marié, vous êtes faiblement couplés.

vous pouvez quitter votre partenaire plus facilement.

quand vous "êtes" mariés, vous êtes étroitement liés.

Par exemple, dans certains pays, vous devez payer la pension alimentaire lorsque vous quittez votre partenaire.

-1
répondu user3402571 2016-08-27 19:57:53

couplage lâche, en général, est de deux acteurs travaillant indépendamment l'un de l'autre sur la même charge de travail. Donc, si vous aviez 2 serveurs Web utilisant la même base de données de back-end, alors vous diriez que ces serveurs web sont vaguement couplés. Le couplage serait illustré par avoir 2 processeurs sur un serveur web... ces processeurs sont étroitement couplés.

J'espère que c'est utile.

-7
répondu Steve 2008-10-22 18:27:29