Kopplung in Java

Kopplung ist in JAVA ein Indikator für a. Abhängigkeit einer Klasse von der anderen Klasse in einer objektorientierten Umgebung, b. Grad der Flexibilität, die der Entwickler beim Ändern des Codes über verschiedene Klassen hinweg hat, um den Anforderungen des Endbenutzers gerecht zu werden, c. die Art und Weise, wie die Funktionalität einer Klasse von der anderen Klasse verwendet wird: direkt oder mit Hilfe externer Schnittstellen, d von Codes. Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Kopplungsarten in Java

In Java gibt es zwei große Kopplungen. Lassen Sie uns diese im Detail analysieren.

1. Enge Kopplung

Beim objektorientierten Anwendungsdesign besteht immer die Notwendigkeit, die in einer Klasse entwickelte Logik in einer anderen Klasse zu nutzen, um die bereits investierten Anstrengungen wiederzuverwenden und zu vermeiden, dass das Rad neu erfunden wird.

Direkte Zusammenarbeit zwischen den Klassen führt zu einer engen Kopplung, und ihre Funktionen sind

Die in der aufgerufenen Klasse verfügbare Geschäftslogik wird als Objekt innerhalb der aufrufenden Klasse erstellt.

Das so erstellte Objekt wird innerhalb der aufrufenden Klasse ausgeführt, um die erforderliche Funktionalität zu erreichen. Daher kennt das aufrufende Programm die volle Funktionalität der in der aufgerufenen Klasse verfügbaren Geschäftslogik.
Alle Änderungen in der in der aufgerufenen Klasse codierten Geschäftslogik wirken sich auf die Ergebnisse der aufgerufenen Klasse aus
Wenn die Änderungen in der aufgerufenen Klasse unvermeidlich sind, müssen entsprechende Änderungen auch in der aufrufenden Klasse durchgeführt werden.
Daher sind die Klassen stark voneinander abhängig
• Beispiel einer engen Kopplung

Zwei kollaborierende Klassen in diesem Beispiel, „Ordervalue“ und „order“, sind voneinander abhängig. Die aufrufende Klasse „Ordervalue“ kennt die in der aufgerufenen Klasse „order“ codierte Geschäftslogik entsprechend, der Code in der aufrufenden Klasse ist strukturiert und jede Änderung in der aufgerufenen Klasse wird die Ergebnisse des Programms verfälschen.

Daraus kann geschlossen werden, dass die Klassen „Ordervalue“ und „Order“ eng miteinander verbunden sind.

Code:

Ausgabe:

// Tight Coupling - Sample program
public class ordervalue // Calling class
{
public static void main(String args[]) // method in the class
{
order b = new order(600,5); // creating object for the called class
System.out.println("value of the order is");
// order and execute it
System.out.println(b.value); // Prints the order value computed by
} // the called class
}
class order // Called class
{
public int value; // method in the class
order(int orderquantity, int rate) // business logic
{
this.value = orderquantity * rate; // computing the value
}
}

2. Lose Kupplung

In diesem Konzept werden Klassen, die zusammenarbeiten müssen, um Geschäftslogik und gemeinsame Funktionalitäten in OOPS zu teilen, über externe Quellen gekoppelt. Somit sind sie lose oder indirekt miteinander verbunden.

Hauptmerkmale der losen Kopplung sind

Die Abhängigkeit zwischen Klassen, Codekomponenten und Modulen ist gering.

Wenn die Abhängigkeit unvermeidlich ist, dann werden sie über externe Komponenten wie Schnittstellen verbunden.
Die Konnektivität über Schnittstellen wird minimal gehalten, um die Vorteile der losen Kopplung zu nutzen.
Es besteht keine Notwendigkeit, Objekte rund um die anderen Klassen innerhalb einer Klasse zu definieren, und Objekte sind unabhängig.
Jede Klasse kennt nur wenige Informationen über die anderen Klassen in dieser Kopplung. Im besten Fall kennt jede Klasse die Schnittstellen, denen die anderen Module ausgesetzt sind.
Jede Änderung am Code in einer Klasse hat keine Auswirkungen auf die anderen Klassen und sie müssen nicht aktualisiert werden.
Es bietet dem Entwickler perfekte Flexibilität, den Code einfach zu ändern und neue Geschäftsänderungen zu berücksichtigen.
Der Zeit- und Arbeitsaufwand für die Programmpflege wird drastisch reduziert
Konzepte des Spring-Frameworks wie Inversion of Control und Dependency Injection werden verwendet, um enge Kopplung zu überwinden.
• Inversion of Control (IOC)

Es handelt sich um ein Konzept, mit dem die Steuerung von Programmmodulen oder Objekten auf das Container-Framework übertragen wird. Dieses Konzept wird in OOPS ziemlich regelmäßig verwendet. Anstatt dass Programmcodes eine Bibliothek aufrufen, übernimmt das Container-Framework die Steuerung und Aufrufcodes. Den Objekten wird eine Abhängigkeit injiziert, im Gegensatz zu Objekten, die Abhängigkeiten erzeugen.

Dieses Konzept erleichtert eine lose Kopplung und Modularität in der Programmierung.

Abhängigkeitsinjektion (DI)

DI ist das Vehikel, über das IOC-Konzepte in Gebrauch genommen werden, und die Kontrollübertragung erfolgt beim Einrichten von Objektabhängigkeiten.

Beispiele für lose Kopplung

In the example, three Classes, “month1”, “month2”, “month3” are independent modules, and they collaborate little with each other through an interface “iface”. As a result, these classes have very little knowledge of the other classes on what they are doing. They only know that all the classes are interacting with an interface.

There is no object created using the other classes in any of these classes, and they are the typical examples of loose coupling.

Code:

// Loose Coupling in JAVA - Sample Program
interface Iface //Interface is defined
{
public void monthname(); //module within the interface
}
class month1 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("January");
}
}
class month2 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("Feburary");
}
}
class month3 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("March");
}
}
public class Subject { // Execution starts here
public static void main(String[] args)
{
Iface t = new month1(); // First class called thru
t.monthname(); // interface
Iface tx = new month2(); // Second class called thru
tx.monthname(); // interface
Iface tx2 = new month3(); // Third class called thru
tx2.monthname(); } // interface
}

Output:

Conclusion

As far as possible, applications will have to be designed to hold only loose couplings for better maintainability and serviceability and keep interdependence between program components very minimal. However, if interdependence is a must, the components will have to be connected only through the interface.

Das obige ist der detaillierte Inhalt vonKopplung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!