Che cosa significa "basso in accoppiamento e alto in coesione"

Ho problemi a comprendere l'affermazione low in coupling and high in cohesion. Ho cercato su Google e letto molto su questo, ma trovo ancora difficile da capire.

Ciò che capisco è High cohesionche dovremmo avere lezioni specializzate per svolgere una particolare funzione. Spero che sia corretto? Come una classe di convalida della carta di credito, specializzata nella convalida solo delle carte di credito.

E ancora non capisci cosa significa accoppiamento basso?

Quello che credo è questo:

La coesione si riferisce al grado in cui gli elementi di un modulo / classe si uniscono, si suggerisce che il codice correlato dovrebbe essere uno vicino all'altro, quindi dovremmo lottare per un'alta coesione e legare tutti i codici correlati il ​​più vicino possibile. Ha a che fare con gli elementi all'interno del modulo / classe.

L'accoppiamento si riferisce al grado in cui i diversi moduli / classi dipendono l'uno dall'altro, si suggerisce che tutti i moduli dovrebbero essere il più indipendenti possibile, ecco perché basso accoppiamento. Ha a che fare con gli elementi tra diversi moduli / classi.

Per visualizzare l'intera immagine sarà utile:

Lo screenshot è stato preso da Coursera .

La coesione nell'ingegneria del software, come nella vita reale, è quanto si può dire che gli elementi costituiti da un intero (nel nostro caso diciamo una classe) appartengano effettivamente insieme. Quindi, è una misura di quanto fortemente correlata sia ogni parte di funzionalità espressa dal codice sorgente di un modulo software.

Un modo di considerare la coesione in termini di OO è se i metodi nella classe utilizzano uno degli attributi privati.

Ora la discussione è più ampia di questa, ma High Cohesion (o il miglior tipo di coesione - la coesione funzionale) è quando parti di un modulo sono raggruppate perché tutte contribuiscono a un singolo compito ben definito del modulo.

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.

L'accoppiamento lento è un metodo di interconnessione dei componenti in un sistema o in una rete in modo tale che tali componenti dipendano l'uno dall'altro nella misura minima possibile ...

Ho scritto un post sul blog su questo. Discute tutto questo in modo molto dettagliato, con esempi ecc. Spiega anche i vantaggi del perché dovresti seguire questi principi.

Nella progettazione del software l' alta coesione significa che la classe dovrebbe fare una cosa e una cosa molto bene. L'alta coesione è strettamente correlata al principio della responsabilità unica .

Un accoppiamento basso suggerisce che la classe dovrebbe avere meno dipendenze possibili. Inoltre, le dipendenze che devono esistere dovrebbero essere dipendenze deboli - preferiscono la dipendenza dall'interfaccia piuttosto che la dipendenza dalla classe concreta, o preferiscono la composizione rispetto all'eredità.

L'alta coesione e il basso accoppiamento ci offrono un codice progettato meglio che è più facile da mantenere.

Risposta breve e chiara

• Alta coesione : elementi all'interno di una classe / modulo dovrebbero funzionare funzionalmente insieme e fare una cosa in particolare.
• Accoppiamento libero : tra diverse classi / moduli dovrebbe esserci una dipendenza minima.

Il basso accoppiamento è nel contesto di due o più moduli. Se una modifica in un modulo comporta molte modifiche in un altro modulo, allora si dice che siano altamente accoppiati. È qui che aiuta la programmazione basata su interfaccia. Qualsiasi modifica all'interno del modulo non avrà alcun impatto sull'altro modulo poiché l'interfaccia (il mezzo di interazione) tra loro non è cambiata.

Alta coesione: metti insieme le cose simili. Quindi una classe dovrebbe avere metodi o comportamenti per fare un lavoro correlato. Giusto per dare un cattivo esempio esagerato: un'implementazione dell'interfaccia Elenco non dovrebbe avere operazioni correlate a String. La classe String dovrebbe avere metodi, campi rilevanti per String e allo stesso modo, l'implementazione di List dovrebbe avere elementi corrispondenti.

Spero che aiuti.

Per farla breve, accoppiamento basso, come ho capito, significa che i componenti possono essere sostituiti senza influire sul corretto funzionamento di un sistema. Fondamentalmente modula il tuo sistema in componenti funzionanti che possono essere aggiornati individualmente senza rompere il sistema

Hai uno smartphone? Esiste una grande app o molte piccole? Un'app risponde a un'altra? È possibile utilizzare un'app durante l'installazione, l'aggiornamento e / o la disinstallazione di un'altra? Che ogni app sia autonoma è un'alta coesione. Che ogni app sia indipendente dalle altre è un accoppiamento basso. DevOps favorisce questa architettura perché significa che è possibile eseguire una distribuzione continua discreta senza interrompere l'intero sistema.

L'ereditarietà o la generalizzazione sono un esempio di accoppiamento elevato (ovvero di alta interdipendenza). Ciò che intendevo con questo è che in eredità spesso la classe genitore definisce le funzionalità di base utilizzate dalla sua classe figlio e il cambiamento nei metodi della classe genitore influisce direttamente sulle sue classi figlio. Quindi possiamo dire che esiste un maggior grado di interdipendenza tra le classi.

La realizzazione o l'utilizzo dell'interfaccia è un esempio di elevata coesione (cioè bassa interdipendenza). Ciò significa che un'interfaccia presenta un contratto per qualsiasi classe che lo implementa, ma ogni classe ha il diritto di implementare i metodi dichiarati nell'interfaccia a modo suo e le modifiche al metodo dichiarate in una classe non influiscono su nessun'altra classe.

Coesione : quanto è strettamente correlato tutto l'uno con l'altro.
Accoppiamento : come tutto è collegato tra loro.

Facciamo un esempio: vogliamo progettare un'auto a guida autonoma.

(1) Abbiamo bisogno che il motore funzioni correttamente.

(2) Abbiamo bisogno che l'auto guidi da sola.

Tutte le classi e le funzioni di (1) avviare il motore e farlo funzionare funzionano perfettamente insieme, ma non aiutano la macchina a sterzare. Quindi mettiamo quelle classi dietro un controller del motore.

Tutte le classi e le funzioni di (2) funzionano perfettamente per far sterzare, accelerare e frenare l'auto. Non aiutano l'automobile ad avviare o inviare benzina ai pistoni. Quindi mettiamo queste classi dietro il suo Driving Controller.

Questi controller vengono utilizzati per comunicare con tutte le classi e le funzioni disponibili. I controller quindi comunicano solo tra loro. Ciò significa che non posso chiamare una funzione nella classe pistone dalla classe del pedale del gas per rendere l'auto più veloce.

La classe del pedale deve chiedere al controllore di guida di parlare con il controllore del motore che poi dice alla classe del pistone di andare più veloce. Questo ci consente ai programmatori di trovare i problemi e ci consente di combinare programmi di grandi dimensioni senza preoccuparci. Questo perché il codice funzionava tutto dietro il controller.

Un accoppiamento basso e un'alta coesione sono un fenomeno raccomandato.

Accoppiamento significa in che misura i vari moduli sono interdipendenti e in che modo gli altri moduli sono influenzati dalla modifica di alcune / notevoli funzionalità di un modulo. Il basso accoppiamento viene enfatizzato poiché la dipendenza deve essere mantenuta bassa in modo che vengano apportate modifiche minime / trascurabili ad altri moduli.

Un esempio potrebbe essere utile. Immagina un sistema che genera dati e li inserisce in un archivio dati, un file su disco o un database.

L'alta coesione può essere ottenuta separando il codice dell'archivio dati dal codice di produzione dei dati. (e di fatto separando la memoria del disco dalla memoria del database).

L'accoppiamento basso può essere ottenuto assicurandosi che la produzione di dati non abbia alcuna conoscenza non necessaria dell'archivio dati (ad es. Non chiede all'archivio dati i nomi dei file o le connessioni db).

Ecco una risposta da un po 'di un angolo teorico astratto, grafico:

Semplifichiamo il problema osservando solo i grafici delle dipendenze (diretti) tra oggetti con stato.

Una risposta estremamente semplice può essere illustrata considerando due casi limitanti di grafici delle dipendenze:

Il primo caso limite : un grafo di grappoli .

Un grafico a grappolo è la realizzazione più perfetta di un grafico di dipendenza ad alta coesione e basso accoppiamento (dato un insieme di dimensioni del cluster).

La dipendenza tra i cluster è massima (completamente connessa) e la dipendenza tra cluster è minima (zero).

Questa è un'illustrazione astratta della risposta in uno dei casi limitanti .

Il secondo caso limite è un grafico completamente connesso, in cui tutto dipende da tutto.

La realtà è da qualche parte nel mezzo, più vicino al grappolo grafico meglio è, nella mia umile comprensione.

Da un altro punto di vista : quando si guarda un grafico di dipendenza diretto, idealmente dovrebbe essere aciclico, altrimenti i cicli formano i cluster / componenti più piccoli.

Un gradino in alto / in basso nella gerarchia corrisponde a "un'istanza" di accoppiamento lento, coesione stretta in un software ma è possibile visualizzare questo principio di accoppiamento lento / coesione stretta come fenomeni ripetitivi a diverse profondità di un grafico diretto aciclico (o su uno dei suoi alberi spanning).

Tale scomposizione di un sistema in una gerarchia aiuta a battere la complessità esponenziale (diciamo che ogni cluster ha 10 elementi). Quindi a 6 strati sono già 1 milione di oggetti:

10 cluster formano 1 supercluster, 10 supercluster formano 1 hypercluster e così via ... senza il concetto di coesione stretta, accoppiamento libero, tale architettura gerarchica non sarebbe possibile.

Quindi questa potrebbe essere la vera importanza della storia e non solo il basso accoppiamento ad alta coesione all'interno di due soli strati. La vera importanza diventa chiara quando si considerano le astrazioni di livello superiore e le loro interazioni.

Penso che tu abbia così tante definizioni rosse ma nel caso tu abbia ancora dubbi o Nel caso tu sia nuovo nella programmazione e desideri approfondire questo, ti suggerirò di guardare questo video, https://youtu.be/HpJTGW9AwX0 È solo un riferimento per avere maggiori informazioni sul polimorfismo ... Spero che tu possa capire meglio con questo

Accoppiamento basso: - Lo manterrà molto semplice. Se cambi il tuo modulo, come influisce sugli altri moduli.

Esempio: - Se l'API del servizio è esposta come JAR, qualsiasi modifica alla firma del metodo interromperà l'API di chiamata (accoppiamento High / Tight).

Se il modulo e l'altro modulo comunicano tramite messaggi asincroni. Finché ricevi messaggi, la firma della modifica del metodo sarà locale per il tuo modulo (accoppiamento basso).

Fuori rotta se c'è un cambiamento nel formato del messaggio, il client chiamante dovrà apportare alcune modifiche.