Unterschied zwischen Kohäsion und Kopplung

Was ist der Unterschied zwischen Kohäsion und Kopplung?

Wie kann die Kopplung und Kohäsion führen entweder gute oder schlechte software-design?

Was sind einige Beispiele, die Gliederung, der Unterschied zwischen den beiden, und Ihre Auswirkungen auf die code-Qualität?

InformationsquelleAutor der Frage JavaUser | 2010-06-21

ooad oop

494

Zusammenhalt bezieht sich auf das, was die Klasse (oder Modul) tun können. Geringe Kohäsion würde bedeuten, dass die Klasse bietet eine große Vielfalt an Aktionen - er ist breit, unkonzentriert auf, was es tun sollte. Hohe Kohäsion bedeutet, dass die Klasse ist konzentriert auf das, was Sie tun sollten, D. H. nur Methoden in Bezug auf die Absicht der Klasse.

Beispiel der Geringe Kohäsion:
```
-------------------
| Staff           |
-------------------
| checkEmail()    |
| sendEmail()     |
| emailValidate() |
| PrintLetter()   |
-------------------
```
Beispiel der Hohe Kohäsion:
```
----------------------------
| Staff                   |
----------------------------
| -salary                 |
| -emailAddr              |
----------------------------
| setSalary(newSalary)    |
| getSalary()             |
| setEmailAddr(newEmail)  |
| getEmailAddr()          |
----------------------------
```
Als für Kupplunges bezieht sich darauf, wie Verwandte oder abhängige zwei-Klassen/Module zueinander. Für die niedrigen Klassen gekoppelt, ändern etwas wesentliches in einer Klasse sollte nicht auf die anderen. Hohe Kopplung würde es schwierig machen, zu ändern und halten Sie Ihren code; da der Unterricht sind eng miteinander verknüpft, sodass eine änderung könnte ein ganzes system umzukrempeln.

Gutes software-design hat hohe Kohäsion und niedrige Kopplung.

InformationsquelleAutor der Antwort mauris
61

Hohe Kohäsion innerhalb Module und niedrige Kopplung zwischen - Module werden Häufig als Bezug auf hohe Qualität in OO-Programmiersprachen.

Beispielsweise den code in jede Java-Klasse muss eine hohe interne Kohäsion, sondern werden als lose gekoppelt wie möglich, um den code in anderen Java-Klassen.

Kapitel 3 Meyer Object-Oriented Software Construction (2nd edition) ist eine tolle Beschreibung dieser Probleme.

InformationsquelleAutor der Antwort CesarGon
33

Zusammenhalt ist ein Indiz dafür, wie Verwandte und konzentrierte sich die Aufgaben eines software-Elements.

Kupplung bezieht sich darauf, wie stark ein software-element ist mit anderen Elementen.

Den software-element-Klasse, Paket, Komponente, subsystem oder ein system. Und während der Gestaltung des systems ist es empfehlenswert, software-Elemente, die Hohe Kohäsion und Unterstützung Niedrige Kopplung.

Geringe Kohäsion Ergebnisse in monolithischen Klassen, die schwierig sind zu pflegen, zu verstehen und verringert die re-usablity. Ähnlich Hohe Kopplung Ergebnisse in Klassen, die fest miteinander verbunden sind und Veränderungen, die nicht dazu neigen, nicht-lokalen, schwer zu ändern und verringert die Wiederverwendung.

Nehmen wir ein hypothetisches Szenario, in dem wir entwerfen ein typischer monitor-in der Lage ConnectionPool mit den folgenden Anforderungen. Beachten Sie, dass es Aussehen könnte, zu viel für eine einfache Klasse wie ConnectionPool aber die grundlegende Absicht ist nur zu zeigen niedrige Kopplung und hohe Kohäsion mit einigen einfachen Beispiel und ich denke, dass sollte helfen.
1. support immer eine Verbindung
2. release eine Verbindung
3. Statistiken über den Anschluß vs Verwendungshäufigkeit
4. Statistiken über den Anschluß vs Zeit
5. Speichern der Verbindung, das abrufen und freigeben von Informationen zu einer Datenbank für die Berichterstattung später.
Mit geringe Kohäsion könnten wir entwerfen ein ConnectionPool Klasse gewaltsam die Füllung alle diese Funktionen/Aufgaben in einer einzigen Klasse als unten. Wir können sehen, dass dies die einzige Klasse ist verantwortlich für das connection-management, Interaktion mit der Datenbank sowie die Aufrechterhaltung der Verbindung stats.

Mit hohe Kohäsion können wir zuordnen, die diese Verantwortung über die Klassen und machen es mehr wartbar und wiederverwendbar.

