Capire l'accoppiamento sciolto / stretto nel "mondo reale"

Non proprio --- rimuovere il modulo potrebbe interrompere il sistema. L'idea alla base dei sistemi accoppiati è che lo swapping in un modulo completamente diverso funzionerà benissimo fintanto che il nuovo modulo è conforme agli stessi requisiti dell'interfaccia di quello vecchio. Se fosse strettamente accoppiato, il codice circostante farebbe presunzioni sugli interni e inizierebbe a fallire se fosse introdotto un nuovo modulo.

Accoppiamento lento è essenzialmente la dipendenza indiretta tra modulo su come possono evolversi.

Generalmente, quando vi sono sistemi strettamente accoppiati, diversi moduli / oggetti hanno comportamenti molto specifici che presuppongono il comportamento degli oggetti periferici. Tali oggetti sono collegati / accoppiati ad altri comportamenti dei moduli e non possono essere riutilizzati in isolamento o in qualsiasi altro contesto.

Tali moduli anche se responsabili delle singole funzionalità non possono evolversi in modo indipendente o non possono evolvere

Un esempio:

Diciamo che hai 3 oggetti Shape (un oggetto modello) e Canvas (un elemento dell'interfaccia utente). Ora

Supponi che un metodo shape.draw(Canvas) disegni un oggetto sul piano che viene fornito dal piano della tela.

Ora, a volte le finestre sono parzialmente coperte e ridimensionate. In tali casi, il metodo sopra potrebbe semplicemente fare qualcosa di simile.

shape::draw(Canvas) {
   Rect.WindowLeft = Canvas.GetWindowRect.getLeftOffset(); 
   Rect.LeftPixel = Canvas.GetWindowRect.pixels() + Rect.WindowLeft; 
   ....  // like this get all co-ordinates. 

   draw_instance(Rect);  // This will draw the actual shape. 
}

Fondamentalmente, qui la funzione draw richiama il rettangolo dove le cose devono essere disegnate. Questo è facile da capire (la gente potrebbe chiamare questo semplice ) codice. Tuttavia, questo è un codice estremamente accoppiato.

Immagina la situazione:

• Che cosa succede se il meccanismo di conservazione di Windows non è più un rettangolo?
• Cosa succede se ci sono ulteriori compensazioni che Canvas conserva e che sono private ?
• Che cosa succede se alcune altre applicazioni richiedono la stessa forma ma non hanno più una finestra della GUI (ad esempio, sta creando immagini e salvando i file).

La causa principale del problema è che l'oggetto shape conosce e quindi strettamente accoppiato con Canvas .

Che cosa è desiderabile che un set di pixel sia dato per modellare dove scrive? il shape non dovrebbe avere una conoscenza (anche implicita) su dove i pixel sono effettivamente scritti.

Dipende, anche su ciò che specifichi come modulo. Alcune parti del sistema devono essere strettamente accoppiate (ad esempio, le tue entità dovrebbero essere riutilizzate in tutta l'app), ma alcuni sistemi dovrebbero essere liberi, con separazioni di interfaccia, o se stiamo parlando di non rompere l'applicazione se rimuovi il modulo allora quel modulo deve essere cablato in qualche modo in modo dinamico, magari attraverso il contenitore IoC o qualcosa del genere.

Inoltre, l'accoppiamento stretto significa che una parte dipende dall'implementazione del modulo specifico , non dalla definizione di modulo o qualcosa del genere.