Liskov Substitution Principle (LSP) – Wissenshäppchen #5

This entry is Teil 5 von 8 in the series Wissenshäppchen

Im fünften Wissenshäppchen geht es um das Liskov Substitution Principle.

TL;DR

Am Liskov Substitution Principle (LSP) zeige ich dir, worauf du beim Austauschen von Klassen achten musst: Subklassen und Klassen, die ein Interface implementieren, müssen das erwartete Verhalten auch zur Laufzeit einhalten. Unerwartete Exceptions oder Seiteneffekte können bestehenden Code beschädigen, obwohl der Compiler alle geforderten Methoden akzeptiert. An Quadrat und Rechteck wird das greifbar; Unit-Tests helfen dir, solche Fehler zu entdecken. Kleine, passende Interfaces erleichtern es dir, den vereinbarten Vertrag vollständig zu erfüllen.

Kapitelmarken

  • [00:00:20] Das dritte SOLID-Prinzip und Barbara Liskov
  • [00:01:11] Austauschbare Klassen und Polymorphie
  • [00:02:01] Was der Compiler bei Methoden prüft
  • [00:03:38] Erwartetes Verhalten zur Laufzeit
  • [00:04:58] Definition des Liskov Substitution Principle
  • [00:06:51] LSP-Verletzung durch eine NotImplementedException
  • [00:09:09] Fehler mit Unit-Tests entdecken
  • [00:10:14] Quadrat und Rechteck als Vererbungsbeispiel
  • [00:14:18] Getrennte Klassen für Quadrat und Rechteck
  • [00:15:07] Ruby-Beispiel: Employee, Developer und Überstunden
  • [00:17:42] Prinzipien bewusst anwenden
  • [00:18:13] Verständlicher Code durch erwartbares Verhalten
  • [00:19:12] Prinzip der geringsten Überraschung
  • [00:20:12] Einschränkungen bei der Vererbung
  • [00:21:19] Unveränderbare Listen und passende Abstraktionen
  • [00:23:02] Zusammenhang mit dem Interface Segregation Principle
  • [00:24:14] Rückblick auf das LSP
  • [00:25:46] Shownotes, Code-Beispiele und Buchempfehlung

Probeabo bei Audible (Affiliate)

Inhalt

Das LSP ist das dritte der fünf SOLID-Prinzipien. Es wurde 1987 von Barbara Liskov definiert, die ihm auch seinen Namen gab:

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

Man könnte sagen, dass dies quasi die Grundanforderung ist, um Polymorphie zu ermöglichen. Denn überall dort, wo eine Basisklasse oder ein Interface erwartet wird, müssen auch alle abgeleiteten bzw. implementierenden Klassen erlaubt sein. Dies ist in den heutigen Programmiersprachen auch der Fall und der Compiler prüft dies (statisch). Aber das LSP geht noch einen Schritt weiter und fordert auch zur Laufzeit ein korrektes Verhalten.

Erklärung

  • Subklassen müssen sich so verhalten, wie es von ihren Basisklassen erwartet wird. Dies gilt auch für Interfaces und ihre Implementierungen.
  • Statisch ist das kein Problem: Der Compiler prüft, ob alle geforderten Methoden von den Subklassen bzw. implementierenden Klassen angeboten werden.
  • Die korrekte Verhaltensweise der Implementierung in den Subklassen bzw. implementierenden Klassen kann jedoch nicht statisch geprüft werden. Hierfür ist der Entwickler zuständig, um das LSP nicht zu verletzen.
  • Wenn beispielsweise eine Subklasse in einer überschriebenen Methode eine NotImplementedException wirft, anstatt sie zu implementieren, wird das LSP verletzt.
  • Aber auch unerwartete Nebeneffekte der Implementierungen in überschriebenen Methoden verletzten das LSP (Beispiel: Square erbt von Rectangle und setzt beim Aufruf von setA() auch die Seite b auf den gleichen Wert).

Beispiel

Die Basisklasse Employee gibt die Methode work_overtime() vor, die damit in allen Subklassen (Manager und Developer) zur Verfügung steht. Somit kann das Project gerade noch erfolgreich fertiggestellt werden.

class Employee
    def work_overtime
        puts "Working in the evening and on weekends..."
    end
end

class Manager < Employee
end

class Developer < Employee
end

class Project
    def finish(employees)
        employees.each { |e| e.work_overtime }
        "Project done"
    end
end

puts Project.new.finish([Manager.new, Developer.new])

# Working in the evening and on weekends...
# Working in the evening and on weekends...
# Project done

Aber was passiert, wenn sich der Developer zwar formell an den „Vertrag“ seiner Basisklasse hält, die Methode work_overtime() aber wie folgt überschreibt?

class Developer < Employee
    def work_overtime
        raise "Sorry, I use XP and adhere to the 40 hour workweek"
    end
end

puts Project.new.finish([Manager.new, Developer.new])

# Working in the evening and on weekends...                                                          
# Traceback (most recent call last):                                                                 
#         4: from ./LSP.rb:23:in `<main>'                                                            
#         3: from ./LSP.rb:18:in `finish'                                                            
#         2: from ./LSP.rb:18:in `each'                                                              
#         1: from ./LSP.rb:18:in `block in finish'                                                   
# ./LSP.rb:12:in `work_overtime': Sorry, I use XP and adhere to the 40 hour workweek (RuntimeError)  

Autsch! Das Project ist wohl zum Scheitern verurteilt! 😉 Es hatte ja keine Ahnung, dass man Developer nicht zu Überstunden verdonnern kann, denn das geht ja schließlich bei allen Employees…

Vorteile

  • Der Code wird deutlich besser nachvollziehbar, da keine unerwarteten Fehler zur Laufzeit auftreten, obwohl laut Compiler alles ok ist.
  • Klassen verhalten sich so, wie man es von ihnen erwarten würde („Principle of Least Astonishment“), und überraschen den Entwickler nicht.

Nachteile

  • Die Möglichkeiten der Vererbung werden ein wenig eingeschränkt.

Literaturempfehlungen

Auch beim dritten SOLID-Prinzip empfehle ich wieder Uncle Bobs Clean Code*.

Robert C. Martin - Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*

Links

Zusammenfassung

Was das Liskov Substitution Principle verlangt

Mit dem Liskov Substitution Principle (LSP) behandle ich das dritte SOLID-Prinzip. Es wurde 1987 von der Entwicklerin Barbara Liskov definiert und trägt ihren Namen. "Substitution" bedeutet "Ersatz".

Wo dein Code eine Basisklasse erwartet, muss er auch mit einem Objekt einer abgeleiteten Klasse korrekt arbeiten können. Dasselbe gilt für Interfaces und die Klassen, die sie implementieren. Der aufrufende Code soll dabei unabhängig davon bleiben, welche konkrete Klasse er erhält.

