Beispielerklärung des Schnittstellenisolationsprinzips in Java

Dieser Artikel stellt hauptsächlich das Prinzip der Schnittstellenisolation vor. Der Herausgeber findet es ziemlich gut. Ich werde es jetzt mit Ihnen teilen und es als Referenz geben. Folgen wir dem Editor und werfen wir einen Blick darauf.

Definition: Der Client sollte sich nicht auf Schnittstellen verlassen, die er nicht benötigt; die Abhängigkeit einer Klasse von einer anderen Klasse sollte auf der kleinsten Schnittstelle basieren .

Ursprung des Problems: Klasse A hängt von Klasse B über Schnittstelle I ab, Klasse C hängt von Klasse D über Schnittstelle I ab, wenn Schnittstelle I nicht die Mindestschnittstelle für Klasse ist A und Klasse B, dann müssen Klasse B und Klasse D Methoden implementieren, die sie nicht benötigen.

Lösung: Teilen Sie die aufgeblähte Schnittstelle I in mehrere unabhängige Schnittstellen auf, und Klasse A und Klasse C stellen Abhängigkeiten mit den Schnittstellen her, die sie jeweils benötigen. Das heißt, das Prinzip der Schnittstellenisolation wird übernommen.
Ein Beispiel zur Veranschaulichung des Schnittstellenisolationsprinzips:

(Abbildung 1 Design, das nicht dem Schnittstellenisolationsprinzip folgt)

Was Dieses Bild bedeutet: Klasse A hängt von Methode 1, Methode 2 und Methode 3 in Schnittstelle I ab. Klasse B ist die Implementierung der Abhängigkeit von Klasse A. Klasse C hängt von Methode 1, Methode 4 und Methode 5 in Schnittstelle I ab. Klasse D ist die Implementierung der Abhängigkeit von Klasse C. Obwohl beide Klassen B und D nicht verwendete Methoden haben (d. h. die in der Abbildung rot markierten Methoden), müssen diese nicht verwendeten Methoden ebenfalls implementiert werden, da Schnittstelle I implementiert ist. Wer mit Klassendiagrammen nicht vertraut ist, kann sich zum Verständnis auf den Programmcode beziehen. Der Code lautet wie folgt:

interface I {
  public void method1();
  public void method2();
  public void method3();
  public void method4();
  public void method5();
}

class A{
  public void depend1(I i){
    i.method1();
  }
  public void depend2(I i){
    i.method2();
  }
  public void depend3(I i){
    i.method3();
  }
}

class B implements I{
  public void method1() {
    System.out.println("类B实现接口I的方法1");
  }
  public void method2() {
    System.out.println("类B实现接口I的方法2");
  }
  public void method3() {
    System.out.println("类B实现接口I的方法3");
  }
  //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，
  //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
  public void method4() {}
  public void method5() {}
}

class C{
  public void depend1(I i){
    i.method1();
  }
  public void depend2(I i){
    i.method4();
  }
  public void depend3(I i){
    i.method5();
  }
}

class D implements I{
  public void method1() {
    System.out.println("类D实现接口I的方法1");
  }
  //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，
  //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
  public void method2() {}
  public void method3() {}

  public void method4() {
    System.out.println("类D实现接口I的方法4");
  }
  public void method5() {
    System.out.println("类D实现接口I的方法5");
  }
}

public class Client{
  public static void main(String[] args){
    A a = new A();
    a.depend1(new B());
    a.depend2(new B());
    a.depend3(new B());

    C c = new C();
    c.depend1(new D());
    c.depend2(new D());
    c.depend3(new D());
  }
}

Wie Sie sehen können, Wenn die Schnittstelle zu aufgebläht ist, müssen die in der Schnittstelle angezeigten Methoden, unabhängig davon, ob sie für die von ihnen abhängigen Klassen nützlich sind, in der Implementierungsklasse implementiert werden. Wenn dieses Design geändert wird, um dem Schnittstellenisolationsprinzip zu entsprechen, muss Schnittstelle I aufgeteilt werden. Hier teilen wir die ursprüngliche Schnittstelle I in drei Schnittstellen auf. Das geteilte Design ist in Abbildung 2 dargestellt:

(Abbildung 2 folgt dem Schnittstellenisolationsprinzip Design)

Veröffentlichen Sie den Code des Programms wie gewohnt als Referenz für Freunde, die mit Klassendiagrammen nicht vertraut sind:

interface I1 {
  public void method1();
}

interface I2 {
  public void method2();
  public void method3();
}

interface I3 {
  public void method4();
  public void method5();
}

class A{
  public void depend1(I1 i){
    i.method1();
  }
  public void depend2(I2 i){
    i.method2();
  }
  public void depend3(I2 i){
    i.method3();
  }
}

class B implements I1, I2{
  public void method1() {
    System.out.println("类B实现接口I1的方法1");
  }
  public void method2() {
    System.out.println("类B实现接口I2的方法2");
  }
  public void method3() {
    System.out.println("类B实现接口I2的方法3");
  }
}

class C{
  public void depend1(I1 i){
    i.method1();
  }
  public void depend2(I3 i){
    i.method4();
  }
  public void depend3(I3 i){
    i.method5();
  }
}

class D implements I1, I3{
  public void method1() {
    System.out.println("类D实现接口I1的方法1");
  }
  public void method4() {
    System.out.println("类D实现接口I3的方法4");
  }
  public void method5() {
    System.out.println("类D实现接口I3的方法5");
  }
}

Schnittstellenisolation Die Bedeutung Das Prinzip lautet: Erstellen Sie eine einzelne Schnittstelle, erstellen Sie keine riesige und aufgeblähte Schnittstelle, versuchen Sie, die Schnittstelle so weit wie möglich zu verfeinern und so wenig Methoden wie möglich in der Schnittstelle zu haben. Mit anderen Worten: Wir müssen für jede Klasse dedizierte Schnittstellen einrichten, anstatt zu versuchen, eine riesige Schnittstelle für alle Klassen zu erstellen, deren Aufruf darauf angewiesen ist. Im Beispiel in diesem Artikel wird das Schnittstellenisolationsprinzip verwendet, um eine große Schnittstelle in drei dedizierte Schnittstellen umzuwandeln. Bei der Programmierung ist es flexibler, auf mehrere dedizierte Schnittstellen zu setzen, als auf eine umfassende Schnittstelle. Schnittstellen sind „Verträge“, die während des Entwurfs extern festgelegt werden. Durch die dezentralisierte Definition mehrerer Schnittstellen können wir die Verbreitung externer Änderungen verhindern und die Flexibilität und Wartbarkeit des Systems verbessern.

Apropos: Viele Leute werden denken, dass das Prinzip der Schnittstellenisolation dem vorherigen Prinzip der Einzelverantwortung sehr ähnlich ist, aber das ist nicht der Fall. Erstens konzentrierte sich das Prinzip der Einzelverantwortung ursprünglich auf Verantwortlichkeiten, während sich das Prinzip der Schnittstellenisolation auf die Isolierung von Schnittstellenabhängigkeiten konzentrierte. Zweitens schränkt das Prinzip der Einzelverantwortung hauptsächlich Klassen ein, gefolgt von Schnittstellen und Methoden, die auf die Implementierung und Details des Programms abzielen, während das Prinzip der Schnittstellenisolation hauptsächlich Schnittstellen einschränkt, hauptsächlich zur Abstraktion und für den Aufbau des Gesamtrahmens des Programms .

Wenn Sie das Schnittstellenisolationsprinzip zur Einschränkung von Schnittstellen verwenden, achten Sie auf die folgenden Punkte:

• Die Schnittstelle sollte so klein wie möglich sein. aber in Grenzen. Es ist eine Tatsache, dass eine Verfeinerung der Schnittstelle die Programmierflexibilität verbessern kann. Wenn sie jedoch zu klein ist, führt dies zu zu vielen Schnittstellen und verkompliziert das Design. Es muss also in Maßen geschehen.

• Passen Sie Dienste für Klassen an, die auf Schnittstellen basieren, indem Sie der aufrufenden Klasse nur die Methoden zur Verfügung stellen, die sie benötigt, während Sie die Methoden ausblenden, die sie nicht benötigt. Nur durch die Fokussierung auf die Bereitstellung maßgeschneiderter Dienste für ein Modul können minimale Abhängigkeiten hergestellt werden.

• Verbessern Sie den Zusammenhalt und reduzieren Sie externe Interaktionen. Stellen Sie sicher, dass die Schnittstelle die wenigsten Methoden verwendet, um die meisten Aufgaben zu erledigen.

Verwenden Sie das Schnittstellenisolationsprinzip und es muss moderat sein. Es ist nicht gut, die Schnittstelle zu groß oder zu klein zu gestalten. Beim Entwerfen einer Benutzeroberfläche können Sie dieses Prinzip nur dann genau umsetzen, wenn Sie mehr Zeit zum Nachdenken und Planen aufwenden

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