it-swarm.com.de

Was ist der Unterschied zwischen loser Kopplung und enger Kopplung im objektorientierten Paradigma?

Kann jemand den genauen Unterschied zwischen loser Kopplung und enger Kopplung im objektorientierten Paradigma beschreiben?

229
Jim

Enge Kopplung ist, wenn eine Gruppe von Klassen stark voneinander abhängig ist. 

Dieses Szenario tritt auf, wenn eine Klasse zu viele Verantwortlichkeiten übernimmt oder wenn ein Anliegen über viele Klassen verteilt ist und nicht über eine eigene Klasse verfügt.

Eine lose Kopplung wird durch ein Design erreicht, das die Einzelverantwortung und die Trennung der Anliegen fördert.

Eine lose gekoppelte Klasse kann unabhängig von anderen (konkreten) Klassen konsumiert und getestet werden.

Schnittstellen sind ein leistungsfähiges Werkzeug zur Entkopplung. Klassen können über Schnittstellen anstatt über andere konkrete Klassen kommunizieren, und jede Klasse kann sich am anderen Ende dieser Kommunikation befinden, indem sie einfach die Schnittstelle implementiert.

Beispiel für eine feste Verbindung:

class CustomerRepository
{
    private readonly Database database;

    public CustomerRepository(Database database)
    {
        this.database = database;
    }

    public void Add(string CustomerName)
    {
        database.AddRow("Customer", CustomerName);
    }
}

class Database
{
    public void AddRow(string Table, string Value)
    {
    }
}

Beispiel für lose Kupplung:

class CustomerRepository
{
    private readonly IDatabase database;

    public CustomerRepository(IDatabase database)
    {
        this.database = database;
    }

    public void Add(string CustomerName)
    {
        database.AddRow("Customer", CustomerName);
    }
}

interface IDatabase
{
    void AddRow(string Table, string Value);
}

class Database : IDatabase
{
    public void AddRow(string Table, string Value)
    {
    }
}

Ein weiteres Beispiel hier .

286
Jonathan

Einfache Erklärung ohne Code

Zusammenfassendes Beispiel:

Der Hut ist "lose" an den Körper gekoppelt. Dies bedeutet, dass Sie den Hut leicht abnehmen können, ohne Änderungen an der Person/am Körper vorzunehmen. Wenn Sie das können, dann haben Sie "lose Kopplung". Weitere Informationen finden Sie unten. 

 The Hat is "loosely coupled" to the body. This means you can easily take then hat off without making any changes to the the person/body. Picture Attribution: https://pixabay.com/en/greeting-cylinder-chapeau-dignity-317250/

Enge Kupplung (detailliertes Beispiel)

Denken Sie an Ihre Haut. Es hängt an deinem Körper. Es passt wie angegossen. Aber was wäre, wenn Sie Ihre Hautfarbe von weiß zu schwarz ändern wollten? Können Sie sich vorstellen, wie schmerzhaft es sein würde, Ihre Haut abzuziehen, zu färben und dann wieder auf die Haut zu kleben? Das Wechseln der Haut ist schwierig, da sie fest mit Ihrem Körper verbunden ist. Sie können einfach nicht einfach Änderungen vornehmen. Sie müssten einen Menschen grundlegend umgestalten, um dies zu ermöglichen. 

  • Schlüsselpunkt # 1: Mit anderen Worten, wenn Sie die Haut ändern möchten, MÜSSEN Sie auch das Design Ihres Körpers ändern, da die beiden Elemente dies sind miteinander verbunden - sie sind eng miteinander verbunden. 

Gott war kein guter objektorientierter Programmierer.

Lose Kupplung (detailliertes Beispiel)

Denken Sie jetzt daran, sich morgens anzuziehen. Du magst kein Blau? Keine Probleme: Sie können stattdessen ein rotes Hemd anziehen. Dies ist leicht und mühelos möglich, da das Hemd nicht so mit Ihrem Körper verbunden ist wie Ihre Haut. Das Shirt weiß nicht oder kümmert sich nicht um welchen Körper es geht. Mit anderen Worten, Sie können Ihre Kleidung wechseln, ohne Ihren Körper wirklich zu verändern. 

  • Das ist der Schlüsselpunkt Nr. 2. Wenn Sie Ihr Hemd wechseln, sind Sie nicht gezwungen, Ihren Körper zu wechseln - wenn Sie das können, dann haben Sie lockere Kopplung. Wenn Sie das nicht können, dann haben Sie eine enge Verbindung.