Demonstrieren Niedrige Kopplung wir werden weiterhin mit der hohen Kohäsion ConnectionPool Diagramm oben. Wenn wir den Blick auf das obige Diagramm obwohl es unterstützt hohe Kohäsion, die ConnectionPool ist eng gekoppelt mit ConnectionStatistics Klasse und PersistentStore es interagiert direkt mit Ihnen. Stattdessen reduzieren Sie die Kupplung konnten wir die Einführung einer ConnectionListener - Schnittstelle und lassen diese beiden Klassen implementieren das interface und lassen Sie Sie registrieren mit ConnectionPool Klasse. Und die ConnectionPool iteriert durch diese Zuhörer und teilen Sie Verbindung bekommen und die release-Veranstaltungen und erlaubt es, weniger Kupplung.

Note/Wort "oder" Vorsicht: aus diesem einfachen Szenario kann es wie ein overkill, aber wenn wir uns vorstellen, eine Echtzeit-Szenario, in dem unsere Anwendung muss für die Interaktion mit mehreren third-party-services, um eine Transaktion abzuschließen: Direkt-Kopplung, die unseren code, mit dem Dritten-Dienste würde bedeuten, dass alle änderungen in der service Dritter führen könnten änderungen an unserem code an mehreren Orten, stattdessen könnten wir haben Facade für die Interaktion mit dieser mehrere Dienste intern und änderungen der Leistungen, werden die Facade erzwingen und niedrigen Kopplung mit dem Drittanbieter-Dienste.

InformationsquelleAutor der Antwort Madhusudana Reddy Sunnapu

Erhöht die Kohäsion und die Kopplung verringert führen, um gutes software-design.

Zusammenhalt Partitionen Ihrer Funktionalität, so dass es prägnant ist und am nächsten an die relevanten Daten, während die Entkopplung sorgt dafür, dass die funktionale Umsetzung ist isoliert vom rest des Systems.

Entkopplung erlaubt die änderung der Implementierung ohne Auswirkungen auf andere Teile der software.

Zusammenhalt sorgt dafür, dass die Umsetzung spezifischer Funktionalität und gleichzeitig einfacher zu pflegen.

Ist die effektivste Methode der abnehmenden Kopplung und die Stärkung des Zusammenhalts ist - design durch Grenzflächen -.

Die wichtigsten funktionalen Objekte sollten nur 'wissen' über die Schnittstelle(N), die Sie implementieren. Die Implementierung einer Schnittstelle führt zu zusammenhalt als eine Natürliche Folge.

Zwar nicht realistisch, in einige senarios sollte es ein design-Ziel zu arbeiten.

Beispiel (sehr lückenhaft):

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 }
}

Einige, wo sonst, in Ihrer Codebasis haben, könnten Sie ein Modul, dass die Prozesse Fragen unabhängig davon, was Sie sind:

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

InformationsquelleAutor der Antwort Adrian Regan

23

Zusammenhalt ist die Angabe der Beziehung innerhalb ein Modul.

Kupplung ist die Angabe der Beziehungen zwischen Module.

überprüfen diese link

InformationsquelleAutor der Antwort Buddhika Alwis
22

beste Erklärung Zusammenhalt kommt von Onkel Bob ' s Clean Code:

Klassen sollten eine kleine Anzahl von Instanz-Variablen. Jede der Methoden einer Klasse sollten manipulieren eines oder mehrere dieser Variablen. Im Allgemeinen die mehrere Variablen einer Methode manipuliert den zusammenhalt, die Methode seiner Klasse. Eine Klasse, in der jede variable verwendet wird, indem jede Methode ist maximal zusammenhalt.

Im Allgemeinen ist es weder ratsam noch möglich, erstellen Sie eine solche maximal zusammenhängenden Klassen; auf der anderen Seite, wir möchten den zusammenhalt zu hoch sein. Beim zusammenhalt ist hoch, es bedeutet, dass die Methoden und Variablen der Klasse sind co-abhängig und hängen zusammen als eine logische Einheit.

Die Strategie zu halten, Funktionen klein und halten Parameterlisten kurz kann manchmal führen zu einer Verbreitung von Instanz-Variablen, die verwendet werden, indem eine Teilmenge von Methoden. Wenn dies geschieht, es bedeutet fast immer, dass es mindestens eine andere Klasse versucht, sich aus der größeren Klasse. Sie sollten versuchen, zu trennen die Variablen und Methoden, die in zwei oder mehr Klassen, so dass die neuen Klassen sind mehr zusammenhalt.

InformationsquelleAutor der Antwort Cătălin Rădoi
11

Zusammenhalt in software-engineering ist der Grad, zu dem die Elemente von einem bestimmten Modul gehören zusammen. Es ist also ein Maß dafür, wie stark verknüpft jedes Stück Funktionalität, ausgedrückt durch den Quellcode eines software-Moduls ist.

Kupplung in einfachen Worten, ist, wie viel einer Komponente (wieder, stellen Sie sich eine Klasse, obwohl nicht unbedingt nötig) kennt, die innere Funktionsweise oder inneren elements der anderen, D. H. wie viel wissen Sie von der anderen Komponente.

Ich schrieb einen blog-post über diesemwenn Sie Lesen möchten, in ein wenig mehr details mit Beispielen und Zeichnungen. Ich denke, es beantwortet die meisten Fragen.

