Unterschied zwischen Kohäsion und Kopplung

https://stackoverflow.com/questions/3085285

oop
ooad

28-09-2019
|

Frage

Was ist der Unterschied zwischen Kohäsion und Kopplung?

Wie kann Kopplung und Zusammenhalt führen zu entweder gut oder schlecht Software-Design?

Was sind einige Beispiele, die Umrisse der Unterschied zwischen den beiden, und ihre Auswirkungen auf die Gesamtcodequalität?

Lösung

Kohäsions bezieht sich auf das, was die Klasse (oder Modul) tun können. Niedriger Zusammenhalt würde bedeuten, dass die Klasse eine Vielzahl von Aktionen tut - es ist breit, unkonzentriert auf, was es tun soll. Hohe Kohäsion bedeutet, dass die Klasse konzentriert sich auf das, was sollte es Methoden, um die Absicht der Klasse beziehen, tun, das heißt nur werden.

Beispiel für Low Kohäsion:

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

Beispiel für High Cohesion:

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

Wie bei Kupplung , es bezieht sich, wie im Zusammenhang oder abhängigen zwei Klassen / Module zueinander sind. Für niedrige gekoppelt Klassen, etwas Großes in einer Klasse zu ändern sollte der andere nicht beeinträchtigt. Hohe Kopplung würde es schwierig machen, den Code zu ändern und zu pflegen; da Klassen eng zusammen gestrickt werden, eine Änderung vornehmen könnte ein ganzes System Umbau erforderlich.

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

Andere Tipps

Hoch Zusammenhalt in Module und geringe Kopplung zwischen Module werden oft als in Bezug auf hohe Qualität in der OO-Programmiersprachen.

Zum Beispiel muss der Code in jeder Java-Klasse mit hohem inneren Zusammenhalt hat, aber so locker wie möglich, um den Code in anderen Java-Klassen gekoppelt werden.

Kapitel 3 von Meyer Object-Oriented Software Construction (2. Auflage) eine große Beschreibung dieser Themen.

Kohäsions ist die Angabe der Beziehung innerhalb ein Modul.

Kupplung ist die Angabe der Beziehungen zwischen Module.

eingeben

Kohäsions

Die Kohäsion ist die Angabe der Beziehung innerhalb des Moduls.
Kohäsions zeigt die relative funktionale Stärke des Moduls.
ist Kohäsions ein gewisses Maß (Qualität), an dem ein Bauteil / Modul auf das fokussiert einzelne Sache.
Bei der Gestaltung sollte für hohe Kohäsion streben d.h. eine zusammenhängende Komponente / Modul Fokus auf einer einzelnen Aufgabe (d.h. Zielstrebigkeit) mit wenig Interaktion mit anderen Modulen der System.
Die Kohäsion ist die Art der natürlichen Erweiterung der Datenkapselung für Beispiel mit Klasse alle Mitglieder sichtbar mit einem Paket mit Standardsichtbarkeit. Zusammenhalt ist Intra -. Modulkonzept

Kupplung

Kupplung ist die Angabe der Beziehungen zwischen den Modulen.
Die Kopplung zeigt die relative Abhängigkeit / Interdependenz zwischen den Modulen.
Die Kupplung ist ein Maß, in dem ein Bauteil / Modul mit den anderen Modulen verbunden ist.
Beim Entwerfen Sie für eine geringe Kopplung heißt die Abhängigkeit zwischen den Modulen sollte sich bemühen sollte weniger
machen private Felder, private Methoden und nicht öffentliche Klassen ermöglicht eine lose Kopplung.
Kupplung ist Inter -Modul Konzept.

dieser Link

Kohäsions ist ein Indiz dafür, wie im Zusammenhang und konzentrierten sich die Aufgaben eines Software-Elements sind.

Kupplung gibt an, wie stark ein Software-Element mit anderen Elementen verbunden ist.