Das ist das Grundkonzept in aller Kürze. 

Warum ist das alles wichtig?

Dies ist wichtig, da sich die Software ständig ändert. Im Allgemeinen möchten Sie Ihren Code einfach ändern können.

Praxisbeispiele der Kopplung in der Datenverarbeitung

  • Wenn jemand seine Ausgabe in einer CSV-Datei anstelle von JSON usw. wünscht oder wenn Sie von MySQL zu PostGreSQL wechseln möchten, sollten Sie diese Änderungen sehr einfach in Ihrem Code vornehmen können, ohne die gesamte Klasse usw. neu schreiben zu müssen Sie möchten Ihre Anwendung also nicht mit einer bestimmten Datenbankimplementierung (z. B. Mysql) oder einer bestimmten Ausgabe (z. B. CSV-Dateien) eng koppeln. Denn wie es in der Software unvermeidlich ist, werden sich Änderungen ergeben. Wenn sie kommen, ist es viel einfacher, wenn Ihre Teile Ihres Codes lose miteinander verbunden sind.

Ein anderes Beispiel: Auto- und Ersatzteil-Analogie der Kupplung

  • Wenn jemand sein Auto in black möchte, müssen Sie dafür nicht das gesamte Auto umgestalten. Ein Auto und seine Ersatzteile wären ein perfektes Beispiel für eine locker gekoppelte Architektur (wie in den Kommentaren von @ mnmopazem). Wenn Sie Ihren Motor durch einen besseren ersetzen möchten, sollten Sie in der Lage sein, Ihren Motor ohne großen Aufwand zu entfernen und durch einen besseren zu ersetzen. Wenn Ihr Auto nur mit Rolls Royce 1234-Motoren und keinen anderen Motoren funktioniert - dann ist Ihr Auto eng mit diesem Motor verbunden (Rolls Royce 1234). Es wäre besser, wenn Sie das Design Ihres Autos so geändert haben, dass es mit any engine funktioniert, sodass es mit den Komponenten etwas lockerer gekoppelt ist. Besser wäre es, wenn Ihr Auto ohne Motor funktionieren könnte! Ein gewisses Maß an Kopplung wird passieren, aber Sie sollten daran arbeiten, sie so weit wie möglich zu minimieren. Warum? Denn wenn sich die Anforderungen ändern, sollten wir immer noch in der Lage sein, qualitativ hochwertige Software zu liefern, und wir werden durch lose Kopplung dabei unterstützt.

Zusammenfassung

Kurz gesagt, lockere Kopplung erleichtert die Änderung des Codes. Die obigen Antworten enthalten einen Code, der an dieser Stelle lesenswert ist.

Bildzuteilung .

125
BKSpurgeon

Beim objektorientierten Design bezieht sich der Kopplungsgrad darauf, wie sehr das Design einer Klasse vom Design einer anderen Klasse abhängt. Mit anderen Worten, wie oft ändern sich Änderungen in der Kraft der Klasse A in Klasse B? Feste Kopplung bedeutet, dass sich die beiden Klassen häufig zusammen ändern, lose Kopplung bedeutet, dass sie meist unabhängig sind. Im Allgemeinen wird eine lose Kopplung empfohlen, da sie einfacher zu testen und zu warten ist.

Sie finden dieses Dokument von Martin Fowler (PDF) hilfreich.

64
Don Kirkby

Im Allgemeinen ist Tight Coupling in der Regel schlecht, da es die Flexibilität und Wiederverwendbarkeit von Code reduziert, Änderungen erheblich erschwert und die Testbarkeit beeinträchtigt.

