Was ist der Unterschied zwischen Kohäsion und Kopplung?

Wie können Kopplung und Kohäsion zu einem guten oder schlechten Software-Design führen?

Welche Beispiele beschreiben den Unterschied zwischen den beiden und ihre Auswirkungen auf die Gesamtcodequalität?

Kohäsion bezieht sich darauf, was die Klasse (oder das Modul) tun kann. Ein geringer Zusammenhalt würde bedeuten, dass die Klasse eine Vielzahl von Aktionen ausführt - sie ist breit und unkonzentriert auf das, was sie tun sollte. Hoher Zusammenhalt bedeutet, dass sich die Klasse auf das konzentriert, was sie tun soll, dh nur auf Methoden, die sich auf die Absicht der Klasse beziehen.

Beispiel für geringe Kohäsion:

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

Beispiel für hohe Kohäsion:

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

Die Kopplung bezieht sich darauf, wie verwandt oder abhängig zwei Klassen / Module zueinander sind. Bei niedrig gekoppelten Klassen sollte sich das Ändern von etwas Wichtigem in einer Klasse nicht auf die andere auswirken. Eine hohe Kopplung würde es schwierig machen, Ihren Code zu ändern und zu pflegen. Da die Klassen eng miteinander verbunden sind, kann eine Änderung eine vollständige Systemrevision erfordern.

Gutes Software-Design hat eine hohe Kohäsion und eine geringe Kopplung .

Kohäsion ist der Hinweis auf die Beziehung innerhalb eines Moduls.

Die Kopplung ist die Angabe der Beziehungen zwischen Modulen.

Zusammenhalt

• Kohäsion ist der Hinweis auf die Beziehung innerhalb des Moduls.
• Die Kohäsion zeigt die relative Funktionsstärke des Moduls.
• Kohäsion ist ein Grad (Qualität), in dem sich eine Komponente / ein Modul auf die einzelne Sache konzentriert.
• Während des Entwurfs sollten Sie eine hohe Kohäsion anstreben, dh eine zusammenhängende Komponente / ein zusammenhängendes Modul, das sich auf eine einzelne Aufgabe (dh Zielstrebigkeit) konzentriert und wenig mit anderen Modulen des Systems interagiert.
• Kohäsion ist die Art der natürlichen Erweiterung von Daten, die beispielsweise verborgen sind, wobei alle Mitglieder mit einem Paket mit Standardsichtbarkeit sichtbar sind. Kohäsion ist ein Intra-Modul-Konzept.

Kupplung

• Die Kopplung ist die Angabe der Beziehungen zwischen Modulen.
• Die Kopplung zeigt die relative Abhängigkeit / Interdependenz zwischen den Modulen.
• Die Kopplung ist ein Grad, in dem eine Komponente / ein Modul mit den anderen Modulen verbunden ist.
• Während des Entwurfs sollten Sie eine geringe Kopplung anstreben, dh die Abhängigkeit zwischen Modulen sollte geringer sein
• Das Erstellen privater Felder, privater Methoden und nicht öffentlicher Klassen bietet eine lose Kopplung.
• Die Kopplung ist ein Inter-Modul-Konzept.

Überprüfen Sie diesen Link

Hohe Kohäsion innerhalb von Modulen und geringe Kopplung zwischen Modulen werden häufig als mit hoher Qualität in OO-Programmiersprachen verbunden angesehen.

Beispielsweise muss der Code in jeder Java-Klasse einen hohen internen Zusammenhalt aufweisen, jedoch so locker wie möglich mit dem Code in anderen Java-Klassen gekoppelt sein.

Kapitel 3 von Meyers objektorientierter Softwarekonstruktion (2. Ausgabe) enthält eine ausführliche Beschreibung dieser Probleme.

Kohäsion ist ein Hinweis darauf, wie eng und fokussiert die Verantwortlichkeiten eines Softwareelements sind.

Die Kopplung bezieht sich darauf, wie stark ein Softwareelement mit anderen Elementen verbunden ist.

Das Softwareelement kann eine Klasse, ein Paket, eine Komponente, ein Subsystem oder ein System sein. Beim Entwurf der Systeme wird empfohlen, Softwareelemente mit hoher Kohäsion und geringer Kopplung zu verwenden .

