Differenza tra coesione e accoppiamento

https://stackoverflow.com/questions/3085285

oop
ooad

28-09-2019
|

Domanda

Qual è la differenza tra coesione e accoppiamento?

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

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

Soluzione

di coesione si riferisce a ciò che la classe (o modulo) può fare. Bassa coesione vorrebbe dire che la classe fa un grande varietà di azioni - è ampia, focalizzata su quello che dovrebbe fare. Alte mezzi di coesione che la classe è focalizzata su quello che dovrebbe fare, ossia solo i metodi relativi alla volontà della classe.

Esempio di bassa coesione:

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

Esempio di High Cohesion:

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

Come per accoppiamento , si riferisce al modo correlati o dipendenti due classi / moduli sono uno verso l'altro. Per basse accoppiato classi, cambiando qualcosa di importante in una classe non dovrebbe pregiudicare l'altro. Alta accoppiamento renderebbe difficile cambiare e mantenere il proprio codice; dal momento che le classi sono strettamente uniti insieme, fare un cambiamento potrebbe richiedere un intero rinnovamento di sistema.

Una buona progettazione del software ha alta coesione e basso accoppiamento .

Altri suggerimenti

alta coesione all'interno moduli e basso accoppiamento tra moduli sono spesso considerati come riferito all'alta qualità dei linguaggi di programmazione OO.

Ad esempio, il codice all'interno di ciascuna classe Java deve avere elevata coesione interna, ma essere logicamente disconnesse possibile al codice in altre classi Java.

Object-Oriented Software Construction di Meyer (2 ° edizione) è una grande descrizione di questi problemi.

Coesione è l'indicazione della relazione entro un modulo.

Accoppiamento è l'indicazione delle relazioni fra moduli.

Coesione

La coesione è l'indicazione della relazione all'interno del modulo.
La coesione mostra la forza funzionale relativa del modulo.
La coesione è un grado (qualità) a cui un componente / modulo si concentra sulla singola cosa.
Durante la progettazione dovresti lottare per la coesione ad alta coesione, cioèUn componente/ modulo coeso si concentra su un'unica attività (cioè una singola mentalità) con poca interazione con altri moduli del sistema.
La coesione è il tipo di estensione naturale dei dati che si nascondono, ad esempio, la classe ha tutti i membri visibili con un pacchetto con visibilità predefinita.La coesione è il concetto intra-modulare.

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 dovresti cercare di ottenere un accoppiamento basso, ad es.la dipendenza tra i moduli dovrebbe essere inferiore
La creazione di campi privati, metodi privati e classi non pubbliche fornisce un accoppiamento lento.
L'accoppiamento è il concetto Inter-Modulo.

controllo Questo collegamento

di coesione è un'indicazione di quanto connesse e concentrate le responsabilità di un elemento software sono.

Accoppiamento si riferisce a quanto fortemente un elemento software è collegato ad altri elementi.

L'elemento software potrebbe essere di classe, pacchetto, componente, sottosistema o un sistema. E, mentre la progettazione dei sistemi si raccomanda di avere elementi software che hanno Alta coesione e il supporto Basso accoppiamento .

Bassa coesione risultati nelle classi monolitici che sono difficili da mantenere, capire e riduce ri-usablity. Analogamente accoppiamento alto risultati delle classi che sono strettamente accoppiati e modifiche non tendono essere non locale, difficile cambiare e riduce il riutilizzo.

Siamo in grado di prendere un ipotetico scenario in cui stiamo progettando un ConnectionPool tipica del monitor-in grado con i seguenti requisiti. Si noti che, potrebbe sembrare troppo per una semplice classe come ConnectionPool ma l'intento di base è solo per dimostrare la basso accoppiamento e alta coesione con qualche semplice esempio e credo che dovrebbe aiutare .

Supporto ottenere una connessione
rilasciare una connessione
ottenere statistiche sulla connessione vs l'uso del numero
ottenere statistiche circa connessione vs tempo
Memorizzare le informazioni di connessione recupero e il rilascio di una banca dati per la segnalazione successiva.