Für dich als IT-Azubi gehört dieser Zusammenhang zur Polymorphie, die auch in der Abschlussprüfung vorkommt. Das LSP verlangt, dass die austauschbaren Objekte das erwartete Verhalten zur Laufzeit einhalten.

Was der Compiler prüft

In den betrachteten Sprachen Java und C# prüft der Compiler, ob eine konkrete Klasse die geforderten abstrakten Methoden mit passenden Signaturen implementiert. Fehlen solche Methoden, muss die Klasse selbst abstrakt bleiben oder der Code lässt sich nicht kompilieren.

Ob eine Methode fachlich das Erwartete tut, liegt bei dir als Entwickler:in. Eine vorhandene Methode kann zur Laufzeit unerwartete Seiteneffekte auslösen oder eine Exception werfen, die der aufrufende Code gar nicht berücksichtigt.

Beispiel: Eine Methode wirft eine Exception

In meinem ersten Beispiel überschreibe ich eine abstrakte Methode und hinterlege darin lediglich eine NotImplementedException. Damit ist die Methode für den Compiler vorhanden.

Beim Aufrufen erwartet der bestehende Code, dass die vereinbarte Aufgabe ausgeführt wird. Durch die unerwartete Exception kann das Programm abbrechen, wenn eine passende Fehlerbehandlung fehlt. Die Subklasse verletzt damit das LSP.

Mit Unit-Tests kannst du solche Fehler entdecken. Ohne Tests zeigt sich das Problem möglicherweise erst beim Ausführen des Programms, wodurch es aufwendiger und teurer wird, den Fehler zu beheben. Michael Feathers bezeichnet Code ohne Unit-Tests als Legacy-Code.

Beispiel: Quadrat und Rechteck

Für das geometrische Beispiel lasse ich Square von Rectangle erben. Die Klasse Rectangle bietet mit SetA und SetB zwei Setter an, über die sich die beiden Seitenlängen unabhängig voneinander ändern lassen.

Ein Quadrat muss gleich lange Seiten behalten. Seine Setter ändern deshalb jeweils beide Werte. Wenn du SetA aufrufst, wird auch B angepasst.

Code, der mit Rectangle arbeitet, erwartet beim Setzen von A, dass B unverändert bleibt. Ein entsprechender Unit-Test schlägt mit einem Square fehl. Auch produktiver Code kann durch diesen Seiteneffekt falsche Ergebnisse liefern.

Für dieses Modell empfehle ich getrennte Klassen für Quadrat und Rechteck, gegebenenfalls mit einer gemeinsamen Basisklasse für geometrische Formen. Eine direkte Vererbungsbeziehung in umgekehrter Richtung passt ebenfalls nicht zu dem beschriebenen Verhalten.

Beispiel: Überstunden im Klassenmodell

Im Ruby-Beispiel aus meinen Shownotes erben Manager und Developer von Employee. Über WorkOvertime kann der aufrufende Code Überstunden für alle Mitarbeiter:innen anfordern.

Die Klasse Developer folgt im Beispiel der 40-Stunden-Woche aus Extreme Programming und verweigert die Methode mit einer Exception. Dadurch verletzt sie das Verhalten, das der Code von Employee erwartet.

Verständlicher Code und weniger Überraschungen

Wenn ich mich auf den Vertrag einer Basisklasse oder eines Interfaces verlassen kann, lässt sich mein Code leichter nachvollziehen. Besondere Regeln einzelner Subklassen muss ich dann beim Aufrufen nicht berücksichtigen.

Dazu passt das Principle of Least Astonishment, das Prinzip der geringsten Überraschung. Verständlicher Code und erwartbares Verhalten verringern die Wahrscheinlichkeit von Fehlern.

Das LSP begrenzt, welches Verhalten du in einer Subklasse verändern darfst. SOLID-Prinzipien verlangen grundsätzlich eine bewusste Entscheidung über ihren Einsatz und den damit verbundenen Aufwand. Beim LSP gewichte ich die Vorteile höher als diese Einschränkung.

Passende Interfaces wählen

An einer unveränderbaren Liste beschreibe ich ein weiteres Problem: Im Beispiel erwartet der aufrufende Code, über das gewählte Listen-Interface Elemente löschen zu können. Wenn die konkrete Liste beim Löschen eine Exception wirft, scheitert dieser Aufruf zur Laufzeit.

Für die gewünschte unveränderbare Liste brauche ich eine passende eigene Abstraktion, deren Vertrag das angebotene Verhalten beschreibt.

Hier entsteht der Zusammenhang zum Interface Segregation Principle: Kleine Interfaces erleichtern es dir, alle vereinbarten Methoden sinnvoll zu implementieren. Große Interfaces können dazu verleiten, einzelne Methoden mit Exceptions zu hinterlegen, weil sie zur konkreten Klasse nicht passen.

Code-Beispiele und weitere Quellen

Meine Ruby-Beispiele und weiterführende Artikel findest du unter anwendungsentwicklerpodcast.de/WH5. Dort verweise ich auch auf das Buch Clean Code von Uncle Bob.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:00] Herzlich Willkommen zu den Wissenshäppchen beim Anwendungsentwickler-Podcast. In dieser

[0:09] Episode geht es um das Liskov Substitution Principle. Viel Spaß!

[0:20] Hallo und herzlich Willkommen zum fünften Wissenshäppchen beim Anwendungsentwickler-Podcast.

[0:26] Mein Name ist Stefan Macke und heute geht es weiter mit dem dritten Solid-Prinzip, und zwar dem Liskov Substitution Principle, dem LSP oder L-S-P.

[0:37] Das Ding hört sich aber ganz sperrig an wegen diesem Liskov. So, was soll das sein? Was hat das mit Programmierung zu tun?

[0:44] Vorab schon mal, nein, das hat nichts mit Programmierung zu tun, das ist einfach ein Name. Barbara Liskov war eine Entwicklerin, die diesem Prinzip ihren Namen gegeben hat, deswegen heißt es Liskov Substitution Principle.

[0:56] Auf Deutsch übersetzen würde man das mit Liskovisches Substitutionsprinzip, also noch ein bisschen sperriger. Deswegen sage ich vielleicht einfach Liskov Substitution Principle. Das geht irgendwie leichter von der Zunge als dieses Substitutionsprinzip.

[1:11] Naja gut, okay, so ist die deutsche Sprache halt. Was hat es damit auf sich? Substitution, also Ersatz. Es geht hier darum, dass man irgendwas, ja, ersetzen soll. Aber was wird hier eigentlich durch was anderes ersetzt?

[1:22] Es geht darum, dass abgeleitete Klassen oder implementierende Klassen von Interfaces überall dort verwendet werden können, müssen, wo auch die Basisklasse bzw. das Interface verwendet wird.