Ein eng gekuppeltes Objekt ist ein Objekt, das einiges voneinander wissen muss und in der Regel stark von den anderen Schnittstellen abhängt. Das Ändern eines Objekts in einer eng gekoppelten Anwendung erfordert häufig Änderungen an einer Reihe anderer Objekte. In einer kleinen Anwendung können wir die Änderungen leicht erkennen und die Wahrscheinlichkeit, etwas zu übersehen, ist geringer. In großen Anwendungen sind diese wechselseitigen Abhängigkeiten jedoch nicht jedem Programmierer bekannt oder es besteht die Chance, Änderungen zu übersehen. Jeder Satz lose gekoppelter Objekte ist jedoch nicht von anderen abhängig.

Zusammenfassend kann gesagt werden, dass lose Kopplung ein Entwurfsziel ist, das darauf abzielt, die wechselseitigen Abhängigkeiten zwischen Komponenten eines Systems zu reduzieren, um das Risiko zu reduzieren, dass Änderungen an einer Komponente Änderungen an anderen Komponenten erfordern. Lose Kopplung ist ein weitaus generischeres Konzept, das die Flexibilität eines Systems erhöhen, es wartungsfreundlicher machen und den gesamten Rahmen stabiler machen soll.

Kopplung bezieht sich auf den Grad der direkten Kenntnis, den ein Element von einem anderen hat. Wir können ein Beispiel sagen: A und B, nur B ändert sein Verhalten nur, wenn A sein Verhalten ändert. Ein lose gekoppeltes System kann leicht in definierbare Elemente zerlegt werden. 

13
Jom George

Wenn zwei Objekte lose miteinander verbunden sind, können sie miteinander interagieren, kennen sich jedoch sehr wenig. 

Mit lose gekoppelten Designs können wir flexible OO - Systeme erstellen, die mit Veränderungen umgehen können.

Observer Design Pattern ist ein gutes Beispiel, um Klassen lose gekoppelt zu machen. Sie können es in Wikipedia anschauen.

9
Ahmed_Gad

Ich verstehe es so, dass eine eng gekoppelte Architektur im Vergleich zu einer locker gekoppelten Architektur nicht viel Flexibilität für Änderungen bietet. 

Bei locker gekoppelten Architekturen wirken sich Nachrichtenformate oder Betriebsplattformen oder die Umgestaltung der Geschäftslogik jedoch nicht auf das andere Ende aus. Wenn das System für eine Überarbeitung heruntergefahren wird, kann das andere Ende natürlich für eine Weile nicht auf den Dienst zugreifen, aber ansonsten kann das unveränderte Ende den Nachrichtenaustausch so fortsetzen, wie es vor der Überarbeitung war. 

5
Amit Kumar

Ein Auszug aus meinem Blogbeitrag zur Kopplung:

Was ist enge Verbindung: -

Wie in der obigen Definition ist ein eng verbundenes Objekt ein Objekt, das über andere Objekte Bescheid wissen muss und in der Regel stark von den Schnittstellen der jeweils anderen abhängig ist. 

Wenn wir ein Objekt in einer eng gekoppelten Anwendung ändern, sind häufig Änderungen an einer Reihe anderer Objekte erforderlich. Es gibt kein Problem in einer kleinen Anwendung, die die Änderung leicht erkennen kann. Bei großen Anwendungen sind diese Abhängigkeiten jedoch nicht immer jedem Verbraucher oder anderen Entwicklern bekannt, oder es besteht eine große Chance auf zukünftige Änderungen. 

Nehmen wir den Demo-Code eines Einkaufswagens, um die enge Verbindung zu verstehen:

namespace DNSLooseCoupling
{
    public class ShoppingCart
    {
        public float Price;
        public int Quantity;

        public float GetRowItemTotal()
        {
            return Price * Quantity;
        }
    }

    public class ShoppingCartContents
    {
        public ShoppingCart[] items;

        public float GetCartItemsTotal()
        {
            float cartTotal = 0;
            foreach (ShoppingCart item in items)
            {
                cartTotal += item.GetRowItemTotal();
            }
            return cartTotal;
        }
    }

    public class Order
    {
        private ShoppingCartContents cart;
        private float salesTax;

        public Order(ShoppingCartContents cart, float salesTax)
        {
            this.cart = cart;
            this.salesTax = salesTax;
        }

        public float OrderTotal()
        {
            return cart.GetCartItemsTotal() * (2.0f + salesTax);
        }
    }
}

Probleme mit dem obigen Beispiel

Enge Kopplung schafft einige Schwierigkeiten. 

Hier geben uns OrderTotal() Methoden den vollen Betrag für die aktuellen Artikel der Wagen an. Wenn wir die Rabattfunktionen in dieses Warenkorbsystem einfügen möchten. Im obigen Code ist es sehr schwierig, da in jeder Klasse Änderungen vorgenommen werden müssen, da er sehr eng gekoppelt ist. 

4
Anil Sharma

Es gibt bestimmte Werkzeuge, die eine Abhängigkeitsinjektion durch ihre Bibliothek ermöglichen, zum Beispiel in .net haben wir ninject Library .

Wenn Sie in Java weiter gehen, bietet spring diese Funktionen.

Locker gekoppelte Objekte können erstellt werden, indem in Ihren Code Interfaces eingefügt wird. Dies ist, was diese Quellen tun.

Sagen Sie in Ihrem Code, dass Sie schreiben 

Myclass m = new Myclass();

jetzt sagt diese Anweisung in Ihrer Methode, dass Sie auf myclass angewiesen sind. Dies wird eng gekoppelt genannt. Jetzt stellen Sie eine Konstruktorinjektion oder eine Objektinjektion und ein Objekt bereit, die dann lose zusammengefügt werden.

3
Vishal Sharma

Eine lose Kopplung bedeutet, dass der Grad der Abhängigkeit zwischen zwei Komponenten sehr gering ist.
Beispiel: GSM SIM

Enge Kopplung bedeutet, dass der Grad der Abhängigkeit zwischen zwei Komponenten sehr hoch ist.
Beispiel: CDMA Mobile

3
govind satpute

Lose Kopplung ist und ist die Antwort auf alte hartcodierte Abhängigkeiten und damit zusammenhängende Probleme, z. B. häufige Neukompilierung bei Änderungen und Wiederverwendung von Code. Es legt Wert darauf, die Worker-Logik in Komponenten zu implementieren und dort lösungsspezifischen Code für die Verdrahtung zu vermeiden. 

Lose Kopplung = IoC Siehe dies zur leichteren Erklärung.

2
MSIL

Enge Kopplung bedeutet, dass eine Klasse von einer anderen Klasse abhängig ist.
Loose Coupling bedeutet, dass eine Klasse von der Schnittstelle und nicht von der Klasse abhängig ist.

In tight Kopplung gibt es in Methoden festgelegte Abhängigkeiten.
Bei loser Kopplung müssen wir die Abhängigkeit zur Laufzeit extern statt hartcodiert übergeben. (Systeme mit loser Verbindung verwenden die Schnittstelle, um die Abhängigkeit von der Klasse zu verringern.)

Zum Beispiel haben wir ein System, das die Ausgabe auf zwei oder mehr Arten senden kann, wie JSON-Ausgabe, CSV-Ausgabe usw.

Fest gekoppelt

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput() {
        // Here Output will be in CSV-Format, because of hard-coded code.
        // This method tightly coupled with CSVOutputGenerator class, if we want another Output, we must change this method.
        // Any method, that calls Class1's generateOutput will return CSVOutput, because Class1 is tight couple with CSVOutputGenerator.
        OutputGenerator outputGenerator = new CSVOutputGenerator();
        output.generateOutput();
    }
}

Wenn Sie im obigen Beispiel die Ausgabe in JSON ändern möchten, müssen Sie den gesamten Code suchen und ändern, da Class1 eng mit der Klasse CSVOutputGenerator gekoppelt ist.

Lose gekoppelt

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput(OutputGenerator outputGenerator) {
        // if you want to write JSON, pass object of JSONOutputGenerator (Dependency will be passed externally to this method)
        // if you want to write CSV, pass object of CSVOutputGenerator (Dependency will be passed externally to this method)

        // Due to loose couple with class, we don't need to change code of Class1, because Class1 is loose coupled with CSVOutputGenerator or JSONOutputGenerator class
        // Any method, that calls Class1's generateOutput will desired output, because Class1 does not tight couple with CSVOutputGenerator or JSONOutputGenerator class
        OutputGenerator outputGenerator = outputGenerator;
        output.generateOutput();
    }
}
2
Milan Vaghasiya

