Qual è la differenza tra coesione e accoppiamento?

In che modo l'accoppiamento e la coesione possono portare a una progettazione software buona o scarsa?

Quali sono alcuni esempi che evidenziano la differenza tra i due e il loro impatto sulla qualità complessiva del codice?

Coesione si riferisce a ciò che la classe (o il modulo) può fare. Una bassa coesione significherebbe che la classe compie una grande varietà di azioni - è ampia, non focalizzata su ciò che dovrebbe fare. Alta coesione significa che la classe è focalizzata su ciò che dovrebbe fare, cioè solo sui metodi relativi all'intenzione della classe.

Esempio di bassa coesione:

-------------------
| Staff           |
-------------------
| checkEmail()    |
| sendEmail()     |
| emailValidate() |
| PrintLetter()   |
-------------------

Esempio di alta coesione:

----------------------------
| Staff                   |
----------------------------
| -salary                 |
| -emailAddr              |
----------------------------
| setSalary(newSalary)    |
| getSalary()             |
| setEmailAddr(newEmail)  |
| getEmailAddr()          |
----------------------------

Per quanto riguarda l' accoppiamento , si riferisce a come due classi / moduli correlati o dipendenti siano l'uno verso l'altro. Per le classi a basso accoppiamento, cambiare qualcosa di importante in una classe non dovrebbe influire sull'altra. Un accoppiamento elevato renderebbe difficile modificare e mantenere il codice; poiché le classi sono strettamente legate tra loro, apportare una modifica potrebbe richiedere un rinnovamento dell'intero sistema.

Il buon design del software ha un'elevata coesione e un basso accoppiamento .

La coesione è l'indicazione della relazione all'interno di un modulo.

L'accoppiamento è l'indicazione delle relazioni tra i moduli.

Coesione

• La coesione è l'indicazione della relazione all'interno del modulo.
• La coesione mostra la relativa forza funzionale del modulo.
• La coesione è un grado (qualità) a cui un componente / modulo si concentra sulla singola cosa.
• Durante la progettazione, dovresti cercare di ottenere una coesione elevata, ovvero un componente / modulo coesivo focalizzato su un singolo compito (cioè, concentrazione) con poca interazione con altri moduli del sistema.
• La coesione è il tipo di estensione naturale dei dati nascosti, ad esempio la classe con tutti i membri visibili con un pacchetto con visibilità predefinita. Cohesion is Intra - Module Concept.

accoppiamento

• L'accoppiamento è l'indicazione delle relazioni tra i moduli.
• L'accoppiamento mostra la dipendenza / interdipendenza relativa tra i moduli.
• L'accoppiamento è il grado in cui un componente / modulo è collegato agli altri moduli.
• Durante la progettazione è necessario cercare un accoppiamento basso, ovvero la dipendenza tra i moduli dovrebbe essere inferiore
• Creare campi privati, metodi privati ​​e classi non pubbliche offre un accoppiamento libero.
• L'accoppiamento è il concetto Inter-Module.

controlla questo link

L'elevata coesione all'interno dei moduli e il basso accoppiamento tra i moduli sono spesso considerati correlati all'alta qualità nei linguaggi di programmazione OO.

Ad esempio, il codice all'interno di ogni classe Java deve avere un'elevata coesione interna, ma essere il più possibile accoppiato al codice in altre classi Java.

Il capitolo 3 di Meyer Object-Oriented Software Construction (2a edizione) è una grande descrizione di questi problemi.

La coesione è un'indicazione di quanto siano correlate e focalizzate le responsabilità di un elemento software.

L'accoppiamento si riferisce alla forza con cui un elemento software è collegato ad altri elementi.

L'elemento software può essere classe, pacchetto, componente, sottosistema o un sistema. E durante la progettazione dei sistemi si consiglia di disporre di elementi software con elevata coesione e supporto di accoppiamento basso .

La bassa coesione si traduce in classi monolitiche che sono difficili da mantenere, comprendere e ridurre la riusabilità. Allo stesso modo, l' accoppiamento elevato si traduce in classi strettamente accoppiate e le modifiche non sono locali, difficili da cambiare e riducono il riutilizzo.

Possiamo prendere uno scenario ipotetico in cui stiamo progettando un tipico monitor capace ConnectionPooldi soddisfare i seguenti requisiti. Si noti che potrebbe sembrare troppo per una classe semplice come, ConnectionPoolma l'intento di base è solo quello di dimostrare basso accoppiamento e alta coesione con alcuni semplici esempi e penso che dovrebbe aiutare.

1. supporto per ottenere una connessione
2. rilasciare una connessione
3. ottenere statistiche sulla connessione rispetto al conteggio degli utilizzi
4. ottenere statistiche sulla connessione vs tempo
5. Memorizzare il recupero della connessione e rilasciare le informazioni in un database per la segnalazione in un secondo momento.

Con una bassa coesione potremmo progettare una ConnectionPoolclasse inserendo con forza tutte queste funzionalità / responsabilità in una singola classe come di seguito. Possiamo vedere che questa singola classe è responsabile della gestione della connessione, interagendo con il database e mantenendo le statistiche di connessione.

Con l' alta coesione possiamo assegnare queste responsabilità tra le classi e renderle più sostenibili e riutilizzabili.

Per dimostrare l' accoppiamento basso continueremo con il ConnectionPooldiagramma ad alta coesione sopra. Se osserviamo il diagramma sopra, sebbene supporti l'alta coesione, ConnectionPoolè strettamente associato alla ConnectionStatisticsclasse e PersistentStoreinteragisce direttamente con essi. Invece per ridurre l'accoppiamento potremmo introdurre ConnectionListenerun'interfaccia e lasciare che queste due classi implementino l'interfaccia e permettano loro di registrarsi con la ConnectionPoolclasse. E ConnectionPoolitererà attraverso questi ascoltatori e notificherà loro gli eventi di connessione e rilascio e consente un minor accoppiamento.

Nota / Parola o Attenzione: per questo semplice scenario può sembrare eccessivo, ma se immaginiamo uno scenario in tempo reale in cui la nostra applicazione deve interagire con più servizi di terze parti per completare una transazione: Accoppiamento diretto del nostro codice con i servizi di terze parti significherebbe che eventuali modifiche al servizio di terze parti potrebbero comportare modifiche al nostro codice in più punti, invece potremmo avere Facadeche interagisca internamente con questi servizi multipli e qualsiasi modifica ai servizi diventi locale Facadee imponga un basso accoppiamento con la terza parte Servizi.

L'aumento della coesione e la riduzione dell'accoppiamento portano a una buona progettazione del software.

La coesione suddivide la tua funzionalità in modo che sia concisa e vicina ai dati ad essa rilevanti, mentre il disaccoppiamento garantisce che l'implementazione funzionale sia isolata dal resto del sistema.

Il disaccoppiamento consente di modificare l'implementazione senza influire su altre parti del software.

La coesione assicura che l'implementazione sia più specifica per la funzionalità e allo stesso tempo più facile da mantenere.

Il metodo più efficace per ridurre l'accoppiamento e aumentare la coesione è la progettazione per interfaccia .

Ciò significa che gli oggetti funzionali principali dovrebbero "conoscersi" solo attraverso l'interfaccia o le interfacce che implementano. L'implementazione di un'interfaccia introduce la coesione come conseguenza naturale.

Anche se non realistico in alcuni senari, dovrebbe essere un obiettivo di progettazione per cui lavorare.

Esempio (molto impreciso):

public interface IStackoverFlowQuestion
      void SetAnswered(IUserProfile user);
      void VoteUp(IUserProfile user);
      void VoteDown(IUserProfile user);
}

public class NormalQuestion implements IStackoverflowQuestion {
      protected Integer vote_ = new Integer(0);
      protected IUserProfile user_ = null;
      protected IUserProfile answered_ = null;

      public void VoteUp(IUserProfile user) {
           vote_++;
           // code to ... add to user profile
      }

      public void VoteDown(IUserProfile user) {
          decrement and update profile
      }

      public SetAnswered(IUserProfile answer) {
           answered_ = answer
           // update u
      }
}