Geringe Kohäsion führt zu monolithischen Klassen, die schwer aufrechtzuerhalten, zu verstehen und die Wiederverwendbarkeit zu verringern sind. Ähnlich hohe Kopplung führt zu Klassen, die eng gekoppelt sind und Änderungen sind nicht lokal, schwer zu ändern und reduzieren die Wiederverwendung.

Wir können ein hypothetisches Szenario annehmen, in dem wir ein typisches Monitoring ConnectionPoolmit den folgenden Anforderungen entwerfen . Beachten Sie, dass es für eine einfache Klasse wie zu viel aussehen mag, ConnectionPoolaber die grundlegende Absicht besteht darin, nur eine geringe Kopplung und einen hohen Zusammenhalt anhand eines einfachen Beispiels zu demonstrieren, und ich denke, dies sollte helfen.

1. Unterstützung beim Herstellen einer Verbindung
2. Verbindung herstellen
3. Erhalten Sie Statistiken über Verbindung und Nutzungsanzahl
4. Holen Sie sich Statistiken über Verbindung gegen Zeit
5. Speichern Sie die Informationen zum Abrufen und Freigeben von Verbindungen in einer Datenbank, um sie später zu melden.

Mit geringem Zusammenhalt könnten wir eine ConnectionPoolKlasse entwerfen , indem wir all diese Funktionen / Verantwortlichkeiten wie unten beschrieben in eine einzige Klasse packen. Wir können sehen, dass diese einzelne Klasse für das Verbindungsmanagement, die Interaktion mit der Datenbank sowie die Verwaltung der Verbindungsstatistiken verantwortlich ist.

Mit hohem Zusammenhalt können wir diese Verantwortung auf die Klassen verteilen und sie wartbarer und wiederverwendbarer machen.

Um eine niedrige Kopplung zu demonstrieren, werden wir mit dem ConnectionPoolobigen Diagramm für hohe Kohäsion fortfahren . Wenn wir uns das obige Diagramm ansehen, obwohl es eine hohe Kohäsion unterstützt, ConnectionPoolist das eng mit der ConnectionStatisticsKlasse gekoppelt und PersistentStorees interagiert direkt mit ihnen. Um die Kopplung zu verringern, könnten wir stattdessen eine ConnectionListenerSchnittstelle einführen und diese beiden Klassen die Schnittstelle implementieren lassen und sie sich bei der ConnectionPoolKlasse registrieren lassen . Und der ConnectionPoolWille durchläuft diese Listener und benachrichtigt sie über Verbindungsabruf- und Freigabeereignisse und ermöglicht weniger Kopplung.

Hinweis / Wort oder Vorsicht: In diesem einfachen Szenario mag es wie ein Overkill aussehen. Wenn wir uns jedoch ein Echtzeitszenario vorstellen, in dem unsere Anwendung mit mehreren Diensten von Drittanbietern interagieren muss, um eine Transaktion abzuschließen: Koppeln Sie unseren Code direkt mit den Diensten von Drittanbietern Dies würde bedeuten, dass Änderungen am Dienst eines Drittanbieters an mehreren Stellen zu Änderungen an unserem Code führen könnten. Stattdessen könnte Facadedies zu einer internen Interaktion mit diesen mehreren Diensten führen und Änderungen an den Diensten werden lokal für den Dienst Facadeund erzwingen eine geringe Kopplung mit dem Drittanbieter Dienstleistungen.

Erhöhte Kohäsion und verringerte Kopplung führen zu einem guten Software-Design.

Durch die Kohäsion wird Ihre Funktionalität so aufgeteilt, dass sie präzise und den für sie relevanten Daten am nächsten kommt. Durch die Entkopplung wird sichergestellt, dass die funktionale Implementierung vom Rest des Systems isoliert ist.

Durch die Entkopplung können Sie die Implementierung ändern, ohne andere Teile Ihrer Software zu beeinflussen.

Durch den Zusammenhalt wird sichergestellt, dass die Implementierung funktionsspezifischer und gleichzeitig einfacher zu warten ist.

Die effektivste Methode zur Verringerung der Kopplung und Erhöhung der Kohäsion ist das Design per Schnittstelle .

Das heißt, wichtige Funktionsobjekte sollten sich nur über die von ihnen implementierten Schnittstellen kennen. Die Implementierung einer Schnittstelle führt den Zusammenhalt als natürliche Folge ein.