[1:34] Das hört sich erstmal ganz logisch an, denn das ist ja die Standarddefinition der Polymorphie, die wir auch immer gerne in der Abschlussprüfung abfragen, bzw. ein Teil davon.

[1:43] Man kann überall dort, wo eine Basisklasse verwendet wird, auch ihre Subklasse benutzen, bzw. überall, wo ein Interface erwartet wird, auch jede implementierende Klasse dieses Interfaces. Das ist ja quasi per Definition die Polymorphie.

[1:55] Also warum brauchen wir da jetzt noch so ein komisches Prinzip dafür, dass uns das irgendwie nochmal verdeutlicht?

[2:01] Ja, das brauchen wir tatsächlich, denn man kann natürlich dem Compiler einen gewissen Check überlassen, ob zum Beispiel eine Klasse alle Methoden eines Interfaces implementiert, dass sie implementieren will.

[2:13] Das macht der Compiler auch. Ich bleibe jetzt hier mal wieder bei meinen Standardsprachen, C Sharp und Java zum Beispiel.

[2:19] Wenn ich dort sage, eine Klasse erbt von einer Basisklasse und diese Basisklasse hat eine abstrakte Methode, oder ich sage, eine Klasse implementiert ein Interface, Interfaces enthalten ja nur abstrakte Methoden,

[2:30] dann checkt der Compiler, ob ich auch alle Methoden, die ich implementieren muss, wirklich implementiert habe.

[2:36] Also alle abstrakten Methoden des Interfaces oder der Basisklasse muss eine Klasse implementieren, sonst geht das nicht.

[2:43] Sonst kompiliert er mir das einfach nicht, oder ich muss die Klasse selber wieder abstrakt machen.

[2:47] Ja, das geht auch, aber das sparen wir uns jetzt mal.

[2:49] Also, natürlich prüft der Compiler, ob alle Subklassen und implementierenden Klassen alle Methoden anbieten, also implementieren, die die Basisklasse oder das Interface vorgibt.

[3:00] Das ist ja auch richtig so. Das ist aber ein statischer Check, der guckt einfach nur, bietet die Klasse mir eine Methode mit dieser Signatur an, die ich erwarte, oder nicht.

[3:10] Und wenn sie das tut, und zwar für alle Methoden, die erwartet werden, ja, dann ist der Compiler erstmal glücklich und dann übersetzt er mir das auch.

[3:17] Das heißt, das ist wirklich nur ein ganz simpler Check, ob die Methoden da sind.

[3:22] Es wird nicht gecheckt, und das kann der Compiler auch gar nicht, ob die richtige Implementierung da ist.

[3:28] Denn was heißt denn hier richtige Implementierung? Wir wollen ja Polymorphie nutzen, das heißt, der Compiler darf gar nicht entscheiden können, was jetzt hier die richtige Implementierung ist.

[3:35] Das muss natürlich ich als Entwickler machen.

[3:38] Aber jetzt gucken wir uns mal dieses Prinzip an, das Listkopf-Substitutionsprinzip, obwohl ich es nicht sagen wollte, und stellen fest,

[3:46] wir können sehr wohl Klassen implementieren, die rein statisch korrekt ein Interface implementieren, oder von einer Basisklasse erben, die aber dann zur Laufzeit sich trotzdem falsch verhalten.

[3:57] Und darum geht's beim LSP. Es geht um das korrekte Verhalten dieser Klassen, nicht darum, dass zum Beispiel ein Interface verletzt wird,

[4:05] weil das kann in modernen Sprachen sowieso gar nicht passieren, weil der Compiler mir das halt eben abnimmt.

[4:10] Der prüft das ja, und der kompiliert das nicht, wenn halt eine Methode fehlt zum Beispiel.

[4:15] Also, haken wir das kurz ab. Der Compiler prüft, ob meine Klassen Interfaces korrekt implementieren, und Basisklassen, wenn sie abstrakte Methoden vorgeben, auch.

[4:25] Das kann der prüfen, aber was jetzt diese Methoden da machen, und ob die das Richtige machen, das kann der Compiler nicht prüfen, dafür müsste er das Programm ja ausführen.

[4:34] Und da gibt es jetzt aber Probleme, denn ich kann jetzt durchaus als Entwickler in so einer Subklasse, sag ich mal, oder einer implementierenden Klasse, eine Methode implementieren aus dem Interface oder der Basisklasse,

[4:45] aber ich kann das nicht so richtig machen, wie ich's erwarten würde. Und genau da setzt das LSP an.

[4:52] Ich muss meine Klassen so bauen, dass sie sich verhalten, wie erwartet.

[4:58] Schauen wir uns mal ganz kurz die Definition des LSPs an.

[5:01] Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

[5:12] Das wäre so ziemlich die Standarddefinition der Polymorphie.

[5:16] Überall, wo ich eine Basisklasse erwarte, und wir müssen hier heutzutage halt eben auch Interfaces erweitern,

[5:23] auch das LSP ist schon ein bisschen älter, 1987 schon definiert von Frau Liskov.

[5:29] Deswegen, damals gab es C++, Vererbung, alles toll, heutzutage gibt es auch Interfaces, die dürfen wir nicht vergessen.

[5:35] Das heißt, Basisklassen und Interfaces, dafür gilt das genauso.

[5:39] Also nochmal, überall, wo ich eine Basisklasse oder eben ein Interface erwarte,

[5:43] muss ich auch Objekte von abgeleiteten Klassen oder implementierenden Klassen benutzen können,

[5:49] ohne es zu merken, sag ich mal, ohne wissen zu müssen, dass das so ist.

[5:54] Das ist in der Polymorphie ja so.

[5:56] Und hier geht es jetzt aber eben nicht um das statische Verhalten, sondern um das dynamische Verhalten.

[6:02] Das heißt, zur Laufzeit muss sich meine Subklasse oder meine implementierende Klasse so verhalten,

[6:08] wie ich es erwarten würde.

[6:10] Denn wenn ich das nicht erwartete Verhalten irgendwie abprüfen müsste,

[6:14] dann, ja, hätte ich dieses ganze Konzept ja, wäre das ja hinfällig für mich.

[6:18] Das heißt, ich kriege irgendwie als Methode irgendein Objekt rein,

[6:22] und das entspricht natürlich dem, was ich da erwarte, also Basisklasse oder Interface.

[6:26] Und es muss mir jetzt wirklich völlig egal sein, ob ich eine Subklasse oder irgendeine andere implementierende Klasse reinbekomme.

[6:33] Mein Code muss trotzdem weiterhin korrekt funktionieren.

[6:37] Das heißt, die Subklassen oder die implementierenden Klassen, die müssen bitte ihr Verhalten so anpassen,

[6:43] dass alle, die dieses Verhalten schon kennen und erwarten, sich nicht auf einmal anders verhalten müssen,