public class CommunityWikiQuestion implements IStackoverflowQuestion {
     public void VoteUp(IUserProfile user) { // do not update profile }
     public void VoteDown(IUserProfile user) { // do not update profile }
     public void SetAnswered(IUserProfile user) { // do not update profile }
}

Alcuni altri posti nella tua base di codice potrebbero avere un modulo che elabora le domande indipendentemente da cosa siano:

public class OtherModuleProcessor {
    public void Process(List<IStackoverflowQuestion> questions) {
       ... process each question.
    }
}

la migliore spiegazione di Cohesion deriva dal codice pulito di zio Bob:

Le classi dovrebbero avere un numero limitato di variabili di istanza. Ciascuno dei metodi di una classe dovrebbe manipolare una o più di quelle variabili. In generale, più variabili un metodo manipola, più il metodo è coerente con la sua classe . Una classe in cui ogni variabile viene utilizzata da ciascun metodo è al massimo coesiva.

In generale non è né consigliabile né possibile creare classi così al massimo coesive; d'altra parte, vorremmo che la coesione fosse alta . Quando la coesione è alta, significa che i metodi e le variabili della classe sono co-dipendenti e si bloccano insieme come un tutto logico.

La strategia di mantenere piccole le funzioni e di mantenere brevi gli elenchi di parametri può talvolta portare a una proliferazione di variabili di istanza utilizzate da un sottoinsieme di metodi. Quando ciò accade, significa quasi sempre che c'è almeno un'altra classe che cerca di uscire dalla classe più grande. Dovresti provare a separare le variabili e i metodi in due o più classi in modo tale che le nuove classi siano più coerenti.

semplicemente, la coesione rappresenta il grado in cui una parte di una base di codice forma un'unità atomica logicamente singola. L'accoppiamento , d'altra parte, rappresenta il grado in cui una singola unità è indipendente dalle altre. In altre parole, è il numero di connessioni tra due o più unità. Minore è il numero, minore è l'accoppiamento.

In sostanza, elevata coesione significa mantenere parti di una base di codice correlate tra loro in un unico posto. Il basso accoppiamento, allo stesso tempo, consiste nel separare il più possibile parti non correlate della base di codice.

Tipi di codice dal punto di vista della coesione e dell'accoppiamento:

Ideale è il codice che segue le linee guida. È liberamente accoppiato e altamente coesivo. Possiamo illustrare tale codice con questa immagine:

God Object è il risultato dell'introduzione di elevata coesione e alto accoppiamento. È un anti-pattern e sostanzialmente rappresenta un singolo pezzo di codice che fa tutto il lavoro in una sola volta: la selezione scarsa avviene quando i confini tra le diverse classi o moduli sono selezionati male

Il disaccoppiamento distruttivo è il più interessante. A volte si verifica quando un programmatore tenta di disaccoppiare una base di codice così tanto che il codice perde completamente la sua attenzione:

leggi di più qui

La coesione nell'ingegneria del software è il grado in cui gli elementi di un determinato modulo si uniscono. Quindi, è una misura di quanto fortemente correlata sia ogni parte di funzionalità espressa dal codice sorgente di un modulo software.

L'accoppiamento in parole semplici è quanto un componente (di nuovo, immagina una classe, anche se non necessariamente) conosce i meccanismi interni o gli elementi interni di un altro, cioè quanta conoscenza ha dell'altro componente.

Ho scritto un post sul blog su questo , se vuoi leggere qualche dettaglio in più con esempi e disegni. Penso che risponda alla maggior parte delle tue domande.

coesione si riferisce a come viene progettata una singola classe. La coesione è il principio orientato agli oggetti più strettamente associato all'accertarsi che una classe sia progettata con un unico scopo ben focalizzato. Più una classe è focalizzata, la coesione di quella classe è maggiore. I vantaggi dell'alta coesione sono che tali classi sono molto più facili da mantenere (e cambiate meno frequentemente) rispetto alle classi a bassa coesione. Un altro vantaggio dell'alta coesione è che le classi con uno scopo ben focalizzato tendono ad essere più riutilizzabili rispetto ad altre classi.

Nell'immagine sopra, possiamo vedere che in bassa coesione solo una classe è responsabile di eseguire molti lavori che non sono in comune, il che riduce le possibilità di riutilizzabilità e manutenzione. Ma in alta coesione esiste una classe separata per tutti i lavori per eseguire un lavoro specifico, che si traduce in una migliore usabilità e manutenzione.

Coesione (Co-esione): Co che significa insieme , esione che significa attaccare . Il sistema di attaccamento di particelle di diverse sostanze.

Per esempio nella vita reale: img Courtesy

Tutto è maggiore della somma delle parti -Aristotle.

• La coesione è un tipo ordinario di misurazione ed è generalmente descritta come "alta coesione" o "bassa coesione". I moduli con elevata coesione tendono ad essere preferibili, poiché l'elevata coesione è associata a diversi tratti desiderabili del software tra cui robustezza, affidabilità, riusabilità e comprensibilità. Al contrario, la bassa coesione è associata a tratti indesiderati come essere difficili da mantenere, testare, riutilizzare o persino comprendere. wiki

• L'accoppiamento è di solito contrastato con la coesione . Il basso accoppiamento spesso si correla con l'alta coesione e viceversa. Il basso accoppiamento è spesso un segno di un sistema informatico ben strutturato e di un buon design e, se combinato con elevata coesione, supporta gli obiettivi generali di alta leggibilità e manutenibilità. wiki

Penso che le differenze possano essere poste come segue:

• La coesione rappresenta il grado in cui una parte di una base di codice forma un'unità atomica logicamente singola.
• L'accoppiamento rappresenta il grado in cui una singola unità è indipendente dalle altre.
• È impossibile archiviare il disaccoppiamento completo senza danneggiare la coesione e viceversa.

In questo post del blog ne scrivo più in dettaglio.

La coesione è un'indicazione della forza funzionale relativa di un modulo.

• Un modulo coeso esegue una singola attività, richiedendo una scarsa interazione con altri componenti in altre parti di un programma. Detto semplicemente, un modulo coerente dovrebbe (idealmente) fare solo una cosa.

•  Visione convenzionale:

  la "risolutezza" di un modulo

• OO vista:

  La coesione implica che un componente o una classe incapsula solo gli attributi e le operazioni strettamente correlati tra loro e alla classe o al componente stesso

• Livelli di coesione

  Functional

  Layer

  Communicational

  Sequential

  Procedural

  Temporal

  utility

L'accoppiamento è un'indicazione della relativa interdipendenza tra i moduli.

• L'accoppiamento dipende dalla complessità dell'interfaccia tra i moduli, dal punto in cui viene inserito o fatto riferimento a un modulo e quali dati passano attraverso l'interfaccia.

• Vista convenzionale: il grado in cui un componente è collegato ad altri componenti e al mondo esterno

• Vista OO: una misura qualitativa del grado a cui le classi sono collegate tra loro

• Livello di accoppiamento

  Content

  Common

  Control

  Stamp

  Data

  Riattiva chiamata

   Digitare use

  Inclusione o importazione

   N. esterno

Accoppiamento = interazione / relazione tra due moduli ... Coesione = interazione tra due elementi all'interno di un modulo.

Un software è composto da molti moduli. Il modulo è composto da elementi. Considera che un modulo è un programma. Una funzione all'interno di un programma è un elemento.

In fase di esecuzione, l'output di un programma viene utilizzato come input per un altro programma. Questo si chiama interazione da modulo a modulo o processo per elaborare la comunicazione. Questo è anche chiamato come accoppiamento.

All'interno di un singolo programma, l'output di una funzione viene passato a un'altra funzione. Questo si chiama interazione di elementi all'interno di un modulo. Questo è anche chiamato Coesione.

Esempio:

Accoppiamento = comunicazione tra 2 famiglie diverse ... Coesione = comunicazione tra padre-madre-figlio all'interno di una famiglia.

In parole povere, coesione significa che una classe dovrebbe rappresentare un singolo concetto.

L'interfaccia pubblica di una classe è coerente se tutte le funzionalità della classe sono correlate al concetto rappresentato dalla classe. Ad esempio, invece di avere la classe CashRegister, la coesione delle caratteristiche CashRegister e Coin lo rende in 2 classi: CashRegister e Coin.

In accoppiamento , una classe dipende da un'altra quanto utilizza gli oggetti della classe.

Il problema con un elevato accoppiamento è che può creare effetti collaterali. Una modifica in una classe potrebbe causare un errore imprevisto nell'altra classe e potrebbe interrompere l'intero codice.

Generalmente, alta coesione e basso accoppiamento sono considerati OOP di alta qualità.

Il termine coesione è in effetti poco intuitivo per ciò che significa nella progettazione del software.

Il significato comune di coesione è che qualcosa che si attacca bene è unito, che sono caratterizzati da un forte legame come l'attrazione molecolare. Tuttavia, nella progettazione del software, significa lottare per una classe che idealmente fa solo una cosa, quindi non sono nemmeno coinvolti più sottomoduli.

Forse possiamo pensarlo in questo modo. Una parte ha più coesione quando è l'unica parte (fa solo una cosa e non può essere ulteriormente scomposta). Questo è ciò che si desidera nella progettazione del software. Coesione è semplicemente un altro nome per "responsabilità singola" o "separazione delle preoccupazioni".

Il termine accoppiamento sulla mano è abbastanza intuitivo, il che significa che quando un modulo non dipende da troppi altri moduli e quelli a cui si collega possono essere facilmente sostituiti, ad esempio obbedendo al principio di sostituzione di Mosca .

Teoria Differenza

Coesione

• La coesione è un'indicazione della forza funzionale relativa del modulo.
• Un modulo coeso esegue una singola attività, richiedendo poca interazione con altri componenti in altre parti del programma.
• Si dice che un modulo ad alta coesione e basso accoppiamento sia funzionalmente indipendente da altri moduli.

Classificazione della coesione

1. Casuale 2. Logico 3. Temporale 4. Processo 5. Comunicazione 6. Potenziale 7. Funzionale

accoppiamento

• L'accoppiamento è un'indicazione della relativa interdipendenza tra i moduli.
• Il grado di accoppiamento tra due moduli dipende dalla complessità dell'interfaccia.