InformationsquelleAutor der Antwort TheBoyan
1

Ich denke, die Unterschiede kann man als die folgenden:
- Zusammenhalt repräsentiert den Grad, zu dem ein Teil von einer code-Basis bildet eine logisch einheitliche, unteilbare Einheit.
- Kupplung stellt den Grad, zu dem eine Einheit ist unabhängig von den anderen.
- Es ist unmöglich, Archiv der vollständigen Entkopplung ohne Beschädigung zusammenhalt, und Umgekehrt.
In diesem blog-post Ich Schreibe über Sie im detail.

InformationsquelleAutor der Antwort Vladimir
1

Zusammenhalt ist ein Indiz für die relative funktionelle Stärke eines Moduls.
- Ein zusammenhängendes Modul führt eine einzelne Aufgabe, die wenig
  Interaktion mit anderen Komponenten in anderen teilen eines Programms. Angegeben
  einfach, ein zusammenhängendes Modul sollte (im Idealfall) nur eines.
- Herkömmlichen Ansicht:
  
  die "Zielstrebigkeit", ein Modul
- OO anzeigen:
  
  zusammenhalt impliziert, dass eine Komponente oder Klasse enthält nur Attribute und Operationen, die eng miteinander verwandt und auf die Klasse oder Komponente selbst
- Ebenen der zusammenhalt
  
  Funktionale
  
  Schicht
  
  Kommunikations -
  
  Sequentielle
  
  Prozedurale
  
  Zeitliche
  
  utility
Kupplung ist ein Indiz für die relative gegenseitige Abhängigkeit zwischen Modulen.
- Kupplung ist abhängig von der Schnittstelle der Komplexität zwischen Modulen, die
  Punkt, an dem Eintrag oder Hinweis auf ein Modul, und welche Daten
  pass quer durch die Schnittstelle.
- Herkömmlichen Ansicht :
  Der Grad, zu dem eine Komponente mit anderen Komponenten und der externen Welt
- OO anzeigen: ein qualitatives Maß für den Grad, zu dem die Klassen miteinander verbunden sind
- Ebene der Kupplung
  
  Inhalt
  
  Gemeinsamen
  
  Kontrolle
  
  Stempel
  
  Daten
  
  Routine-Ruf
  
  - Typ verwenden
  
  Aufnahme oder import
  
  Externe #
InformationsquelleAutor der Antwort zee
1

Kupplung = Interaktion /Beziehung zwischen zwei Modulen...
Zusammenhalt = Interaktion zwischen zwei Elementen innerhalb eines Moduls.

Einer software besteht aus vielen Modulen. Modul besteht aus Elementen. Betrachten wir ein Modul ist ein Programm. Eine Funktion in einem Programm ein element.

Zur Laufzeit die Ausgabe eines Programms als Eingabe für ein anderes Programm. Dies wird als Modul zu Modul Interaktion oder Prozess-zu-Prozess-Kommunikation. Dies ist auch als Kupplung.

Innerhalb eines einzigen Programms, die Ausgabe einer Funktion übergeben in eine andere Funktion. Dies wird als Interaktion von Elementen innerhalb eines Moduls. Dies ist auch als Zusammenhalt.

Beispiel:

Kupplung = Kommunikation zwischen 2 verschiedenen Familien...
Zusammenhalt = die Kommunikation zwischen Vater-Mutter-Kind in einer Familie.

InformationsquelleAutor der Antwort Dipankar Nalui
1

Zusammenhalt (Kohäsion) : Co was bedeutet zusammenhesion was bedeutet stick. Das System zusammenkleben der Teilchen von verschiedenen Substanzen.

Für real-life-Beispiel:

img-mit freundlicher Genehmigung

Ganze ist Mehr als die Summe seiner Teile -Aristoteles.
- Zusammenhalt ist eine Ordinalzahl der Art der Messung und ist in der Regel beschrieben als "hohe Kohäsion" und "wenig zusammenhalt". Module mit hoher Kohäsion tendenziell bevorzugt, da hohe Kohäsion ist im Zusammenhang mit mehrere wünschenswerte Merkmale von software, einschließlich Robustheit, Zuverlässigkeit, Wiederverwendbarkeit und Verständlichkeit. Im Gegensatz, geringe Kohäsion ist im Zusammenhang mit unerwünschten Merkmalen, wie Wesen, die schwer zu verwalten, testen, Wiederverwendung, oder sogar zu verstehen. wiki
- Kupplung ist in der Regel kontrastiert mit zusammenhalt. Niedrige Kopplung oft korreliert mit einer hohen Kohäsion, und Umgekehrt. Geringe Kopplung ist oft ein Zeichen für ein gut strukturiertes EDV-system und ein gutes design, und wenn Sie kombiniert werden mit hoher zusammenhalt, unterstützt die Allgemeinen Ziele der hohen Lesbarkeit und Wartbarkeit. wiki
InformationsquelleAutor der Antwort Premraj

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.