bassa coesione potremmo progettare una classe ConnectionPool farcendo con forza tutte queste funzionalità / responsabilità in una singola classe come di seguito. Possiamo vedere che questa singola classe è responsabile per la gestione delle connessioni, interagendo con il database, nonché il mantenimento di statistiche di connessione.

alta coesione possiamo assegnare queste responsabilità tra le classi e renderlo più gestibile e riutilizzabile.

Per dimostrare Basso accoppiamento si continuerà con il diagramma ConnectionPool alta coesione sopra. Se osserviamo il diagramma sopra sebbene supporti elevata coesione, l'ConnectionPool è strettamente accoppiato con classe ConnectionStatistics e PersistentStore interagisce direttamente con loro. Invece di ridurre l'accoppiamento potremmo introdurre un'interfaccia ConnectionListener e lasciare che queste due classi implementano l'interfaccia e lasciarli registrano con classe ConnectionPool. E il ConnectionPool itererà attraverso questi ascoltatori e comunica loro connessione GET e Stampa Eventi e permette meno di accoppiamento.

Nota / Word o Attenzione: Per questa semplice scenario può apparire come un peso inutile, ma se noi immaginare uno scenario in tempo reale in cui le nostre esigenze di applicazione di interagire con i molteplici servizi di terze parti per completare una transazione : Direttamente accoppiando il nostro codice con i servizi di terze parti significherebbe che eventuali variazioni del servizio di terze parti potrebbero comportare modifiche al nostro codice in diversi punti, invece potremmo avere Facade che interagisce con queste molteplici servizi internamente e le eventuali modifiche ai servizi diventano locale al Facade e far rispettare basso accoppiamento con i servizi di terze parti.

Una maggiore coesione e una diminuzione di accoppiamento di piombo do alla buona progettazione del software.

coesione suddivide la funzionalità in modo che esso sia sintetico e più vicina ai rispettivi dati, mentre disaccoppiamento garantisce che l'implementazione funzionale è isolato dal resto del sistema.

Il disaccoppiamento permette di cambiare l'implementazione senza influenzare altre parti del software.

coesione assicura che l'attuazione più specifico la funzionalità e allo stesso tempo facile da mantenere.

Il metodo più efficace per diminuire l'accoppiamento ed accrescere la coesione è disegno dall'interfaccia .

Questo è il principali oggetti funzionali dovrebbero solo 'conoscere' l'un l'altro attraverso l'interfaccia (s), che attuano. L'implementazione di un introduce interfaccia di coesione come una conseguenza naturale.

Mentre non è realistico in alcuni senarios dovrebbe essere un obiettivo di progettazione per il lavoro da.

Esempio (molto superficiale):

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 dove altro nel vostro codice di base si potrebbe avere un modulo che elabora domande indipendentemente da quello che sono:

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

migliore spiegazione di di coesione viene dal codice pulito dello zio Bob:

Le classi dovrebbero avere un piccolo numero di variabili di istanza. Ognuno dei metodi di una classe dovrebbe manipolare una o più di queste variabili. In generale, il più variabili un metodo manipola la più coese che metodo è quello di sua classe . Una classe in cui ogni variabile è utilizzato da ciascun metodo massimamente coerente.

In generale non è né consigliabile né possibile creare tali classi al massimo di coesione; d'altra parte, vorremmo coesione ad essere elevato . Quando la coesione è alto, significa che i metodi e le variabili della classe sono co-dipendenti e appendere insieme come una logica complesso.

La strategia di mantenere le funzioni di piccole e tenere elenchi di parametri breve a volte può portare a una proliferazione di variabili di istanza che sono utilizzati da un sottoinsieme di metodi. Quando questo accade, significa quasi sempre che ci sia almeno un altro di classe cercando di uscire della classe più grande. Si dovrebbe cercare di separare le variabili e metodi in due o più classi in modo che le nuove classi sono più coesa.