[6:49] nur weil ich einen Bock gemacht habe.

[6:51] Ich gebe mal ein kurzes, einfaches Beispiel, dann kann man das vielleicht verstehen.

[6:55] Also angenommen, ich habe eine Subklasse, die von einer Basisklasse her, die Basisklasse hat eine abstrakte Methode,

[7:00] und ich implementiere diese abstrakte Methode auch, aber anstatt irgendwas zu machen, werfe ich eine Runtime Exception.

[7:05] Ich bin mal in Java, ja, eine Unchecked Runtime Exception, oder in C Sharp, ist ja sowieso egal,

[7:09] da schmeiße ich einfach irgendeine Exception.

[7:11] Das ist dann diese schöne Not Implemented Exception zum Beispiel.

[7:15] Also ich leite von einer Basisklasse ab, aber ich sage,

[7:17] Och Mensch, die eine Methode da, die ist so blöd, die will ich gar nicht implementieren.

[7:21] Throw new Not Implemented Exception und fertig bin ich.

[7:24] Dann habe ich zwar rein statisch die Basisklasse erfüllt, denn ich habe ja die abstrakte Methode überschrieben und implementiert,

[7:31] aber die Implementierung ist natürlich absolut nicht so, wie ich es erwarte,

[7:35] denn anstatt die vernünftig auszuimplementieren, schmeiße ich einfach eine Exception, weil ich sie nicht implementieren will.

[7:39] Und das ist damit gemeint.

[7:41] Das heißt, ich kann jetzt diese Subklasse nicht mehr einfach so benutzen,

[7:45] denn mein Code, der sich ja auf die Basisklasse verlässt und selbstverständlich alle Methoden dieser Basisklasse auch aufrufen darf

[7:51] und das im Zweifel auch tun wird, dafür habe ich es ja in die Basisklasse geschrieben,

[7:54] der fliegt auf die Nase, wenn er mit meiner Subklasse arbeitet,

[7:57] denn die schmeißt ihm eine Exception um die Ohren, die er natürlich nicht erwartet hat,

[8:01] denn er hat erwartet, dass sich die Subklasse vernünftig verhält.

[8:04] Die Subklasse sagt aber, hm, nö, kein Bock, ich schmeiße eine Exception.

[8:08] Und dadurch ist mein bestehender Code, ja, leider, ja, der hat jetzt ein Problem,

[8:12] denn da verhält sich jetzt irgendwie ein Objekt nicht so, wie er es erwartet

[8:15] und da wird im Zweifel also auch keine Fehlerbehandlung passieren,

[8:18] denn er erwartet ja nicht, dass da ein Fehler auftreten kann

[8:21] und deswegen, ja, fliegt uns das Ding um die Ohren und die Exception führt wahrscheinlich zu einem Programmabbruch.

[8:26] So, das ist ein sehr einfaches Beispiel.

[8:28] Rein statisch habe ich quasi den Vertrag der Klasse erfüllt.

[8:32] Ich habe die Methode angeboten.

[8:33] Aber, ja, die Methode wird halt nicht korrekt implementiert,

[8:36] sondern die sagt einfach, ja, ich muss die ja erfüllen, ne,

[8:39] wie so ein trotziges Kind so, nö, ja, muss ich ja, hm.

[8:42] Aber wenn ich sie dann wirklich aufrufe, ja, dann knallt's,

[8:44] dann schmeißt sie mir eine Exception um die Ohren

[8:46] und das ist natürlich zur Laufzeit gerade eben nicht das, was ich haben will

[8:49] und darauf bezieht sich das LSP.

[8:51] Also auch zur Laufzeit müssen sich die Objekte korrekt verhalten

[8:55] und korrekt heißt eben, wie ich es erwarte.

[8:58] Also wenn ich eine Implementierung erwarte, die keine Exception schmeißt

[9:01] und auf einmal fliegt eine, ja, dann habe nicht ich was falsch gemacht,

[9:04] sondern hat der andere was falsch gemacht,

[9:06] also in diesem Fall die Subklasse beziehungsweise implementierende Klasse.

[9:09] Und diese Art von Fehlern, die ist sehr schwer zu finden,

[9:13] denn der Compiler sagt ja, hey, ist ja alles gut.

[9:15] Die Subklasse, ja, bietet alle Methoden an, wunderbar, kompiliere ich die.

[9:19] Aber, dass zur Laufzeit so ein Fehler auftritt,

[9:21] das kann der Compiler nicht checken, denn der führt das Programm nicht aus.

[9:24] Das heißt, sowas kriege ich nur raus, wenn ich, hoffentlich habe ich das,

[9:27] viele Unit-Tests laufen lasse.

[9:29] Wenn ich die aber aus irgendeinem Grund noch nicht habe,

[9:31] vielleicht bin ich in Legacy-Software unterwegs,

[9:33] was ja per Definition von Michael Feathers Code ohne Unit-Test ist.

[9:36] Wenn ich in so einem Code unterwegs bin,

[9:38] dann fliegt mir das Ding einfach um die Ohren

[9:40] und ich finde das erst raus, wenn ich das Programm wirklich ausführe.

[9:42] Und das ist natürlich sehr, sehr, sehr spät,

[9:44] denn dann ist es sehr teuer und zeitintensiv, diesen Fehler zu beheben.

[9:48] Also muss ich von Anfang an darauf achten,

[9:50] dass ich sowas eben nicht mache.

[9:52] Dass ich nicht einfach nur, ich sag jetzt mal so ein bisschen bildlich,

[9:55] den Vertrag unterschreibe,

[9:57] sondern dass ich mich auch inhaltlich daran halte

[10:00] und dass ich meine Implementierung nicht nur irgendwie anbiete,

[10:03] sondern so, wie sie erwartet wird.

[10:06] Und dieses, hey, ich hab keinen Bock, das zu implementieren,

[10:08] ich schmeiß dir eine Exception um die Ohren,

[10:10] das ist halt eben genau nicht das Verhalten,

[10:12] was meine Aufrufe von mir erwarten.

[10:14] Ein weiteres schönes Beispiel aus der Praxis möchte ich hier aber noch bringen,

[10:17] weil das Ankel Bob auch immer gerne anführt in seinen Vorträgen

[10:20] und auch in seinen Büchern.

[10:22] Es geht nämlich nicht einfach nur um sowas Offensichtliches wie,

[10:25] hey, ich hab keinen Bock, die Methode zu implementieren,

[10:27] throw new irgendwas,

[10:29] sondern es geht auch um ein anderes Verhalten fachlich in dem Objekt.

[10:33] Und sein Standardbeispiel, wo man auch gut erklären kann,

[10:36] dass Vererbung nicht immer so gut geeignet ist,

[10:39] ist das Beispiel der geometrischen Formen Quadrat und Rechteck.

[10:43] Das kennst du bestimmt noch aus der Schule, Geometrieunterricht,

[10:46] da sagt der Lehrer immer, ein Quadrat ist ein Rechteck.

[10:51] Also jedes Quadrat ist ein Rechteck,

[10:53] aber nicht jedes Rechteck ist ein Quadrat.

[10:55] Das ist ja so der Zusammenhang.

[10:57] Das heißt, man könnte jetzt eine Vererbung sich ausdenken.

[11:00] Square, also Quadrat, erbt von Rectangle, Rechteck.

[11:06] Warum? Denn ein Quadrat ist ein Rechteck.

[11:10] Also könnte man sagen, Quadrat erbt von Rechteck.

[11:13] Angenommen, das tun wir,

[11:15] und wir haben jetzt in Rechteck ein paar Methoden definiert,

[11:18] zum Beispiel sowas wie Seitenlänge-Sets.

[11:21] Ein Rechteck hat zwei Seiten, A und B,

[11:23] das heißt, ich habe zwei Setter, Set A, Set B.

[11:25] Damit kann ich die Seitenlänge setzen.

[11:27] Jetzt habe ich mein Quadrat,

[11:29] und das Quadrat erbt ja vom Rechteck,

[11:31] hat also auch die beiden Setter, Set A und Set B.

[11:33] Jetzt weißt du aber selber aus der Geometrie noch,

[11:35] dass ein Quadrat keine zwei Seiten hat, A und B.

[11:38] Ein Quadrat kennt nur eine Seite, A.

[11:40] Denn die Definition eines Quadrats ist,

[11:42] dass jede Seite exakt gleich lang ist

[11:44] und alle noch einen rechten Winkel haben.

[11:46] Und das lassen wir mal außen vor.

[11:48] Das heißt, wenn ich auf einmal an einem Quadrat

[11:50] zwei Setter habe für A und B,

[11:52] die auch noch unterschiedlich heißen,

[11:54] dann deutet das ja darauf hin,

[11:56] dass ich irgendwie A und B unterscheiden können muss,

[11:59] denn sonst hätte ich ja nicht diese beiden Methoden.

[12:02] Das heißt, wenn jetzt zum Beispiel mein Code

[12:04] mit Rechtecken arbeitet

[12:06] und einfach mal A und B verändert

[12:08] und jetzt aber auf einmal ein Quadrat reinbekommt,

[12:11] dann müsste sich das Quadrat ja ähnlich verhalten.

[12:14] Wenn ich A oder B setze,

[12:16] dann sollten auch bitte nur A oder B gesetzt werden,

[12:18] denn sonst müsste ich es nicht aufteilen.

[12:20] Jetzt ist ein Quadrat aber so definiert,

[12:22] dass alle Seiten immer gleich lang sind.

[12:24] Wenn ich jetzt also A setze,

[12:26] muss ich automatisch auch B auf den gleichen Wert setzen,

[12:29] damit es noch ein Quadrat bleibt,

[12:31] sonst hätte ich ja wieder ein Rechteck.

[12:33] Das heißt, ein Quadrat in der Klasse Quadrat

[12:35] wird sichergestellt, wenn ich A setze,

[12:37] muss ich automatisch auch B auf den gleichen Wert setzen

[12:40] und umgekehrt auch, wenn ich B setze,

[12:42] muss ich auch sofort die Seite A auf den gleichen Wert setzen,

[12:45] sonst habe ich ja keinen Quadrat mehr.

[12:47] Das heißt, das Verhalten dieses Quadrats

[12:49] ist auf einmal anders als das eines Rechtecks,

[12:52] denn bei einem Rechteck, wenn ich da eine Seite ändere,

[12:55] hat das ja null Auswirkungen auf die andere Seite,

[12:57] die sind ja unabhängig voneinander.

[12:59] Bei einem Quadrat ist das auf einmal nicht mehr so.

[13:01] Wenn ich da A setze, hat sich automatisch im Hintergrund

[13:04] magisch, ohne dass ich das sehe, auch noch B verändert.

[13:07] Das heißt, wenn ich jetzt ganz blöd

[13:09] zum Beispiel einen Unit-Test habe,

[13:11] und der Unit-Test testet bei meinem Rechteck,

[13:13] wenn ich A setze, soll sich B bitte nicht verändert haben.

[13:16] Das wäre ja durchaus ein sinnvoller Unit-Test.

[13:18] Dann wird der fehlschlagen, wenn ich mein Quadrat reingebe,

[13:21] denn wenn ich A ändere, wird B automatisch im Hintergrund mitgeändert

[13:25] und auf einmal schlägt mein Test fehl.

[13:27] Das ist mit dem Test jetzt nur ein Beispiel.

[13:29] Stellen wir uns mal einen richtigen produktiven Code vor,

[13:31] der macht dann halt irgendwas anderes damit.

[13:33] Der rechnet auch nicht damit, wenn ich die eine Seite ändere,

[13:37] dass die andere mit angepasst wird.

[13:40] Das ist bei einem Rechteck nicht der Fall.

[13:42] Bei einem Quadrat, was von Rechteck erbt,

[13:44] müsste das aber jetzt der Fall sein,

[13:46] damit das Quadrat überhaupt ein Quadrat sein darf.

[13:49] Und das ist ein unerwartetes Verhalten.

[13:51] Alle Rechtecke verhalten sich anders als das eine Quadrat.

[13:55] Das Quadrat macht eine Sonderlocke,

[13:57] obwohl es den Vertrag des Rechtecks ja erfüllt.

[14:01] Set A, Set B wird alles angeboten.

[14:03] Der Compiler sagt, Mensch, supergut, ist ein Rechteck, alles wunderbar.

[14:06] Aber das Verhalten dieser beiden Setter unterscheidet sich,

[14:09] weil eben die beiden Seiten so miteinander in Beziehung stehen,

[14:13] dass es de facto nur noch eine Seite gibt.

[14:15] Und das erwarte ich ja nicht, wenn ich mit einem Rechteck arbeite.

[14:18] Das heißt, hier habe ich jetzt also das LSP verletzt

[14:21] und das ist auch ein gutes Beispiel dafür,

[14:23] warum man eben nicht eine Klasse Quadrat

[14:25] von einem Rechteck erben lassen sollte.

[14:28] Und übrigens auch nicht umgekehrt.

[14:30] Das ist auch Quatsch.

[14:31] Man könnte jetzt auf die Idee kommen,

[14:33] ein Rechteck hat zwei Seiten, ein Quadrat nur eine.

[14:35] Dann lasse ich doch das Rechteck von dem Quadrat erben.

[14:37] Auch das ist Murks.

[14:39] Das sind einfach zwei unterschiedliche Formen,