Es geht um Klassen Abhängigkeitsrate um eine andere, die in locker gekoppelten und in eng gekoppelten so hoch ist. Um klar zu sein, in der Serviceorientierungsarchitektur, sind Services lose miteinander gekoppelt gegen monolithisch, wobei die Klassenabhängigkeit der Klassen zweckmäßig ist

1
Mohi72

Loose Coupling ist der Prozess, bei dem Sie die Abhängigkeit angeben, die Ihre Klasse indirekt benötigt, ohne alle Informationen über die Abhängigkeit (d. H. In der Von-Schnittstelle) anzugeben, falls Sie eine enge Kopplung direkt in der Abhängigkeit angeben, die keine gute Codierung darstellt. 

1
David William

Wenn die Erstellung/Existenz eines Objekts von einem anderen Objekt abhängt, das nicht maßgeschneidert werden kann, ist es eng gekoppelt. Und wenn die Abhängigkeit angepasst werden kann, die lose Kopplung. Betrachten Sie ein Beispiel in Java:

class Car {

    private Engine engine = new Engine( "X_COMPANY" ); // this car is being created with "X_COMPANY" engine
    // Other parts

    public Car() { 
        // implemenation 
    }

}

Der Client der Car-Klasse kann einen mit NUR "X_COMPANY" -Motor erstellen.

Betrachten Sie das Brechen dieser Kopplung mit der Fähigkeit, das zu ändern:

class Car {

    private Engine engine;
    // Other members

    public Car( Engine engine ) { // this car can be created with any Engine type
        this.engine = engine;
    }

}

Nun ist eine Car nicht von einer Engine von "X_COMPANY" abhängig, da sie mit Typen erstellt werden kann.

Ein Java-spezifischer Hinweis: Die Verwendung von Java-Schnittstellen nur zur Abkopplung ist aus Gründen der Designierung keine geeignete Vorgehensweise. In Java hat eine Schnittstelle einen Zweck - als einen Vertrag zu fungieren, der intrinsisch ein Abkopplungsverhalten/einen Vorteil bietet.

Bill Rosmus 'Kommentar in akzeptierter Antwort hat eine gute Erklärung.

0
lupchiazoem

Hier gibt es viele nette Antworten mit Analogien, aber ein Freund bei der Arbeit gab mir ein Beispiel, das mir mehr gefiel als alle hier genannten ... Augen und Brillen!

Enge Verbindung

Enge Kopplung wären die Augen. Wenn ich mein Sehvermögen verbessern möchte, ist die Durchführung einer Augentransplantation sehr teuer und mit einem hohen Risiko verbunden. Aber was ist, wenn der Designer (der Mensch ist) einen besseren Weg gefunden hat? Fügen Sie eine Funktion hinzu, die lose mit dem Körper verbunden ist, damit sie leicht geändert werden kann! (ja .. Brille)

Lose Kopplung

Ich kann meine Brille leicht austauschen, ohne die zugrunde liegende Sicht zu beeinträchtigen. Ich kann die Brille abnehmen und meine Vision wird sein, wie es vorher war (nicht besser oder schlechter). Durch die Verwendung verschiedener Brillen wird die Wahrnehmung der Welt durch unsere Augen mit geringem Risiko und einfacher Wartbarkeit verändert.

Zusammenfassung

Also fragt dich das nächste Mal jemand, "wen interessiert es, ob mein Code eng gekoppelt ist?" Bei der Antwort dreht sich alles um Anstrengungen zur Veränderung, Bemühungen zur Aufrechterhaltung und das Risiko von Veränderungen.

Wie wird das in C # gemacht? Schnittstellen und Abhängigkeitsinjektion!

EDIT

Dies ist auch ein gutes Beispiel für das Decorator-Muster, bei dem die Augen die Klasse sind, die wir dekorieren, indem wir die Schnittstellenanforderungen erfüllen, aber unterschiedliche Funktionen bieten (z. B. Sonnenbrillen, Lesebrillen, Lupen für Juweliere usw.).

0
JohnChris