di coesione in ingegneria del software è il grado in cui gli elementi di un certo modulo appartengono insieme. Pertanto, è una misura di quanto fortemente legato ogni pezzo di funzionalità espressa dal codice sorgente di un modulo software sia.

Accoppiamento in parole semplici, è quanto componente una (di nuovo, esista una classe, anche se non necessariamente) conosce il funzionamento interno o elementi interni di un altro, ossia quanta conoscenza che ha di l'altro componente.

ho scritto un post su questo blog , se si vuole leggere in un po 'più particolari con esempi e disegni. Penso che risponde maggior parte delle vostre domande.

semplicemente, coesione rappresenta il grado in cui una parte di un codice di base forma una singola unità logica, atomico. Accoppiamento , invece, rappresenta il grado in cui una singola unità è indipendente dagli altri. In altre parole, è il numero di connessioni tra due o più unità. Il minore è il numero, minore l'accoppiamento.

In sostanza, significa alto coesione mantenere parti di una base di codice che sono collegate tra loro in un unico luogo. Accoppiamento basso, allo stesso tempo, è circa separare parti non collegati del codice di base per quanto possibile.

Tipi di codice da una prospettiva coesione e accoppiamento:

ideale è il codice che segue la linea guida. È debolmente accoppiati e altamente coesivo. Possiamo illustrare tale codice con questa immagine:

Dio oggetto è il risultato di introdurre alta coesione e accoppiamento alto. Si tratta di un anti-modello e fondamentalmente è sinonimo di un unico pezzo di codice che fa tutto il lavoro in una volta: mal selezionato ha luogo quando i confini tra le diverse classi o moduli sono selezionati mal < img src = "https://i.stack.imgur.com/OGJ5W.png" alt = "entrare descrizione dell'immagine qui">

disaccoppiamento Distruttivo è il più interessante. A volte si verifica quando un programmatore tenta di separare una base di codice, tanto che il codice perde completamente la sua attenzione: < img src = "https://i.stack.imgur.com/ZiA3f.png" alt = "entrare descrizione dell'immagine qui">

Per saperne di più qui

coesione si riferisce tutto su come una singola classe è stato progettato. La coesione è il principio Object Oriented più strettamente associata a fare in modo che una classe è stato progettato con un unico scopo, ben focalizzato. Il più mirato una classe è, la coesione di questa classe è più. I vantaggi di elevata coesione è che tali classi sono molto più facile mantenere (e meno frequentemente cambiato) di classi con bassa coesione. Un altro vantaggio di alta coesione è che le classi con uno scopo ben focalizzato tendono ad essere più riutilizzabile rispetto ad altre classi.

Nell'immagine qui sopra, possiamo vedere che in condizioni di scarsa coesione sola classe è responsabile di eseguire un sacco di lavoro che non sono in comune, che riduce il rischio di riutilizzabilità e la manutenzione. Ma in alta coesione c'è una classe separata per tutti i lavori da eseguire un lavoro specifico, che risultano una migliore usabilità e la manutenzione.

di coesione (coesione): Co , che significa insieme , coesio , che significa a bastone . Il Sistema di attaccare insieme di particelle di sostanze diverse.

Ad esempio di vita reale:

img cortesia

tutto è maggiore della somma delle parti -Aristotele.

coesione è un tipo ordinale di misura e di solito è descritto come “coesione alta” o “bassa coesione”. Moduli con elevata coesione tendono ad essere preferibile, perché coesione alta è associata a diversi tratti desiderabili di software compreso robustezza, affidabilità, riutilizzabilità, e comprensibilità. Al contrario, bassa coesione è associato con caratteristiche indesiderabili come essere difficile da mantenere, prova, riutilizzo, o anche capire. wiki
Accoppiamento di solito è in contrasto con coesione . Accoppiamento basso spesso correla con elevata coesione, e viceversa. Accoppiamento basso è spesso un segno di un sistema informatico ben strutturato e un buon design, e quando combinato con alta coesione, sostiene gli obiettivi generali di alta leggibilità e la manutenibilità. wiki