[14:41] die müssen in unterschiedlichen Klassen,

[14:42] die erstmal nichts miteinander zu tun haben,

[14:44] außer vielleicht eine Basisklasse,

[14:45] geometrische Formen oder sowas, umgesetzt werden.

[14:48] Aber es sollte keine Beziehung zwischen denen geben.

[14:50] Jedenfalls nicht so in dem Rahmen,

[14:52] wie wir es jetzt hier besprochen haben.

[14:54] Wenn du tatsächlich täglich irgendwelche Grafikanwendungen programmierst,

[14:57] mag das anders sein.

[14:59] Aber allein von der Idee her,

[15:01] haben Quadrat und Rechteck in der Objektorientierung

[15:04] keine Vererbungsbeziehung zueinander.

[15:07] In den Shownotes zu dieser Episode

[15:08] habe ich noch ein anderes Beispiel.

[15:10] Wieder mal in Ruby.

[15:11] Da habe ich in letzter Zeit ein bisschen mehr mit gemacht

[15:13] und habe mal meine Code-Beispiele darauf,

[15:15] ja, nicht umgestellt,

[15:16] aber jetzt überhaupt erstellt für diese Episode.

[15:19] Und da haben wir wieder mal so ein schönes Enterprise-Beispiel

[15:23] mit Klasse Manager und Employee und Developer und so.

[15:26] Und Manager und Developer, die erben beide von Employee,

[15:29] also vom Angestellten.

[15:30] Und jetzt stellen wir uns mal vor,

[15:32] wir arbeiten im Projekt

[15:33] und wir stehen kurz vor Ende des Projekts

[15:35] und stellen fest, wir sind noch nicht fertig,

[15:37] wir müssen ein bisschen Gas geben.

[15:38] Das heißt, wir müssen unsere Leute

[15:39] ein bisschen Überstunden machen lassen.

[15:41] Und wenn ich jetzt so eine Methode habe,

[15:43] wie zum Beispiel Work Overtime in der Klasse Employee

[15:46] und die Klassen Manager und Developer erben davon,

[15:49] ja, dann machen die halt beide Überstunden.

[15:51] Wunderbar, sage ich halt,

[15:52] hey, für alle Employees macht mal Überstunden.

[15:55] Und das ist ganz egal,

[15:56] ob Manager oder Entwickler,

[15:57] die erben ja alle von Employee,

[15:58] also machen die jetzt alle Überstunden

[16:00] und dann wird das Projekt auch fertig.

[16:02] Aber was ist denn jetzt,

[16:04] wenn wir einen besonders tollen Entwickler haben

[16:06] und der hält sich an das Extreme Programming

[16:08] und sagt,

[16:09] hmm, eine Praktik aus dem XP

[16:13] ist doch die 40-Stunden-Woche

[16:15] 40-Hour-Work-Week.

[16:16] Unsere Entwickler arbeiten nicht überstundenbasiert,

[16:20] denn wir wissen,

[16:21] nur wenn wir vernünftige Arbeitskonditionen haben,

[16:24] wird der Code auch vernünftig.

[16:25] Das heißt, unsere Klasse Developer,

[16:27] die sagt jetzt einfach,

[16:29] hmm, Moment mal,

[16:30] Work Overtime ist ja eine tolle Methode

[16:33] für alle anderen Employees,

[16:34] aber nicht für mich als Entwickler.

[16:35] Ich als Entwickler,

[16:36] ich arbeite nicht an Wochenenden und bis in die Nacht.

[16:39] Der Code leitet darunter,

[16:40] sorry, mache ich nicht.

[16:41] Das heißt,

[16:42] da könnte jetzt einfach mal der Developer

[16:44] auf die Idee kommen,

[16:45] zu sagen,

[16:46] hmm, nö, ich arbeite einfach nicht.

[16:48] Also was könnte er jetzt machen?

[16:49] Er könnte eine Exception werfen oder sowas.

[16:51] Keine Ahnung, wirf eine,

[16:53] ich arbeite nicht am Wochenende Exception oder sowas.

[16:55] Und schon haben wir das Problem,

[16:57] wenn unser Projekt sich dem Ende neigt

[16:59] und wir sehen,

[17:00] oh, das muss fertig werden

[17:01] und ich mache wieder meine,

[17:02] hey, lass mal alle Mitarbeiter Überstunden machen,

[17:05] Aktion,

[17:06] dann wird mir der Entwickler

[17:07] eine Exception um die Ohren hauen,

[17:08] denn er arbeitet ja nicht Überstunden.

[17:10] Also nicht gut.

[17:12] Mein Code, der sich darauf verlässt,

[17:13] dass alle Mitarbeiter Überstunden machen können,

[17:16] was per Definition, per Kontrakt,

[17:19] also laut Interface zum Beispiel auch der Fall ist,

[17:22] ruft das auf,

[17:23] weil das darf er ja,

[17:24] das steht ja im Vertrag,

[17:25] aber leider sagt der Entwickler,

[17:27] hmm, nö

[17:28] und schmeißt ihm eine Exception um die Ohren.

[17:30] Und da haben wir auch das LSP jetzt leider verletzt,

[17:33] denn der Developer verhält sich nicht so,

[17:36] wie der Code es von einem Employee,

[17:39] seiner Basisklasse, erwarten würde.

[17:42] Gut, dann schauen wir uns doch einfach mal

[17:43] die Vor- und Nachteile an von diesem Prinzip.

[17:45] Auch hier gilt wieder,

[17:46] alles immer mit Vorsicht genießen.

[17:48] Diese Prinzipien sind nicht in Stein gemeißelt,

[17:50] sondern man muss immer entscheiden als Entwickler,

[17:52] wende ich das jetzt an oder nicht.

[17:53] Grundsätzlich ist das LSP eine super Sache,

[17:56] so wie alle anderen Prinzipien,

[17:57] die ich vorstelle auch,

[17:58] aber es kann immer Gründe geben,

[18:00] um davon abzuweichen.

[18:01] Der Hauptgrund ist wohl,

[18:03] weil es den Aufwand nicht wert ist.

[18:04] Aber hier in diesem Fall wäre ich doch dafür zu sagen,

[18:07] es gibt sehr viele Vorteile und sehr wenig Nachteile

[18:09] und deswegen sollte man das LSP ja nicht immer einhalten,

[18:11] aber wir gucken erst mal.

[18:13] Vorteile.

[18:14] Der Code wird deutlich besser nachvollziehbar.

[18:17] Der Compiler prüft zwar schon einiges für mich,

[18:19] aber das Verhalten zur Laufzeit,

[18:21] das kann er nicht prüfen.

[18:23] Und da möchte ich mich doch bitte darauf verlassen können,

[18:25] wenn ich ein Interface definiere

[18:27] und ich kriege ein Objekt rein,

[18:28] was dieses Interface implementiert,

[18:29] dann muss ich auch alle Methoden aufrufen dürfen.

[18:32] Alles andere wäre Quatsch,

[18:33] dann hätte ich das Interface gar nicht definieren müssen.

[18:35] Und das soll sich auch so verhalten,

[18:37] wie ich es erwarte.

[18:38] Mir also nicht irgendwelche Exception um die Ohren schmeißen

[18:40] oder irgendwie nichts tun

[18:42] oder irgendwie was verändern,

[18:43] was gar nicht verändert werden soll.

[18:45] Solche Sachen, wie eben in den Beispielen gezeigt.

[18:47] Das ist nicht gut.

[18:49] Das macht den Code für mich auch schwer verständlich als Entwickler,

[18:51] weil sich irgendwie eine Klasse anders verhält,

[18:54] als alle anderen.

[18:55] Und das ist Mist.

[18:56] Das habe ich morgen vergessen,

[18:57] dass das so ist

[18:58] und dann benutze ich die Klasse,

[18:59] als wäre nichts gewesen,

[19:01] was ich ja auch machen kann,

[19:02] dafür habe ich ja das Interface,

[19:03] aber dann knallt es halt

[19:04] und es knallt vor allem zur Laufzeit

[19:06] und nicht zur Compile-Zeit

[19:07] und das ist doof.

[19:08] Da brauche ich wieder Unitests

[19:09] und nananana

[19:10] wollen wir alles verhindern, ja?

[19:12] Und es gibt noch ein weiteres Prinzip,

[19:14] was man hier gut mit verbinden kann

[19:15] und zwar das Principle of Least Astonishment.

[19:18] Das heißt das Prinzip der geringsten Überraschung.

[19:22] Ich möchte als Entwickler

[19:23] nicht durch Verhalten von meinen Objekten überrascht werden,

[19:26] sondern ich möchte am liebsten,

[19:27] dass sie sich einfach so verhalten,

[19:29] wie ich es erwarte,

[19:30] denn dann ist die Fehlerwahrscheinlichkeit am geringsten.

[19:33] Ich möchte nicht ständig in eine Methode reingucken

[19:36] und nachdenken,

[19:37] was sie denn wohl macht,

[19:38] sondern das gilt genauso beim Schreiben von Code.

[19:41] Der muss auch sprechend sein,

[19:42] der muss selbsterklärend sein.

[19:44] Wenn man es übertreibt,

[19:45] der muss langweilig sein, ne?

[19:47] Der soll nicht in Prosaform

[19:48] und überraschend mit irgendwelchen Unexpected irgendwas geschrieben sein,

[19:52] sondern der muss so einfach wie möglich sein,

[19:54] gut verständlich

[19:55] und so wenig Überraschung wie möglich

[19:56] und das gilt hier beim LSP auch.

[19:58] Wenn ich ein Objekt benutze,

[19:59] dann will ich das so benutzen,

[20:00] wie ich es erwarte

[20:02] und es soll sich halt eben nicht anders verhalten.

[20:04] Das macht mir das Leben schwer.

[20:06] Also Vorteile, Code ist besser nachvollziehbar, die Klassen verhalten sich so, wie man es

[20:11] erwartet.

[20:12] Kleiner Nachteil, da muss ich schon ein bisschen überlegen, überhaupt einen zu finden, aber

[20:16] ich schränke die Vererbung so ein bisschen ein.

[20:19] Wenn ich doch jetzt entscheide, dass meine Subklasse eine ganz besondere Subklasse ist

[20:24] und die soll halt in der einen Methode meine Exception werfen, ja, dann darf ich das nicht,

[20:28] weil das LSP das so nicht will.

[20:30] Okay, kann man jetzt, das ist schon wirklich konstruiert, das Beispiel, ich benutze Vererbung,

[20:35] weil ich was wiederverwenden will oder Interface ist halt eben, um Implementierung austauschen

[20:39] zu können.

[20:40] Und wenn ich eine Implementierung austausche, die dann kaputt ist und mir eine Exception

[20:43] um die Ohren fliegt, ja, was habe ich dann gewonnen?

[20:46] Also dann ist das ganze Prinzip der Polymorphie für mich irgendwie kaputt.

[20:50] Also ich finde das LSP äußerst wichtig, ich würde das immer einhalten und dieser

[20:54] konstruierte Grund mit, ja, ich darf dann nicht mehr alles machen, ja, darf ich auch

[20:58] nicht.

[20:59] Okay, das ist so.

[21:00] Dafür habe ich dieses Prinzip der Interfaces, ich übersetze das ja auch ganz gern immer

[21:02] mit Vertrag, den eine Klasse eingeht und dann hat sich die Klasse eben auch an diesen

[21:06] Vertrag zu halten, Punkt, ja, und da gibt es eben nicht eine Sonderlocke für eine von

[21:11] 27 Subklassen, die sich dann leicht anders verhält.

[21:14] So, das geht dann halt einfach nicht, ne, da muss ich ein anderes Prinzip wählen und

[21:17] sollte halt eben keine Interfaces nutzen.

[21:19] So ein Beispiel, was dann zum Beispiel kommt, wenn ich in Java eine eigene Liste implementieren

[21:24] will, ne, das Interface List, das hat, ich weiß es jetzt nicht genau, aber ich sage

[21:27] jetzt einfach mal 40 Methoden, ja, und ich möchte jetzt eine Liste implementieren, die

[21:31] halt zum Beispiel nicht, was auch immer, aus der ich nichts löschen kann, ja, also

[21:36] quasi eine Immutable List, dann müsste ich bei allen Methoden, die irgendwie die Liste

[21:41] verändern, also was löschen, zum Beispiel die Remove oder sowas Methode, müsste ich

[21:45] halt eine Exception schmeißen.

[21:46] Ja, dann habe ich ein tolles Objekt erzeugt, eine Liste gebaut, aus der ich nichts löschen

[21:51] kann.

[21:52] Das Problem ist, wenn jemand mit dieser Liste arbeitet und einfach erwartet, dass er was

[21:55] löschen kann, dann fliegt ihm leider zur Laufzeit diese Operation um die Ohren und

[22:00] das kann nicht sein, ja, und das überrascht ihn, da weiß er überhaupt gar nicht, was

[22:04] er damit anfangen soll.

[22:05] Ich habe hier doch eine Liste reinbekommen, wieso kann ich da nichts drin löschen?

[22:07] Kann ich doch mit jeder Liste, ja, nur weil ich als Entwickler keinen Bock hatte, die

[22:11] 40 Methoden zu implementieren oder eben entschieden habe, aus meiner Liste soll man aber nichts

[22:16] löschen können.

[22:17] Ja, das ist ja auch okay, dann darf ich mich aber bitte nicht am List-Interface bedienen.

[22:22] Wenn ich eine unveränderbare Liste erzeugen will, dann darf ich nicht das List-Interface

[22:27] implementieren, denn das List-Interface sieht vor, dass man wieder Sachen aus der Liste

[22:30] rausnehmen kann und das bedeutet, ich habe die falsche Abstraktion gewählt.

[22:34] Anstatt mich mit dem List-Interface oder an das List-Interface zu halten, muss ich

[22:40] halt was eigenes schaffen, eine eigene Abstraktion, meinetwegen eine Immutable-List, die mit der

[22:45] Original-List aus Java eben nichts zu tun hat.

[22:48] Das ist dann einfach so, das heißt, wenn ich zu viele Methoden in meinem Interface

[22:53] habe und einige davon einfach nicht implementieren kann oder will, dann habe ich leider Pech

[22:58] gehabt, dann muss ich einen anderen Weg wählen, dann darf ich dieses Interface halt eben nicht

[23:01] benutzen.

[23:02] Da werden wir auch bei einem späteren Wissensheppchen nochmal drauf eingehen, und zwar auf das

[23:07] Interface-Segregation-Prinzip, da beschreibt man auch einen zentralen Nachteil von riesengroßen

[23:13] Interfaces, ich sag mal das List-Interface mit 40 Methoden, ja, wenn ich jetzt eine Liste

[23:17] anbieten will, die aber nur 20 anbietet, dann kann ich dieses Interface nicht nutzen, weil

[23:22] dann das LSP eben verletzt wird, wenn ich da überall Exceptions werfe.

[23:25] Und das ist zum Beispiel ein Grund, warum ich meine Interfaces eben nicht riesengroß

[23:29] machen sollte, weil ich dann halt eben Teile davon gar nicht implementieren kann oder möchte,

[23:34] und das führt dann dazu, dass ich das LSP verletze.

[23:37] Das heißt, die beiden Prinzipien aus Solid hängen auch so ein bisschen miteinander zusammen,

[23:40] das List-Cross-Substitution und das Interface-Segregation.

[23:43] Interface-Segregation sagt, mach deine Interfaces so klein wie möglich, und das LSP sagt, ich

[23:48] muss die Interfaces alle komplett ausimplementieren, die beiden hängen also ganz gut zusammen.

[23:52] Habe ich ein zu großes Interface, bin ich vielleicht verleitet, als Entwickler das LSP

[23:56] zu verletzen, indem ich 5 von 20 Methoden einfach nicht anbiete, und, ja, wie gesagt,

[24:01] das verletzt das LSP.

[24:02] Also, da gibt es so ein bisschen einen Zusammenhang, ja?

[24:05] Gut, dazu aber später mehr in dem nächsten Wissenshäppchen, da gehen wir nämlich genau

[24:09] auf das I in Solid, das Interface-Segregation-Prinzip ein.

[24:14] Für heute noch mal kurz die Zusammenfassung.

[24:16] List-Cross-Substitution-Principle 1987 von Barbara Liskov definiert und sagt, dass überall,

[24:22] wo eine Basisklasse erwartet wird, auch eine Subklasse verwendet werden können muss, und

[24:28] wir übertragen das auf die Neuzeit, indem wir auch Interface und implementierende Klasse

[24:32] dazu nehmen.

[24:33] Subklassen oder implementierende Klassen müssen sich so verhalten, wie es von der Basisklasse

[24:37] erwartet wird, und zwar insbesondere auch zur Laufzeit, denn zur Compile-Zeit prüft

[24:42] der Compiler das ja eh, ob alle Methoden angeboten werden, aber es geht darum, dass das Verhalten

[24:48] auch gleich ist und nicht zum Beispiel Exceptions geworfen werden, weil ich eine Methode einfach

[24:52] nicht anbieten möchte, oder weil ich irgendwelche Nebeneffekte anbiete oder implementiere, wie

[24:58] zum Beispiel bei dem Quadrat, was auf einmal die Seite B mitändert, wenn ich Seite A anpacke,

[25:04] womit ich einfach nicht rechnen kann, wenn ich mit einem Rechteck arbeite.

[25:06] Vorteile?

[25:07] Wenn ich das einhalte, das LSP, der Code wird deutlich besser nachvollziehbar, ich

[25:12] muss mich nicht um irgendwelche Ausnahmen kümmern oder eine Subklasse, die es ein bisschen

[25:15] anders macht, immer im Kopf behalten oder so.

[25:17] Brauche ich alles nicht.

[25:18] Und die Klassen verhalten sich halt eben auch so, wie ich es von ihnen erwarten würde,

[25:23] also Prinzip der geringsten Überraschung, das darf man auch nicht vergessen.

[25:27] Nachteil ist, dass ich eventuell ein bisschen eingeschränkt werde bei der Vererbung, ich

[25:31] darf halt nicht mehr alles machen, ich muss alles immer ausimplementieren.

[25:34] Ja, ich persönlich kann damit gut leben, ich würde die Vorteile auf jeden Fall höher

[25:38] gewichten, als diesen einen winzigen Nachteil, der mir auch echt nur durch langes Nachdenken

[25:42] eingefallen ist.

[25:43] Vielleicht hast du ja noch mehr Nachteile, kann sein.

[25:45] Ich freue mich über deinen Kommentar.

[25:46] Das ganze Zeug, was ich heute erzählt habe, weiterführende Artikel, auch mein Code-Beispiel

[25:51] findest du in den Shownotes unter www.anwendungsentwicklerpodcast.de slash wh5 für das fünfte Wissenshäppchen.

[26:00] Wh bitte großschreiben, dann kommst du direkt auf die Shownotes, auch natürlich wieder

[26:04] zur Buchempfehlung, selbstverständlich Clean Code von Uncle Bob, was soll es auch sonst

[26:07] sein.

[26:08] Und ja, auch die Artikel und Code-Beispiele, also www.anwendungsentwicklerpodcast.de slash

[26:13] wh5 mit großem W und H.

[26:16] Ja, damit das Ganze auch noch ein Häppchen bleibt und nicht zu groß wird, mache ich

[26:20] jetzt auch mal Feierabend, ist ja schon wieder fast eine halbe Stunde rum.

[26:23] Ich hoffe, ich konnte ein bisschen was über das dritte Prinzip aus den Solid-Prinzipien,

[26:29] dem Listgolf Substitution Principle, vermitteln heute.

[26:32] Und ja, ich freue mich sonst über dein Feedback und sage für heute vielen Dank fürs Zuhören

[26:37] und bis zum nächsten Mal.

Polyglot Clean Code Developer
About the Author
Ausbildungsleiter für Fachinformatiker:innen Anwendungsentwicklung, IHK-Prüfer und ehemaliger Hochschuldozent für Programmierung und Software-Engineering.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert