Einführung in das Richter-Substitutionsprinzip in Java

In diesem Artikel werden hauptsächlich die relevanten Informationen zum Liskov-Substitutionsprinzip ausführlich vorgestellt, die einen gewissen Referenzwert haben.

Lassen Sie uns über das Liskov-Substitutionsprinzip sprechen.

Definition 1: Wenn es für jedes Objekt o1 vom Typ T1 ein Objekt o2 vom Typ T2 gibt, so werden beim Wechsel zu alle mit T1 definierten Programme P in allen Objekten o1 dargestellt o2, das Verhalten von Programm P ändert sich nicht, dann ist Typ T2 ein Untertyp von Typ T1.

Definition 2: Alle Orte, die auf eine Basisklasse verweisen, müssen in der Lage sein, Objekte ihrer Unterklassen transparent zu verwenden.

Ursprung des Problems: Es gibt eine Funktion P1, die durch Klasse A vervollständigt wird. Jetzt muss die Funktion P1 erweitert werden, und die erweiterte Funktion ist P, wobei P aus der ursprünglichen Funktion P1 und der neuen Funktion P2 besteht. Wenn die neue Funktion P von der Unterkategorie B der Kategorie A implementiert wird, kann die Unterkategorie B zu einer Fehlfunktion der ursprünglichen Funktion P1 führen, während die neue Funktion P2 ausgeführt wird.

Lösung: Befolgen Sie bei der Verwendung der Vererbung das Liskov-Substitutionsprinzip. Wenn Klasse B Klasse A erbt, versuchen Sie, außer dem Hinzufügen neuer Methoden zur Vervollständigung der neuen Funktion P2, die Methoden der übergeordneten Klasse A nicht zu überschreiben und die Methoden der übergeordneten Klasse A nicht zu überladen.

Vererbung hat die folgende Bedeutung: Alle Methoden, die in der übergeordneten Klasse implementiert wurden (im Vergleich zu abstrakten Methoden), legen tatsächlich eine Reihe von Spezifikationen und Verträgen fest, obwohl dies nicht der Fall ist Es ist für alle obligatorisch Unterklassen müssen diese Verträge einhalten. Wenn Unterklassen diese nicht abstrakten Methoden jedoch willkürlich ändern, führt dies zu Schäden am gesamten Vererbungssystem. Das Liskov-Substitutionsprinzip drückt diese Bedeutung aus.

Als eines der drei Hauptmerkmale der objektorientierten Programmierung bringt die Vererbung großen Komfort in die Programmierung, bringt aber auch Nachteile mit sich. Die Verwendung der Vererbung führt beispielsweise zu Eingriffen in das Programm, verringert die Portabilität des Programms und erhöht die Kopplung zwischen Objekten. Wenn eine Klasse von anderen Klassen geerbt wird und diese Klasse geändert werden muss, müssen alle Unterklassen berücksichtigt werden .Klasse, und nachdem die übergeordnete Klasse geändert wurde, kann es zu Fehlfunktionen aller Funktionen kommen, die die Unterklasse betreffen.

Um ein Beispiel für das Vererbungsrisiko zu geben, müssen wir eine Funktion zum Subtrahieren zweier Zahlen vervollständigen, die von Klasse A verarbeitet wird.

class A{ 
 public int func1(int a, int b){ 
  return a-b; 
 } 
} 

public class Client{ 
 public static void main(String[] args){ 
  A a = new A(); 
  System.out.println("100-50="+a.func1(100, 50)); 
  System.out.println("100-80="+a.func1(100, 80)); 
 } 
}

Laufergebnisse:

100-50=50
100-80=20

Später müssen wir eine neue Funktion hinzufügen: Vervollständigen Sie die Addition zweier Zahlen und summieren Sie sie dann mit 100, was in der Verantwortung von Klasse B liegt. Das heißt, Klasse B muss zwei Funktionen ausführen:

Zwei Zahlen subtrahieren.
Addieren Sie die beiden Zahlen und addieren Sie dann 100.

Da Klasse A die erste Funktion bereits implementiert hat, muss Klasse B, nachdem sie Klasse A geerbt hat, nur noch die zweite Funktion abschließen. Der Code lautet wie folgt:

class B extends A{ 
 public int func1(int a, int b){ 

  return a+b; 
 } 
  
 public int func2(int a, int b){ 
  return func1(a,b)+100; 
 } 
} 
 
public class Client{ 
 public static void main(String[] args){ 
  B b = new B(); 
  System.out.println("100-50="+b.func1(100, 50)); 
  System.out.println("100-80="+b.func1(100, 80)); 
  System.out.println("100+20+100="+b.func2(100, 20)); 
 } 
}

Nach Abschluss der Klasse B lautet das Laufergebnis:

100-50=150
100 - 80=180
100+20+100=220

Wir haben festgestellt, dass die ursprünglich normal ausgeführte Subtraktionsfunktion einen Fehler aufwies. Der Grund dafür ist, dass Klasse B beim Benennen der Methode versehentlich die Methode der übergeordneten Klasse neu schreibt, was dazu führt, dass alle Codes, die die Subtraktionsfunktion ausführen, die neu geschriebene Methode von Klasse B aufrufen, was zu Fehlern in den Funktionen führt, die ursprünglich normal ausgeführt wurden. In diesem Beispiel trat eine Ausnahme auf, nachdem auf die von der Basisklasse A abgeschlossene Funktion verwiesen und diese durch die Unterklasse B ersetzt wurde. Bei der tatsächlichen Programmierung vervollständigen wir häufig neue Funktionen, indem wir die Methode der übergeordneten Klasse neu schreiben. Obwohl sie einfach zu schreiben ist, ist die Wiederverwendbarkeit des gesamten Vererbungssystems relativ gering, insbesondere wenn Polymorphismus häufig verwendet wird sehr hoch. Wenn Sie die Methode der übergeordneten Klasse neu schreiben müssen, ist ein häufigerer Ansatz: Die ursprüngliche übergeordnete Klasse und die Unterklasse erben beide eine beliebtere Basisklasse, entfernen die ursprüngliche Vererbungsbeziehung und verwenden stattdessen Abhängigkeiten, Aggregationen, Kombinationen und andere Beziehungen.

Laienhaft ausgedrückt lautet das Liskov-Substitutionsprinzip: Unterklassen können die Funktionen der übergeordneten Klasse erweitern, aber sie können die ursprünglichen Funktionen der übergeordneten Klasse nicht ändern. Es enthält die folgenden 4 Bedeutungsebenen:

• Eine Unterklasse kann die abstrakte Methode der übergeordneten Klasse implementieren, aber die nicht abstrakte Methode der übergeordneten Klasse nicht überschreiben Klasse.

• Unterklassen können ihre eigenen einzigartigen Methoden hinzufügen.

• Wenn eine Methode einer Unterklasse eine Methode einer übergeordneten Klasse überschreibt, sind die Vorbedingungen der Methode (d. h. die formalen Parameter der Methode) lockerer als die Eingabeparameter der Methode der übergeordneten Klasse.

• Wenn eine Methode einer Unterklasse eine abstrakte Methode einer übergeordneten Klasse implementiert, sind die Nachbedingungen der Methode (d. h. der Rückgabewert der Methode) strenger als die der übergeordneten Klasse .
  

Es scheint unglaublich, denn wir werden feststellen, dass wir in unserer eigenen Programmierung oft gegen das Liskov-Substitutionsprinzip verstoßen, das Programm aber trotzdem gut läuft. Jeder wird sich also fragen: Welche Konsequenzen hat es, wenn ich darauf bestehe, das Liskov-Substitutionsprinzip nicht zu befolgen?

Die Konsequenz ist: Die Wahrscheinlichkeit von Problemen mit dem von Ihnen geschriebenen Code wird erheblich erhöht.

Das obige ist der detaillierte Inhalt vonEinführung in das Richter-Substitutionsprinzip in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!