Die Software-Element-Klasse sein könnte, Paket, Komponente, Subsystem oder ein System. Und während die Systeme entwerfen wird empfohlen, Softwareelemente zu haben, die haben Hohe Zusammenhalt und Unterstützung Niedrige Kupplung .

Niedriger Zusammenhalt Ergebnisse in monolithischen Klassen, die schwer zu pflegen, zu verstehen und reduziert Wieder usablity. Ähnlich Hohe Kopplung Ergebnisse in Klassen, die eng gekoppelt sind und Veränderungen eher nicht nicht-lokale werden, schwer zu ändern und reduziert die Wiederverwendung.

Wir können ein hypothetisches Szenario nehmen, wo wir einen typischen Monitor-fähig ConnectionPool mit folgenden Anforderungen entwerfen. Beachten Sie, dass, könnte es zu viel suchen eine einfache Klasse wie ConnectionPool aber die grundlegende Absicht ist nur zu zeigen, geringe Kopplung und hohe Kohäsion mit einigen einfachen Beispiel und ich denke, sollte Hilfe .

Unterstützung bekommen eine Verbindung
lösen eine Verbindung
erhalten Statistiken über Verbindung vs Verwendungsanzahl
erhalten Statistiken über Verbindung gegen die Zeit
Speichern Sie die Verbindung Abruf und Release-Informationen in eine Datenbank später für die Berichterstattung.

Mit geringer Kohäsion wir eine ConnectionPool Klasse entwerfen könnten durch kräftige Füllung alle diese Funktionalität / Verantwortlichkeit in eine einzige Klasse, wie unten. Wir können sehen, dass diese einzelne Klasse für Verbindungsmanagement verantwortlich ist, mit Datenbank interagieren und Verbindungsstatistiken beibehalten wird.

Mit hohe Kohäsion wir diese Verantwortung für die Klassen zuordnen können und machen es besser verwaltbar und wiederverwendbar.

Um zu demonstrieren, Niedrige Kupplung werden wir oben mit den hohen Zusammenhalt ConnectionPool Diagramm fortzusetzen. Wenn wir bei dem obigen Diagramm sehen, obwohl es eine hohe Kohäsion unterstützt, wird die ConnectionPool eng gekoppelt mit ConnectionStatistics Klasse und PersistentStore es direkt mit ihnen in Wechselwirkung tritt. Stattdessen reduzieren die Kopplung wir eine ConnectionListener Schnittstelle einführen könnte und lassen diese beiden Klassen die Schnittstelle implementieren und lassen Sie sie mit ConnectionPool Klasse registrieren. Und die ConnectionPool wird durch diese Zuhörer laufen und teilen sie der Verbindung erhalten und die Freigabe Ereignisse und ermöglicht geringere Kopplung.

Hinweis / Word oder Achtung: Für dieses einfache Szenario kann es wie ein übertrieben aussehen, aber wenn wir eine Echtzeit-Szenario vorstellen, wo unsere Anwendungsanforderungen mit mehreren Diensten Dritter zu interagieren um eine Transaktion abzuschließen : unser Code mit den Leistungen von dritten direkt haben Facade im dritten Service alle Änderungen Änderungen an unseren Code an mehreren Stellen zur Folge haben könnte, dass wirkt intern mit diesen mehrere Dienste würde bedeuten, koppeln, dass und sich auf die Dienste alle Änderungen stattdessen könnten wir lokal auf den Facade und erzwingt eine geringe Kopplung mit den Leistungen von dritten.

erhöhte Kohäsion und verminderte Kopplung do führen zu gutem Software-Design.

Kohäsions partitioniert Ihre Funktionalität, so dass sie präzise ist und am nächsten zu den relevanten Daten es, während gewährleistet Entkopplung, dass die funktionelle Implementierung vom Rest des Systems isoliert ist.

Entkoppelung können Sie die Implementierung ändern, ohne andere Teile der Software zu beeinflussen.

Kohäsions sorgt dafür, dass die Umsetzung spezifischer Funktionalität und zugleich leichter zu pflegen.

Die effektivste Methode zur Verringerung Kopplung und Kohäsion zu erhöhen, ist Design von Schnittstelle .