Credo che le differenze possono essere messi come il seguente:

coesione rappresenta il grado in cui una parte di un codice di base forma una singola unità logica, atomico.
Accoppiamento rappresenta il grado in cui una singola unità è indipendente dagli altri.
È possibile archiviare disaccoppiamento completo senza danneggiare la coesione, e viceversa.

In questo post del blog scrivo su di esso in modo più dettagliato .

Coesione è un'indicazione della forza funzionale relativa di un modulo.

Un modulo coeso esegue un singolo compito, richiedendo poco interazione con altri componenti in altre parti di un programma.Dichiarato Semplicemente, un modulo coeso dovrebbe (idealmente) fare solo una cosa.
Vista convenzionale:

la “unicità” di un modulo
Vista OO:

La coesione implica che un componente o una classe incapsula solo attributi e operazioni che sono strettamente correlati tra loro e con la classe o il componente stesso
Livelli di coesione

Funzionale

Livello

Comunicativo

Sequenziale

Procedurale

Temporale

utilità

Accoppiamento è un'indicazione della relativa interdipendenza tra i moduli.

L'accoppiamento dipende dalla complessità dell'interfaccia tra i moduli, dal punto in cui viene effettuata l'immissione o il riferimento a un modulo e quali dati passare attraverso l'interfaccia.
Vista convenzionale:Il grado in cui un componente è connesso ad altri componenti e al mondo esterno
Vista OO:una misura qualitativa del grado in cui le classi sono collegate tra loro
Livello di accoppiamento

Contenuto

Comune

Controllo

Timbro

Dati

Chiamata di routine

Digitare uso

Inclusione o importazione

Esterno #

Accoppiamento = interazione / rapporto tra due moduli ... coesione = interazione tra due elementi di un modulo.

Un software è costituito da più moduli. Modulo è composto da elementi. Si consideri un modulo è un programma. Una funzione di un programma è un elemento.

In fase di esecuzione, produzione di un programma viene utilizzato come input per un altro programma. Questo è chiamato modulo all'interazione modulo o processo per la comunicazione di processo. Questo è anche chiamato come accoppiamento.

Da un unico programma, produzione di una funzione viene passata ad un'altra funzione. Questo è chiamato interazione di elementi all'interno di un modulo. Questo è anche chiamato come coesione.

Esempio:

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

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

L'interfaccia pubblica di una classe è coesa se tutte le caratteristiche di classe sono legati al concetto che la classe rappresenta. Ad esempio, invece di avere classe CashRegister, avendo CashRegister e moneta rappresenta la coesione rende in 2 classi -. CashRegister e Coin classe

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

Il problema con accoppiamento alto è che può creare effetti collaterali. Un cambiamento in una classe potrebbe causare un errore imprevisto in altra classe e potrebbe rompere l'intero codice.

Generalmente, alta coesione e basso accoppiamento è considerato OOP alta qualità.

Il termine coesione è davvero un po 'contro intuitivo per quello che significa nella progettazione del software.

coesione significato comune è che qualcosa che si attacca bene insieme, è uniti, che sono caratterizzati da forte legame come attrazione molecolare. Tuttavia nella progettazione del software, esso significa impegnarsi per una classe che fa idealmente solo una cosa, in modo che più sotto-moduli non sono nemmeno coinvolti.

Forse possiamo pensare in questo modo. Una parte ha il maggior coesione quando è l'unica parte (lo fa solo una cosa e non può essere suddiviso ulteriormente). Questo è ciò che si desidera nella progettazione del software. La coesione è semplicemente un altro nome per "single responsabilità" o "separazione degli interessi".

Il termine accoppiamento sulla mano è abbastanza intuitivo quando cioè un modulo non dipende troppi altri moduli e quelli che si connette con può essere facilmente sostituito per esempio obbedire Liskov sostituzione principio .

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow