Detaillierte Beispiele für das Abhängigkeitsinversionsprinzip in Java

Dieser Artikel stellt hauptsächlich die Definition des Java-Abhängigkeitsinversionsprinzips und die Lösung des Problems vor. Freunde, die interessiert sind, sollten einen Blick darauf werfen

Definition: High-Level-Module sollten nicht hängen von Low-Level-Modulen ab, beide sollten von ihren Abstraktionen abhängen; Abstraktionen sollten nicht von Details abhängen, sollten von Abstraktionen abhängen;

Ursprung des Problems: Klasse A hängt direkt von Klasse B ab. Wenn Sie Klasse A so ändern möchten, dass sie von Klasse C abhängt, müssen Sie den Code von Klasse A ändern. In diesem Szenario ist Klasse A im Allgemeinen ein High-Level-Modul, das für komplexe Geschäftslogik verantwortlich ist. Die Klassen B und C sind Low-Level-Module, die für grundlegende atomare Operationen verantwortlich sind. Wenn Klasse A geändert wird, birgt dies unnötige Risiken für das Programm.

Lösung: Ändern Sie Klasse A so, dass sie von Schnittstelle I abhängt. Klasse B und Klasse C implementieren jeweils Schnittstelle I. Klasse A kontaktiert Klasse B oder Klasse C indirekt über Schnittstelle I, dann wird es stark Reduzieren Sie die Wahrscheinlichkeit einer Änderung der Kategorie A.

Das Prinzip der Abhängigkeitsinversion basiert auf der Tatsache, dass abstrakte Dinge viel stabiler sind als die Variabilität von Details. Eine auf Abstraktion basierende Architektur ist viel stabiler als eine auf Details basierende Architektur. In Java bezieht sich Abstraktion auf Schnittstellen oder abstrakte Klassen, und Details sind spezifische Implementierungsklassen. Der Zweck der Verwendung von Schnittstellen oder abstrakten Klassen besteht darin, Spezifikationen und Verträge zu formulieren, ohne dass bestimmte Operationen erforderlich sind, und überlässt die Aufgabe, die Details ihrer Implementierungsklasse anzuzeigen vollständig.

Die Kernidee des Abhängigkeitsinversionsprinzips ist die schnittstellenorientierte Programmierung. Wir veranschaulichen anhand eines Beispiels, dass die schnittstellenorientierte Programmierung besser ist als die umsetzungsorientierte Programmierung. Die Szene sieht so aus: Eine Mutter erzählt ihrem Kind eine Geschichte, solange ihr ein Buch gegeben wird. Der Code lautet wie folgt:

class Book{ 
 public String getContent(){ 
  return "很久很久以前有一个阿拉伯的故事……"; 
 } 
} 
class Mother{ 
 public void narrate(Book book){ 
  System.out.println("妈妈开始讲故事"); 
  System.out.println(book.getContent()); 
 } 
} 
public class Client{ 
 public static void main(String[] args){ 
  Mother mother = new Mother(); 
  mother.narrate(new Book()); 
 } 
}

Laufendes Ergebnis:

Mama hat angefangen, Geschichten zu erzählen

Vor langer Zeit gab es eine arabische Geschichte...

Es läuft gut. Wenn die Nachfrage eines Tages so wird: Statt ein Buch zu verschenken, gib ein Zeitung, und lassen Sie die Mutter die Geschichte in der Zeitung erzählen. Der Code der Zeitung lautet wie folgt:

class Newspaper{ 
 public String getContent(){ 
  return "林书豪38+7领导尼克斯击败湖人……"; 
 } 
}

Diese Mutter kann es nicht, weil sie Ich kann die Geschichte nicht in der Zeitung lesen. Das ist einfach lächerlich. Wenn das Buch durch eine Zeitung ersetzt wird, muss die Mutter dazu gebracht werden, es zu lesen. Was passiert, wenn ich in Zukunft auf eine Zeitschrift umsteigen muss? Wie wäre es, es durch eine Webseite zu ersetzen? Man muss die Mutter ständig modifizieren, was offensichtlich kein gutes Design ist. Der Grund dafür ist, dass die Kopplung zwischen Mutter und Buch zu hoch ist und die Kopplung zwischen ihnen verringert werden muss.

Wir stellen eine abstrakte Schnittstelle IReader vor. Lesungen, solange sie Wörter enthalten, sind Lesungen:

interface IReader{ 
 public String getContent(); 
} 
Mother类与接口IReader发生依赖关系，而Book和Newspaper都属于读物的范畴，他们各自都去实现IReader接口，这样就符合依赖倒置原则了，代码修改为：
class Newspaper implements IReader { 
 public String getContent(){ 
  return "林书豪17+9助尼克斯击败老鹰……"; 
 } 
} 
class Book implements IReader{ 
 public String getContent(){ 
  return "很久很久以前有一个阿拉伯的故事……"; 
 } 
} 
class Mother{ 
 public void narrate(IReader reader){ 
  System.out.println("妈妈开始讲故事"); 
  System.out.println(reader.getContent()); 
 } 
} 
public class Client{ 
 public static void main(String[] args){ 
  Mother mother = new Mother(); 
  mother.narrate(new Book()); 
  mother.narrate(new Newspaper()); 
 } 
}

Laufende Ergebnisse:

Mama hat angefangen, Geschichten zu erzählen
A Lange, lange Zeit. Früher gab es eine arabische Geschichte...
Mama begann, die Geschichte zu erzählen

Jeremy Lin half den Knicks, die Hawks mit 17+9 zu besiegen...

Nach dieser Änderung besteht keine Notwendigkeit, die Mutterklasse zu ändern, egal wie Sie die Client-Klasse in Zukunft erweitern. Dies ist nur ein einfaches Beispiel. In tatsächlichen Situationen ist die Mutterklasse, die das übergeordnete Modul darstellt, für die Vervollständigung der Hauptgeschäftslogik verantwortlich. Sobald diese geändert werden muss, ist das Risiko der Einführung von Fehlern extrem hoch. Daher kann die Befolgung des Abhängigkeitsinversionsprinzips die Kopplung zwischen Klassen verringern, die Stabilität des Systems verbessern und die durch Programmänderungen verursachten Risiken verringern.

Die Übernahme des Abhängigkeitsinversionsprinzips bringt großen Komfort für die parallele Entwicklung mit mehreren Personen. Im obigen Beispiel waren beispielsweise die Mutterklasse und die Buchklasse ursprünglich direkt gekoppelt Warten Sie, bis die Buchklasse kodiert ist. Die Kodierung kann durchgeführt werden, da die Mutterklasse von der Buchklasse abhängt. Die geänderten Programme können gleichzeitig gestartet werden, ohne dass sie sich gegenseitig beeinflussen, da die Klassen Mother und Book nichts miteinander zu tun haben. Je mehr Menschen an der kollaborativen Entwicklung beteiligt sind und je größer das Projekt ist, desto bedeutsamer ist die Übernahme des Abhängigkeitsprinzips. Das mittlerweile beliebte TDD-Entwicklungsmodell ist die erfolgreichste Anwendung des Abhängigkeitsinversionsprinzips.

Es gibt drei Möglichkeiten, Abhängigkeiten zu übertragen. Es gibt auch zwei Übertragungsmethoden: Konstruktormethodenübertragung und Settermethodenübertragung Spring Framework. Sie müssen mit der Art und Weise vertraut sein, wie Abhängigkeiten übergeben werden.
Bei der eigentlichen Programmierung müssen wir im Allgemeinen die folgenden drei Punkte tun:

• Low-Level-Module sollten abstrakte Klassen oder Schnittstellen oder beides haben.

• Der deklarierte Typ der Variablen sollte möglichst eine abstrakte Klasse oder Schnittstelle sein.

• Befolgen Sie bei der Verwendung der Vererbung das Liskov-Substitutionsprinzip.

Der Kern des Abhängigkeitsinversionsprinzips besteht darin, dass wir für Schnittstellen programmieren. Wenn wir schnittstellenorientierte Programmierung verstehen, verstehen wir auch Abhängigkeitsinversion.

Das obige ist der detaillierte Inhalt vonDetaillierte Beispiele für das Abhängigkeitsinversionsprinzip in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!