ist, dass wichtige funktionalen Objekte sollten nur ‚wissen‘, sich durch die Schnittstelle (n), die sie implementieren. Die Implementierung einer Schnittstelle stellt die Kohäsions als natürliche Folge.

Auch wenn es nicht realistisch in einigen senarios soll es ein Design Ziel der Arbeit von sein.

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 Ihrem Code-Basis ein Modul haben könnten, dass die Prozesse Fragen unabhängig davon, was sie sind:

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

beste Erklärung von Kohäsions kommt von Onkel Bob Clean Code:

Klassen sollten eine kleine Anzahl von Instanzvariablen haben. Jede der Methoden einer Klasse sollte eine oder mehrere dieser Variablen manipulieren. Im Allgemeinen ist die mehr Variablen ein Verfahren manipuliert die geschlossenere, dass Verfahren zu seiner Klasse . Eine Klasse, in der jede Variable durch jedes Verfahren verwendet wird, ist maximal Kohäsions.

Im Allgemeinen ist es weder sinnvoll noch möglich, solche maximal zusammenhängende Klassen zu schaffen; auf der anderen Seite, würden wir Zusammenhalt wie hoch sein. Wenn Zusammenhalt hoch ist, bedeutet dies, dass die Methoden und Variablen der Klasse sind co-abhängig und hängen zusammen als eine logische Einheit.

Die Strategie der Funktionen klein zu halten und Parameterlisten halten kurze kann manchmal zu einer starken Zunahme von Instanzvariablen führen, die durch eine Untermenge von Methoden verwendet werden. Wenn dies geschieht, bedeutet das fast immer, dass es zumindest eine andere Klasse, die versucht, von der größeren Klasse raus. Sie sollten versuchen, die Variablen und Methoden in zwei oder mehr Klassen zu trennen, so dass die neuen Klassen mehr Zusammenhalt sind.

Kohäsions in der Softwareentwicklung ist das Ausmaß, in dem die Elemente eines bestimmten Moduls, gehören zusammen. So ist es ein Maß dafür, wie stark im Zusammenhang jedes Stück Funktionalität durch den Quellcode eines Softwaremoduls ausgedrückt ist.

Kupplung in einfachen Worten, wie viel eine Komponente (wieder, stellen Sie sich eine Klasse, wenn auch nicht unbedingt) weiß über das Innenleben oder innere Elemente eines anderen, das heißt, wie viel Wissen hat von die andere Komponente.

Ich schrieb eine Blog-Post über diesen , wenn Sie lesen mögen up in einem wenig mehr Details mit Beispielen und Zeichnungen. Ich denke, es die meisten Ihrer Fragen beantwortet.

einfach Kohäsions für den Grad, in dem ein Teil einer Codebasis eine logisch einzelne, unteilbare Einheit bildet. Kupplung , auf der anderen Seite, stellt den Grad, in dem eine einzelne Einheit von den anderen unabhängig ist. Mit anderen Worten, es ist die Anzahl der Verbindungen zwischen zwei oder mehr Einheiten. Je geringer die Anzahl, die die Kopplung senken.

Im Wesentlichen hohe Kohäsion Mittel Teile eines Codebasis zu halten, die miteinander in einem einzigen Ort in Beziehung steht. Low-Kupplung, zur gleichen Zeit, ist etwa so viel wie möglich nicht verwandte Teile der Code-Basis zu trennen.

Arten von Code aus einer Kohäsion und Kopplung Perspektive:

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

Gott Object ist ein Ergebnis der hohe Kohäsion und hohe Kopplungs einzuführen. Es ist ein anti-Muster und im Grunde steht für ein Stück Code, der die ganze Arbeit auf einmal tut: schlecht gewählt findet statt, wenn die Grenzen zwischen den verschiedenen Klassen oder Module schlecht ausgewählt werden < img src = "https://i.stack.imgur.com/OGJ5W.png" alt = "image description treten Sie hier">