Obwohl dies in einigen Szenarien nicht realistisch ist, sollte es ein Entwurfsziel sein, nach dem gearbeitet werden muss.

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

An einigen anderen Stellen in Ihrer Codebasis könnten Sie ein Modul haben, das Fragen verarbeitet, unabhängig davon, um welche es sich handelt:

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

Die beste Erklärung für den Zusammenhalt stammt aus Onkel Bobs Clean Code:

Klassen sollten eine kleine Anzahl von Instanzvariablen haben. Jede der Methoden einer Klasse sollte eine oder mehrere dieser Variablen manipulieren. Je mehr Variablen eine Methode manipuliert, desto kohärenter ist diese Methode im Allgemeinen für ihre Klasse . Eine Klasse, in der jede Variable von jeder Methode verwendet wird, ist maximal kohäsiv.

Im Allgemeinen ist es weder ratsam noch möglich, solche maximal zusammenhängenden Klassen zu schaffen. Andererseits möchten wir, dass der Zusammenhalt hoch ist . Wenn die Kohäsion hoch ist, bedeutet dies, dass die Methoden und Variablen der Klasse voneinander abhängig sind und als logisches Ganzes zusammenhalten.

Die Strategie, Funktionen klein zu halten und Parameterlisten kurz zu halten, kann manchmal zu einer Zunahme von Instanzvariablen führen, die von einer Teilmenge von Methoden verwendet werden. Wenn dies geschieht, bedeutet dies fast immer, dass mindestens eine andere Klasse versucht, aus der größeren Klasse herauszukommen. Sie sollten versuchen, die Variablen und Methoden in zwei oder mehr Klassen zu unterteilen, damit die neuen Klassen zusammenhängender sind.

Kohäsion repräsentiert einfach den Grad, in dem ein Teil einer Codebasis eine logisch einzelne atomare Einheit bildet. Die Kopplung hingegen repräsentiert den Grad, in dem eine einzelne Einheit von anderen unabhängig ist. Mit anderen Worten, es ist die Anzahl der Verbindungen zwischen zwei oder mehr Einheiten. Je kleiner die Zahl, desto geringer die Kopplung.

Im Wesentlichen bedeutet hohe Kohäsion, Teile einer Codebasis, die miteinander in Beziehung stehen, an einem einzigen Ort zu halten. Bei einer geringen Kopplung geht es gleichzeitig darum, nicht verwandte Teile der Codebasis so weit wie möglich zu trennen.

Codetypen aus Kohäsions- und Kopplungsperspektive:

Ideal ist der Code, der der Richtlinie folgt. Es ist lose gekoppelt und sehr kohäsiv. Wir können einen solchen Code mit diesem Bild veranschaulichen:

God Object ist das Ergebnis der Einführung eines hohen Zusammenhalts und einer hohen Kopplung. Es ist ein Anti-Pattern und steht im Grunde genommen für einen einzelnen Code, der die ganze Arbeit auf einmal erledigt: Schlecht ausgewählt findet statt, wenn die Grenzen zwischen verschiedenen Klassen oder Modulen schlecht ausgewählt sind

Die destruktive Entkopplung ist die interessanteste. Es tritt manchmal auf, wenn ein Programmierer versucht, eine Codebasis so stark zu entkoppeln, dass der Code seinen Fokus vollständig verliert:

Lesen Sie hier mehr

Kohäsion in der Softwareentwicklung ist der Grad, in dem die Elemente eines bestimmten Moduls zusammengehören. Somit ist es ein Maß dafür, wie stark jede Funktionalität, die durch den Quellcode eines Softwaremoduls ausgedrückt wird, in Beziehung steht.

In einfachen Worten bedeutet Kopplung , wie viel eine Komponente (stellen Sie sich eine Klasse vor, wenn auch nicht unbedingt) über das Innenleben oder die inneren Elemente einer anderen weiß, dh wie viel Wissen sie über die andere Komponente hat.

Ich habe einen Blog-Beitrag darüber geschrieben , wenn Sie ein bisschen mehr Details mit Beispielen und Zeichnungen nachlesen möchten. Ich denke, es beantwortet die meisten Ihrer Fragen.

Kohäsion bezieht sich darauf, wie eine einzelne Klasse gestaltet ist. Kohäsion ist das objektorientierte Prinzip, das am engsten mit der Sicherstellung verbunden ist, dass eine Klasse mit einem einzigen, gut fokussierten Zweck entworfen wird. Je fokussierter eine Klasse ist, desto größer ist der Zusammenhalt dieser Klasse. Der Vorteil einer hohen Kohäsion besteht darin, dass solche Klassen viel einfacher zu pflegen (und weniger häufig geändert) werden als Klassen mit geringer Kohäsion. Ein weiterer Vorteil einer hohen Kohäsion besteht darin, dass Klassen mit einem gut fokussierten Zweck tendenziell wiederverwendbarer sind als andere Klassen.

Im obigen Bild sehen wir, dass bei geringer Kohäsion nur eine Klasse für die Ausführung vieler nicht gemeinsamer Aufgaben verantwortlich ist, was die Wahrscheinlichkeit einer Wiederverwendbarkeit und Wartung verringert. Bei hoher Kohäsion gibt es jedoch eine separate Klasse für alle Jobs, um einen bestimmten Job auszuführen, was zu einer besseren Benutzerfreundlichkeit und Wartung führt.

Zusammenhalt (Kohäsion): Co , was bedeutet , zusammen , menhalt , welche Mittel zu kleben . Das System des Zusammenklebens von Partikeln verschiedener Substanzen.

Ein Beispiel aus der Praxis : img Courtesy

Das Ganze ist größer als die Summe der Teile - Aristoteles.

• Kohäsion ist eine ordinale Art der Messung und wird üblicherweise als "hohe Kohäsion" oder "niedrige Kohäsion" beschrieben. Module mit hoher Kohäsion sind in der Regel vorzuziehen, da eine hohe Kohäsion mit mehreren wünschenswerten Merkmalen von Software verbunden ist, einschließlich Robustheit, Zuverlässigkeit, Wiederverwendbarkeit und Verständlichkeit. Im Gegensatz dazu ist eine geringe Kohäsion mit unerwünschten Merkmalen verbunden, wie z. B. der Schwierigkeit, sie aufrechtzuerhalten, zu testen, wiederzuverwenden oder sogar zu verstehen. Wiki

• Die Kopplung steht normalerweise im Gegensatz zur Kohäsion . Eine geringe Kopplung korreliert häufig mit einer hohen Kohäsion und umgekehrt. Eine geringe Kopplung ist häufig ein Zeichen für ein gut strukturiertes Computersystem und ein gutes Design und unterstützt in Kombination mit einer hohen Kohäsion die allgemeinen Ziele einer hohen Lesbarkeit und Wartbarkeit. Wiki

Ich denke, die Unterschiede können wie folgt ausgedrückt werden:

• Kohäsion repräsentiert den Grad, in dem ein Teil einer Codebasis eine logisch einzelne atomare Einheit bildet.
• Die Kopplung gibt an, inwieweit eine einzelne Einheit von anderen unabhängig ist.
• Es ist unmöglich, eine vollständige Entkopplung zu archivieren, ohne den Zusammenhalt zu beeinträchtigen, und umgekehrt.

In diesem Blogbeitrag schreibe ich ausführlicher darüber.

Die Kohäsion ist ein Hinweis auf die relative Funktionsstärke eines Moduls.

• Ein zusammenhängendes Modul führt eine einzelne Aufgabe aus und erfordert wenig Interaktion mit anderen Komponenten in anderen Teilen eines Programms. Einfach ausgedrückt sollte ein zusammenhängendes Modul (idealerweise) nur eines tun.

• Konventionelle Ansicht:

  die „Zielstrebigkeit“ eines Moduls

• OO Ansicht:

  Kohäsion bedeutet, dass eine Komponente oder Klasse nur Attribute und Operationen enthält, die eng miteinander und mit der Klasse oder Komponente selbst verbunden sind

• Zusammenhaltsebenen

  Funktional

  Layer

  Kommunikation

  Sequential

  Verfahren

  Temporal

  Nützlichkeit

Die Kopplung ist ein Hinweis auf die relative gegenseitige Abhängigkeit zwischen Modulen.

• Die Kopplung hängt von der Komplexität der Schnittstelle zwischen Modulen ab, dem Punkt, an dem ein Modul eingegeben oder referenziert wird, und davon, welche Daten über die Schnittstelle übertragen werden.

• Konventionelle Ansicht: Der Grad, in dem eine Komponente mit anderen Komponenten und mit der Außenwelt verbunden ist

• OO-Ansicht: Ein qualitatives Maß dafür, inwieweit Klassen miteinander verbunden sind

• Grad der Kopplung

  Inhalt

  Gemeinsam

  Steuerung

  Stempel

  Daten

  Routinenanruf

  Typ verwenden

  Einschluss oder Import

  Externe #

Kopplung = Interaktion / Beziehung zwischen zwei Modulen ... Kohäsion = Interaktion zwischen zwei Elementen innerhalb eines Moduls.

Eine Software besteht aus vielen Modulen. Modul besteht aus Elementen. Stellen Sie sich vor, ein Modul ist ein Programm. Eine Funktion innerhalb eines Programms ist ein Element.

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

Innerhalb eines einzelnen Programms wird die Ausgabe einer Funktion an eine andere Funktion übergeben. Dies wird als Interaktion von Elementen innerhalb eines Moduls bezeichnet. Dies wird auch als Zusammenhalt bezeichnet.

Beispiel:

Kopplung = Kommunikation zwischen 2 verschiedenen Familien ... Zusammenhalt = Kommunikation zwischen Vater-Mutter-Kind innerhalb einer Familie.

Einfach ausgedrückt bedeutet Zusammenhalt , dass eine Klasse ein einziges Konzept darstellen sollte.

Die öffentliche Schnittstelle einer Klasse ist zusammenhängend, wenn alle Klassenmerkmale mit dem Konzept zusammenhängen, das die Klasse darstellt. Anstatt beispielsweise über die CashRegister-Klasse zu verfügen, werden die Funktionen CashRegister und Coin in zwei Klassen unterteilt: CashRegister und Coin.

Beim Koppeln hängt eine Klasse von einer anderen ab, da sie die Objekte der Klasse verwendet.

Das Problem bei hoher Kopplung ist, dass es zu Nebenwirkungen kommen kann. Eine Änderung in einer Klasse kann einen unerwarteten Fehler in der anderen Klasse verursachen und den gesamten Code beschädigen.

Im Allgemeinen wird eine hohe Kohäsion und eine geringe Kopplung als OOP hoher Qualität angesehen.

Der Begriff Kohäsion ist in der Tat ein wenig kontraintuitiv für das, was er im Software-Design bedeutet.

Kohäsion gemeinsame Bedeutung ist, dass etwas, das gut zusammenhält, vereint ist, die durch starke Bindung wie molekulare Anziehung gekennzeichnet sind. Beim Software-Design bedeutet dies jedoch, nach einer Klasse zu streben, die im Idealfall nur eines tut, sodass nicht einmal mehrere Submodule beteiligt sind.

Vielleicht können wir uns das so vorstellen. Ein Teil hat den größten Zusammenhalt, wenn es der einzige Teil ist (tut nur eines und kann nicht weiter zerlegt werden). Dies ist im Software-Design erwünscht. Zusammenhalt ist einfach ein anderer Name für "Einzelverantwortung" oder "Trennung von Bedenken".

Der Begriff Kopplung ist sehr intuitiv, dh wenn ein Modul nicht von zu vielen anderen Modulen abhängt und diejenigen, mit denen es verbunden ist, leicht ersetzt werden können, beispielsweise unter Befolgung des Liskov-Substitutionsprinzips .

Theorieunterschied

Zusammenhalt

• Die Kohäsion ist ein Hinweis auf die relative Funktionsstärke des Moduls.
• Ein zusammenhängendes Modul führt eine einzelne Aufgabe aus und erfordert nur wenig Interaktion mit anderen Komponenten in anderen Programmteilen.
• Ein Modul mit hoher Kohäsion und geringer Kopplung soll funktional unabhängig von anderen Modulen sein.

Klassifikation des Zusammenhalts

1.Coincidental 2.Logical 3.Temporal 4.Procedural 5.Communication 6.Sequential 7.Functional

Kupplung

• Die Kopplung ist ein Hinweis auf die relative gegenseitige Abhängigkeit zwischen Modulen.
• Der Grad der Kopplung zwischen zwei Modulen hängt von ihrer Schnittstellenkomplexität ab.