Destructive Entkopplung ist die interessanteste. Es tritt manchmal, wenn ein Programmierer versucht, so viel eine Code-Basis zu entkoppeln, dass der Code vollständig seinen Fokus verliert: < img src = "https://i.stack.imgur.com/ZiA3f.png" alt = "image description treten Sie hier">

Weitere Informationen hier

Kohäsion bezieht sich alles darüber, wie eine einzige Klasse ausgelegt ist. Zusammenhalt ist das objektorientierte Prinzip am engsten mit dafür sorgen, verbunden, dass eine Klasse mit einem einzigen, gut fokussierten Zweck ausgelegt ist. Je mehr konzentrierte sich eine Klasse ist, ist der Zusammenhalt dieser Klasse mehr. Die Vorteile der hohen Kohäsion ist, dass solche Klassen sind viel leichter zu pflegen (und weniger häufig gewechselt) als Klassen mit geringer Kohäsion. Ein weiterer Vorteil der hohen Kohäsion ist, dass Klassen mit einem gut fokussierten Zweck als andere Klassen zu mehr wiederverwendbar neigen.

In dem obigen Bild, können wir in geringer Kohäsion nur eine Klasse verantwortlich ist viel Arbeit auszuführen, die nicht gemeinsam, die die Chance auf Wiederverwendbarkeit reduziert und die Wartung sehen, dass. Aber in hohen Zusammenhalt gibt es eine separate Klasse für alle Jobs, um eine bestimmte Aufgabe auszuführen, die eine bessere Bedienbarkeit und Wartung zur Folge haben.

Kohäsions (Kohäsion): Co die Mittel zusammen , menhalt , was bedeutet, Stick . Das System der gemeinsam von Partikeln verschiedener Substanzen kleben.

Für Real-Life-Beispiel:

img Courtesy

Ganze ist mehr als die Summe der Teile -Aristoteles.

Kohäsions ist eine Ordnungs Art der Messung und wird in der Regel als „hohe Kohäsion“ oder „geringe Kohäsion“ beschrieben. Module mit hohen Kohäsion neigt vorzuziehen zu sein, weil ein hohe Kohäsion mit mehreren wünschenswerten Eigenschaften von Software einschließlich Robustheit, Zuverlässigkeit, Wiederverwertbarkeit und Verständlichkeit verbunden ist. Im Gegensatz dazu ist geringe Kohäsion mit unerwünschten Eigenschaften verbunden ist, wie schwierig zu pflegen, zu testen, Wiederverwendung oder sogar zu verstehen. Wiki
Kupplung ist in der Regel mit kontrastiert Zusammenhalt . Geringe Kopplung korreliert oft mit hohen Kohäsion, und umgekehrt. Low-Kupplung ist oft ein Zeichen für ein gut strukturiertes Computersystem und ein guten Design, und wenn sie mit hohen Kohäsion kombiniert, unterstützt die allgemeinen Ziele von hohen Lesbarkeit und Wartbarkeit. Wiki

Ich denke, die Unterschiede als die folgenden gestellt werden können:

Kohäsions stellt den Grad, in dem ein Teil einer Codebasis eine logisch einzelne, unteilbare Einheit bildet.
Kupplung stellt den Grad, in dem eine einzelne Einheit von den anderen unabhängig ist.
Es ist unmöglich, eine vollständige Entkoppelung zu archivieren, ohne Zusammenhalt zu beschädigen, und umgekehrt.

In dieser Blog-Post schreibe ich über sie im Detail .

Kohäsions ist eine Anzeige der relativen Stärke eines funktionalen Moduls.

eine zusammenhängende Modul führt eine einzelne Aufgabe, wenig erfordern Wechselwirkungen mit anderen Komponenten in anderen Teilen eines Programms. Angegeben einfach, sollte eine zusammenhängende Modul (idealerweise) nicht nur eine Sache.
?Conventional Ansicht:

die „Zielstrebigkeit“ eines Moduls
?OO Ansicht:

?cohesion bedeutet, dass eine Komponente oder Klasse kapselt nur Attribute und Operationen, die eng miteinander verbunden sind zueinander und zu der Klasse oder Komponente selbst
?Levels der Kohäsions

?Functional

?Layer

?Communicational

?Sequential

?Procedural

?Temporal

?utility

Kupplung ist ein Indiz für die relative gegenseitige Abhängigkeit zwischen den Modulen.

hängt Kopplung an der Schnittstelle Komplexität zwischen den Modulen, die Punkt, an dem Eintritt oder wird auf ein Modul hergestellt, und welche Daten Pass über die Schnittstelle.
Herkömmliche Ansicht: Das Ausmaß, in dem eine Komponente mit anderen Komponenten und zur Außenwelt
OO Sicht: ein qualitatives Maß für den Grad, zu dem Klasse verbunden ist, miteinander
Stufe der Kupplung

?Content

?Common

?Control

?Stamp

?Data
?Routine Anruf

?Type Verwendung

?Inclusion oder importieren

?External #

Kupplung = Interaktion / Beziehung zwischen zwei Modulen ... Kohäsions = Interaktion zwischen zwei Elementen innerhalb eines Moduls.

Eine Software ist, die aus vielen Modulen. Modul besteht aus Elementen. Betrachten wir ein Modul ein Programm ist. Eine Funktion innerhalb eines Programms ist ein Element.

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

Innerhalb eines einzigen Programms, Ausgabe einer Funktion an eine andere Funktion übergeben. Dies wird die Interaktion von Elementen innerhalb eines Moduls bezeichnet. Dies wird auch als Kohäsions genannt.

Beispiel:

Kupplung = Kommunikation zwischen zwei verschiedenen Familien ... Kohäsions = Kommunikation zwischen Vater-Mutter-Kind innerhalb einer Familie.

Einfach gesagt, Zusammenhalt bedeutet, dass eine Klasse ein einziges Konzept darstellen sollte.

Die öffentliche Schnittstelle einer Klasse ist bindigen, wenn alle die Klassenmerkmale mit dem Konzept verbunden sind, dass die Klasse darstellt. Zum Beispiel kann anstelle von Cashregister Klasse aufweisen, von denen Cashregister und Münzinneren Zusammenhalt es in 2 Klassen macht -. Cashregister und Münzklasse

Kupplung , eine Klasse von einem anderen abhängt, wie es die Objekte der Klasse verwendet.

Das Problem mit hohen Kopplung ist, dass es Nebenwirkungen erzeugen kann. Eine Änderung in einer Klasse könnte einen unerwarteten Fehler in der anderen Klasse führen und könnte den gesamten Code brechen.

Im Allgemeinen hohe Kohäsion und geringe Kopplung gilt als qualitativ hochwertiger OOP.

Der Ausdruck Zusammenhalt ist in der Tat ein wenig unlogisch für das, was es bedeutet, in Software-Design.

Kohäsions gemeinsame Bedeutung ist, dass etwas, dass Sticks gut zusammen, vereint ist, die durch eine starke Bindung wie molekulare Anziehungs gekennzeichnet sind. Jedoch in Software-Design, es bedeutet, für eine Klasse Streben, die im Idealfall macht nur eine Sache, so dass mehrere Untermodule sind nicht einmal beteiligt.

Vielleicht können wir daran denken auf diese Weise. Ein Teil hat die meisten Zusammenhalt, wenn es der einzige Teil ist (tut nur eine Sache und kann nicht weiter aufgeschlüsselt werden). Dies ist, was in der Software-Design gewünscht ist. Zusammenhalt ist einfach ein anderer Name für „single Verantwortung“ oder „Trennung von Bedenken“.

Der Begriff Kupplung auf die Hand ist recht intuitiv, was bedeutet, wenn ein Modul nicht davon abhängt, zu viele andere Module und diejenigen, die es mit lässt sich problemlos zum Beispiel Gehorchen ersetzt werden kann, Liskov Substitutionsprinzip .

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow