So. Heute geht's um,
wir werden so ein bisschen zurückschauen auf SE1. Ich bin mir nie sicher,
ob ich Äußerungen wie die, die ich jetzt auf der Zunge habe,
ob ich die öffentlich machen soll.
Ich fragte Fred dann vorgestern, sag mal, schon wieder
statischer und dynamischer Typ. Wie lange ist das her,
dass du was erzählt hast, nach zwei Wochen.
Und dann sagt er, ach komm,
das haben die eh alles wieder vergessen.
Also erzähl's ruhig nochmal
Soviel zu unserem Bild von Ihnen. Wir werden aber dann
auf Basis dieser nochmal vorgetragenen Unterscheidung zwischen statischem und dynamischem Typ,
werden wir uns dieser beiden, diesen beiden begriffen,
da widmen Polymorphie und Vererbung, um ihren,
nicht nur um ihren Wortschatz zu vergrößern,
sondern um das als Konzepte der objektorientierten Programmierung hier nahezulegen,
die sie dann für den Rest ihres Lebens begleiten werden.
Jedenfalls so lange, wie sie objektorientiert programmiert.
Was steht da
Naja, man, so eine Spezifikation wie die,
wie das Interface lässt, kann implementiert werden durch unterschiedliche Klassen.
Hier sind es Linked List und Arealist und je nachdem,
welcher Natur diese Aufgabenstellung ist, die sie zu bearbeiten haben,
werden sie einmal als Implementationsvariante dann die Linked List auswählen,
ein anderes Mal die Arealist.
Das macht für die Spezifikation eigentlich gar nichts,
weil die Schnittstelle wird durch das Interface list,
wird die vorgegeben und das, was sich lediglich unterscheidet, sind die Implementationen.
Also wenn man so will, von außen ein nachrangiges Detail
in der Verwendung macht es dann schon einen Unterschied.
So, was durch diese Art,
also der Trennung von Spezifikation und Implementation, was dadurch vorbereitet wird,
ist das, was sie hier unter dem Begriff Polymorphie sehen.
Wer von ihnen hat denn Griechisch in der Schule gelernt
Was bedeutet Poly? Das ist die Strafe, wenn man
sich meldet. Entschuldigung, es war nicht so gemeint.
Poly, was heißt Vieh? Poly, was heißt viel
, ja. Also Poly heißt also wohl viel,
sagen sie mal so oder so. Ja, stimmt,
liege ich richtig. Und was ist das mit dem Morphie
? Weißt du, welcher Begriff liegt dem zugrunde?
Oder was ist das, was ist die deutsche Übersetzung von Morphie
Das ist... Ja, das ist also, glaube ich, die Gestalt.
Und so Anthropomorph ist dann also der menschlichen Gestalt nachempfunden.
Und Polymorph bedeutet, also so wie das da steht,
erstmal nichts anderes, kann vielgestaltig sein.
Und jetzt der Zusammenhang zu dem Konzepten der objektorientierten Programmierung,
die Sie kennen, ist,
also dass die Gestalt der Liste kann vielfältig implementiert werden.
Also durch die Arrealist oder durch die Linked List.
Und dieses Konzept, Der Polymorphie erzeugt interessante Effekte zur Laufzeit eines Programms.
Und das ist zur Übersetzungszeit des Programms sind diese Effekte noch nicht vollständig beherrschbar.
Wir können diese Effekte dazu einsetzen, um also wesentlich mehr
Flexibilität bei gleichzeitiger Typkorrektheit auszunutzen. Das ist etwas,
das macht also diese Fähigkeit, ausgezeichnet von objektorientierten Programmen,
trägt viel dazu bei, dass dieses Konzept sich so durchgesetzt hat,
weil das ist ein sehr mächtiges Konzept ist.
Wie das dann also so diese Form von Polymorphie,
wie die im Programm vielfältig eingesetzt werden kann.
Dazu dann im Laufe dieser und der nächsten Vorlesung mehr.
Deswegen steht da oben, das ist dir die erste Näherung, an den Polymorphie-Begriff.
In diesem Zusammenhang wird häufig auch der Begriff der Vererbung verwendet.
Und hier sehen Sie jetzt schon eine erste,
wiederum eine erste Näherung, eine begriffliche Definition von Vererbung.
Das ist zunächst mal ein Mechanismus, um Klassen in Programmen wiederverwenden zu können. Und das Wiederverwendung,
ich habe das am Anfang der letzten Vorlesung gesagt,
ist so eins der,
wenn nicht der heilige Gral der Softwaretechnik, also Dinge,
die man mal implementiert hat, in einem anderen Kontext wiederzuverwenden,
um das Rad nicht jedes Mal neu erfinden zu müssen.
Und Vererbung als ein Mechanismus zur Wiederverwendung von Spezifikationen und Code
ist ein Konzept, das sie noch nicht kennen.
Was sie bis jetzt kennen, ist, dass sie Klassen an
verschiedenen Stellen benutzen können. Wir werden jetzt im Laufe der nächsten,
dieser und der nächsten Vorlesung werden wir kennenlernen, wie man Code,
den man einmal geschrieben hat in Form von Klassen,
zur Definition von neuen Klassen wiederverwenden kann.
Zunächst, aber ich hatte ja gesagt, wir wollen nochmal
kurz jetzt zurückblicken in das, womit wir uns bis jetzt beschäftigt haben.
Und Sie sehen eigentlich hier so auf dieser Folie so in einer Grafik zusammengefasst,
Teile des Inhalts von SE1. Wir haben uns mit Klassen beschäftigt und Klassen implementieren Typen.
Typen sind dadurch definiert, also gerade in Form von abstrakten Datentypen,
dass sie eine öffentliche Schnittstelle haben und sie müssen implementiert werden,
damit Objekte zur Laufzeit von Programmen aus diesen Klassenbeschreibungen erzeugt werden können.
Wenn wir ausschließlich die Operationen betrachten, also die öffentliche,
das, was von einer Klasse öffentlich ist,
dann ist das das sogenannte Interface und das Interface wird durch
Methoden und Exemplar-Variablen und private Methoden einer Klasse implementiert.
Zur Laufzeit eines objektorientierten Programms entstehen dann, so wie das hier versucht ist,
so mit den Mitteln des Kartoffeldrucks, die uns mir zur Verfügung stehen.
Das ist ja so grafisch dargestellt werden sollen,
entstehen Geflechte, Abhängigkeitsgeflechte, die natürlich auf Basis,
also der statischen Beziehungen zwischen diesen Klassen und Interfaces gegeben sind.
Also so wie das hier Also hier stehen eigentlich sämtliche Elemente,
die wir bereits kennengelernt haben, ein Interface,
um bei dem anzufangen, womit ich gerade aufgehört habe,
habe, kann von verschiedenen Klassen implementiert werden.
Klassen benutzen, Interfaces, Klassen benutzen, andere Klassen.
Und das ist so die, das ist so die,
sind so die Arten von Beziehungen,
die wir statisch aus dem Programmtext erkennen können.
Und daraus ergeben sich dann zur Laufzeit die Begrenzungen,
welche Objekte
an Bezeichner gebunden werden können
Wir haben in dem Kontext auch über die sogenannten Referenzvariablen gesprochen, Referenzvariablen.
Das sind die Variablen, die in der Lage sind,
über eine Referenz auf ein Objekt zur Laufzeit eines Objektorientierten,
objektorientierten Programms zu verweisen. Der Zusammenhang zur Typisierung kommt dadurch zustande,
dass Variablen, Exemplarvariablen, aber auch Variablen,
also lokale Variablen in Methoden,
dass die deklariert werden müssen und jede dieser Variablen hat durch ihre Deklaration einen statischen Typ,
einen statisch deklarierten Typ und der heißt statisch Um es mal auf den Punkt zu bringen,
da können Sie drauf gucken.
Und er verändert sich auch nicht, dieser statische Typ.
Da können Sie ganz schön lange drauf gucken,
solange sie nicht mit der Hand am Arm in der Programmierumgebung ihrer Wahl,
den Typen verändern, bleibt dieser statisch deklarierte Typ für immer derselbe.
Das sieht man hier an dem Beispiel, der statische Typ von Liste 1,
das ist halt eine Liste, eine Liste von Strengs.
Und durch diesen statischen Typ ist auch festgelegt, ein für alle Mal,
welche Operationen an Variablen von diesem Typ aufgerufen werden dürfen.
Und das kann statisch überprüft werden, statisch überprüft werden,
bedeutet zur Compile-Zeit kann das überprüft werden.
Hier können sie, also sie können keine in dem Programmtext
einer Klasse, können sie an keiner Stelle...
Das ist nur die Auflösung, die mein Schreibtisch unaufgeräumt erscheinen lassen.
Das ist mit der richtigen Auflösung,
sieht das alles toll aus
Hier können sie niemals eine Operation hinschreiben. Hinschreiben können sie
es natürlich schon, aber übersetzt kriegen sie das nicht,
die nicht im Interface der Liste enthalten ist, also dieses Datentyps, List.
Das wird vom Compiler verhindert. So,
und jetzt kommen wir dann also zu den Effekten,
die sie zur Laufzeit erzielen können. Wir wissen ja bereits,
dass, wenn jetzt dieser Diese Variable von,
wenn diese Variable zur Laufzeit verwendet werden soll,
dann muss an diese Variable ein Objekt dieses Typs gebunden werden.
Und dass die Objekterzeugung passiert zur Laufzeit. Und was sie hier sehen,
ist, dass also an die variable Liste eins,
wird ein Objekt der Klasse Linkblist vom Typ String gebunden.
Der dynamische Typ von Liste 1 ist damit, Linkdlist von String.
Soweit so gut. Und dieser Typ ist dann in diesem Moment,
dynamische Typ von Winklist. Das hindert sie niemand daran,
gleich in der nächsten Anweisung, so sinnlos das jetzt auch erscheinen mag.
In der nächsten Anweisung ihres Programms diese Zuweisung vorzunehmen.
Und dann ist jetzt der dynamische Typ von Liste 1,
ist dann nicht mehr Linked List, sondern er ist Arraylist.
Das ist, weil der Compiler ja fest,
das Laufzeitsystem bzw. der Compiler vorher schon festgestellt hat,
aha, dieser Typ erfüllt also alles, was es braucht,
Listenoperationen aufrufen zu können.
Also kann ich diese Zuweisung, diese Zuweisung durchführen.
Der Mechanismus, also das ist jetzt nochmal zurück auf Polymorphie.
Man kann also die Gestalt von Liste 1,
die kann man nicht so vollständig zur Kompilezeit festhalten,
sondern man muss da bis zur Laufzeit warten.
Und das Konzept, das da dahinter liegt,
um das zu ermöglichen, ist das sogenannte dynamische Binden.
Jetzt kommt die nächste Definition
Was ist dynamisches Binden? Das dynamische Binden ist ein Prozess,
der im Hintergrund läuft,
also während ihrer Programmausführung und der jeweils überprüft,
welche Methode von welcher Klasse muss denn jetzt eigentlich bei einem Aufruf ausgeführt werden.
Das heißt also, das heißt deswegen dynamisch,
weil der Vorgang des Bindens eben erst zur Laufzeit stattfindet und
nicht schon zur Kompalzeit.
Das ist eine Eigenschaft,
objektorientierter Programmiersprachen
Die, oder sagen wir mal,
das ist eine notwendige dynamisches Binden, ist eine notwendige Voraussetzung,
um also diese Eigenschaft objektorientierter Programmiersprachen auch tatsächlich erfüllen zu können.
Und sie sehen auch auf der Folie, also welche Methoden,
für welche Methoden ausschließlich gilt, dass die schon statisch gebunden werden.
So, das ist eine Form von Indirektion,
die also in frühen Tagen von Java-Implementationen auch dazu geführt hat,
dass diese Programme zur Laufzeit etwas ineffizienter waren,
weil immer erst nochmal geschaut werden musste,
welche Methode wird denn jetzt eigentlich tatsächlich ausgeführt
Versus Programmiersprachen, die schon zur Kompilezeit diese Bindung stattfinden lassen.
Also die, wo ausschließlich statisch gebunden werden,
die haben dann zur Laufzeit halt einen kleineren Effizienzvorteil.
Das Thema ist aber mit Weiterentwicklung der Virtual Machines, hat sich erledigt.
Also da gibt es heutzutage keine Unterschiede mehr in der Ausführungsgeschwindigkeit.
Was wir jetzt also zusammen haben, sind, die sind zwei,
sich eigentlich widersprechenden Eigenschaften. Wir haben auf der einen Seite statische Typsicherheit,
die wird vom Compiler festgestellt und wir haben die Fähigkeit,
dynamisch zu binden. Das heißt,
wir haben eigentlich ein entschiedenes sowohl als auch in stark getypten,
statisch getypten Sprachen, wie das bei Java der Fall ist,
oder werden sie der einen oder anderen Veranstaltung in ihrem Studium vielleicht auch noch kennenlernen,
so eine Sprache wie Objective C oder C Sharp Diese Sprachen funktionieren eigentlich alle,
nachdem hier Beschriebenen immer demselben Muster.
Insofern, das, was Sie hier lernen, ist nicht Java-spezifisch,
sondern gilt für eine ganze Klasse von relevanten Programmiersprachen.
So, jetzt haben wir die Begriffe statischer Typ, dynamischer Typ und Polymarphie,
um jetzt schon mal so ein bisschen uns so genähert.
Jetzt wird es, ist es hier eigentlich nur nochmal mit
Blick auf das, was Sie bereits kennengelernt haben,
Zusammengefasst, weil das, worauf wir jetzt als nächstes hinauslaufen,
ist, dass wir nicht nur diese Beziehung zwischen Interfaces,
auf der einen Seite und Implementationen betrachten,
sondern dass wir betrachten werden,
also wie kann man die Typen selber auch verwenden,
um Typinformationen und später auch Implementationen, um die wiederzuverwenden.
Was dadurch entsteht, ist das,
was hier im letzten Begriff steht,
das ist die sogenannte Subtyp-Polymorphie
Ja. Wenn man mal genau hinschaut,
dann ist die Verbindung zwischen List und Linked lässt,
beziehungsweise die Verbindung zwischen List und Every List, ist auch schon eine Subtyp-Polymorphie,
weil Linked lässt implementiert ja oder ist abgeleitet von dem Typen List.
Und diese Beziehung, die wir jetzt ausschließlich zwischen zwei,
ich sag mal, Konzepten kennengelernt haben, die werden wir jetzt verallgemeinern,
sodass wir auch tiefere Ketten von Spezifikationen miteinander verbinden können und dadurch auch tiefere Subtyp Polymorphe-Beziehungen realisieren können.
Das machen wir jetzt nicht aus, wie Sie gleich sehen werden können,
also nicht ausschließlich aus Jux und Dollerei,
sondern wir wollen das verwenden, das Oberziel hatte ich schon genannt.
Wir wollen das verwenden, um möglichst viel von dem,
was wir bereits an anderen Stellen jeweils so erarbeitet haben oder sagen wir,
sage ich mal, erarbeitet haben oder das,
was andere uns zur Verfügung gestellt haben, um das Wiederverwenden zu können.
Das ist das Ziel oder der Grund, warum wir uns also
mit dieser Art von Beziehung setzen zwischen Konzepten, überhaupt beschäftigen.
Sie sehen hier schon so ein paar Eigenschaften von diesen,
durch die Anwendung dieses Konzepts entstehenden Typ Hierarchien. Wir sprechen hier einmal,
also wenn wir so eine Beziehung haben von Supertypen und Subtypen,
wobei also die Grundidee ist, dass wenn ein Subtyp,
so wie der hier steht, mag gleich noch ein paar Beispiele im bekannten Kontexten,
dass der Subtyp typischer Subtyp typisch möglicherweise mehr Operationen,
weitere Operationen anbietet, als der Supertyp.
Und das ist einer der wichtigsten Regeln dabei ist,
wir kommen gleich auch noch mit Blick auf das Vertragsmodell darauf zu sprechen,
an jeder Stelle, an der ein Exemplar eines Supertyps erwartet wird,
muss auch ein Exemplar eines Subtypen zur Laufzeit dynamisch gebunden werden können.
Und es darf für den Klienten keinen Unterschied machen.
Und dann hat man, wenn diese Voraussetzungen gegeben sind,
dann sind eigentlich der Weiterentwickelbarkeit der Wiederverwendbarkeit von Typen,
Schrägstrich Klassen, Objekten zur Laufzeit, sind alle Möglichkeiten eröffnet.
So, das sind jetzt eine Menge Begriffe gewesen und ein paar abstrakte Konzepte dazu.
Und jetzt schauen wir uns das mal an,
also wie diese Konzepte in,
also in zum Beispiel den Collection Classes, der in Java,
in den Bibliotheken, wie das realisiert worden ist.
So die Art, wie sich das liest,
ist so hoffentlich halbwegs intuitiv.
Was hier steht, ist, dass ein Sorted Z ist
ein Fett
Das lässt man mal so kurz auf sich wirken. Ja,
das hört sich doch nachvollziehbar an. Das ist eine spezielle,
also eine sortierte Menge, ist eine spezielle Menge.
Und genauso liest man die Beziehung, die dann da oben steht,
ein Set, ein Set ist eine Collections,
ist eine Collection, also ist eine Sammlung.
Und es gilt also, dass jetzt so das erste Beispiel,
wo sie so eine Mehrfachbeziehung sehen, dann muss also auch insbesondere gelten,
dass eine sortierte Menge eine Collection ist.
Man sieht aber, und das macht die Sache dann schon wieder einfacher,
jedes, jeder Subtyp sieht, in Anführungsstrichen, immer nur seinen direkten Supertyp.
Das heißt, wenn ich also mir überlege,
ich möchte jetzt sowas wie ein Sorted-Set als eine Spezialisierung eines Sets implementieren,
dann brauche ich mich nur um das Kümmern,
was also den Set bisher ausmacht und mir zu überlegen,
also ist es das, wovon ich mich jetzt spezialisieren möchte?
So, ein weiteres Beispiel für diese Art von Wiederverwendung von Typen,
ist das so, womit sie sich dann auch noch im weiteren wir uns auch noch im Weiteren beschäftigen werden.
Das ist die Jana Exceptions. Also es ist,
wenn irgendwas schief läuft, in Anführungsstrichen,
und es wird eine Exception ausgelöst, dann,
also ist es nicht so eine allgemeine Form von Exception,
die dort ausgelöst wird, sondern sie haben die Möglichkeit,
ganz unterschiedliche spezielle Arten von Exceptions mit speziellen Informationen auszulösen.
Und dass sie das können, basiert darauf,
dass die Exceptions selber in Form von abgeleiteten Typen zur Verfügung gestellt werden.
Also die Oberklasse aller Exceptions ist die Klasse Throwable.
Und von der abgeleitet sind die Klassen Error und Exceptions und von der abgeleitet,
von der Exception ist abgeleitet die Runtime Exception.
Ich sage Ihnen das jetzt lieber einmal zu deutlich als zu undeutlich,
was man hier sieht, sind schon so Konzepte,
die sie immer wieder entdecken werden
Von einem Konzept können beliebig viele andere abgeleitet werden.
Jedes einzelne Konzept hat aber genau einen Vorläufer.
Diese Strukturen sind immer baumartig, also jedenfalls solange wir von
der sogenannten Einfachvererbung sprechen. Wir kommen dann auch noch dazu,
was also diese Art von Vererbung unterscheidet, von mehrfach Vererbung.
Das ist nämlich dann der Fall, wenn ein Konzept auf mehrere
von mehreren anderen abgeleitet wird. Aber so als Daumenregel,
es hat sich so in der Entwicklung der objektorientierten Programmiersprachen,
wenn man mal in der Masse des Codes,
würde ich mal sagen, sind, die haben sich die Sprachen durchgesetzt,
die lediglich Einfachvererbung, also diese Art von Konzept implementieren.
Es hat also so, es gab dann so,
wann waren die denn? Irgendwann im letzten Jahrtausend,
die sogenannten Language Wars, Sprachen,
Programmiersprachen drücken ja immer
auch Konzepte aus
Und es hat dann also so in der Zeit, in der objektorientierte Programmiersprachen,
also sich so entwickelt haben auf Basis von Simular 67,
Smalltalk 80, so die Sprachen tragen dankenswerterweise ihre Entstehungsjahre,
also mit sich im Namen,
dass man die auch so im letzten Jahrhundert so ein bisschen einsortieren kann.
Es ist also sehr lange und intensive, teils emotional geführte,
deswegen Language Wars, Language Wars, Diskussionen darüber,
ob das Konzept der Einfachvererbung in einer Programmiersprache realisiert werden sollte oder das Konzept der Mehrfachvererbung.
Die Leute, ist so Holzschnittartig zusammenfassen darf. Die Leute,
die gesagt haben, einfach Vererbung reicht,
weil da draußen in der Welt der Anwendung,
wenn man drüber nachdenkt, dann lässt sich die Welt,
also vielfach durch so einfach Vererbung durch solche baumartigen Strukturen abbilden.
Will heißen, dass die den Leuten unterstellt haben,
die für Mehrfachvererbung argumentiert haben. Ihr habt nicht genügend nachgedacht,
wenn ihr mehrfach Vererbung als Konzept braucht.
Umgekehrt haben die Leute gesagt,
ich möchte mehrfach Vererbung als Konzept in meiner Programmiersprache haben,
weil jeder Programmierer soll
die Freiheit haben
Sich für das eine oder das andere Konzept zu entscheiden.
Wenn ich also mehrfach Vererbung anbiete, dann bedeutet das ja nicht,
dass jemand, der nach Selbsteinschätzung in der Lage ist,
nachzudenken, dieses Konzept auch verwenden muss,
sondern er kann ja dann auch,
er sie kann ja dann auch mit Einfachvererbung umgehen.
Jetzt könnte ich diesen Dialog noch ein bisschen fortsetzen.
In der Praxis haben sich die Programmiersprachen,
die lediglich Einfachvererbung zur Verfügung stellen, haben sich durchgesetzt.
Ich glaube, das ist eine
Vergleichsweise sichere Aussage
Das ist also die, wovon ich hier spreche,
ist diese, ist also die Vererbung von Klassen,
die Wiederverwendung von Klassen zur Definition eigener Klassen. Und das,
was sie sich da drunter,
so wie das da jetzt auch für diese Experimentalsprache Saturd steht,
was sie sich darunter vorstellen können, ist, wenn sie sagen,
ich möchte, ich habe jetzt hier also eine wunderbare Klasse,
sagen wir mal, Konto implementiert und sie überlegen sich jetzt,
sie möchten eine davon abgeleitete,
und sie möchten jetzt
eine Klasse Giro-Konto
Implementieren, dann sagen sie, oh, das ist ja toll.
Also 90 Prozent des Codes, den ich da brauche,
der existiert schon in einer Klasse. Und in einer Programmiersprache,
die jetzt Vererbung als Mittel nicht implementiert,
haben Sie die Möglichkeit,
Sie kopieren den Code und nennen den dann einfach Girokonto und ändern die zehn Prozent,
die Ihnen nicht passen.
Das ist so eine Vorgehensweise,
die ist relativ beliebt bei Programmieren
Weil das so einfach ist. Ich nehme den Code,
ich kopiere den und dann ändere ich so ein bisschen was und dann bin ich fertig.
Das ist für mich so vergleichbar, wie, sagen wir, Drogenkonsum. Das ist so,
für den Moment mag sich das gut anfühlen,
hat aber langfristig Folgen, die sie im Moment,
weil es sich ja so gut anfühlt,
ziemlich egal sind, aber ich sage es ihnen,
also ich sage ihnen das jetzt wirklich mit väterlicher Inbrunst,
tun sie es nicht.
Es tut ihnen nicht gut
So ist es auch mit dem Duplizieren von Code. Dann duplizieren sie das einmal,
sie duplizieren das zweimal und dreimal und dann wissen sie schon gar nicht mehr,
habe ich das dritte Duplikat vom zweiten Duplikat gemacht oder vom ersten oder vom Original, ist auch egal.
Also ich mache das jetzt nochmal und sie erzeugen dann Code,
wenn ich den dann mit einem dafür geeigneten Werkzeug analysiere,
dann sagt mir das über so ein paar Metriken, oh,
Duplicated Code und Duplicated Code oder Duplicated Code ist eine schwerwiegendes,
ist ein Qualitätsmerkmal für Software.
Weil wenn sie dann, dann kommt der Tag und der kommt immer,
wenn so ein Programm länger als sechs Wochen lebt,
wo jemand sagt, hm, an der Stelle,
also zeigt dieses Programm nicht das Verhalten, das es zeigen soll.
Wir müssen diesen Code jetzt mal ändern. Und dann kommen sie,
junge Drogensüchtige und sagen, wie viele Stellen,
also an wie vielen Stellen existiert dieser Code jetzt eigentlich,
existiert, der einmal, zweimal N, größer 2,
mal, sie wissen es nicht mehr.
Dann rinnt ihnen der Schweiß von der Stirn,
ich glaube, ich brauche das nicht weiter zu sagen,
weil sie müssen ja morgen früh wieder fertig sein.
Also lassen sie es gleich, benutzen sie als Konzept zur
Wiederverwendung von Code, gleich die Implementationsvererbung.
Fred wird ihnen heute im Laufe des Tages und nächste Woche auch noch zeigen,
wie man also mit dieser Idee, ich möchte Code wiederverwenden,
ohne die sogenannte Editor-Vererbung zu benutzen,
wie man damit systematisch in Java umgehen kann
So, die Arten der Wiederverwendung durch Code hatte ich eben schon kurz,
also mindestens mal genannt, einfach und mehrfach Vererbung,
einfach Vererbung sind dann immer solche Konzepte,
wie sie sie hier auf der linken Seite sehen,
eine unmittelbare Oberklasse und dann davon abgeleitet,
beliebig viele Unterklassen bei der Mehrfachvererbung, sieht man halt,
also man kann den Code von verschiedenen Oberklassen verwenden.
So, jetzt kommen wir mal zu ein paar Beispielen,
wo sich das überhaupt,
wie man überhaupt dazu kommt,
dass man sich über sowas Gedanken macht
Und jetzt komme ich mal wieder mit meinem 80, 90-Prozent-Beispiel.
Ich gebe Ihnen also die Aufgabe,
gehen Sie mal in die Bibliothek und gucken mal,
so wie die Leute dort arbeiten.
Und Sie gucken sich jetzt das nicht als solches an,
sondern wir überlegen gerade, ob wir nicht sowas wie ein Bibliotheksystem implementieren wollen.
Dieses Bibliotheksystem soll als Grundlage haben,
also dass die Büroarbeit innerhalb der Bibliothek,
dass die auch so elektrifiziert wird.
Und dann kommen Sie zurück
So einfach ist die Geschichte leider nicht,
aber nehmen wir das mal für den Moment ein und sagen,
ja, also was wir da entdeckt haben, ist,
die in der Bibliothek, die gehen,
also zum Beispiel mit Ordnern um.
Die benutzen Ordner in ihrer Arbeit. Völlig verrückt.
Die haben noch so richtige Ordner da stehen.
Und was machen die mit den Ordnern? Die Beschriften,
die mit Text, dann wissen die,
was da drin ist in dem Ordner, es gibt ein Inhaltsverzeichnis.
Und was die machen, ist, die fügen also Dokumente ein,
wählen sie aus, entnehmen sie.
Und so ein Ordner, der Umgang mit einem Ordner ist
unter anderem auch dadurch geprägt,
dass man so Zwischenblätter einlegen kann
Wow, tolle Sachen, die man so erfährt.
Wenn man also mit echten Anwendern spricht. Und dann haben
die auch Stapel. Wir nutzen sie in anderen Kontexten.
Und das ist das, was man mit einem Stapel machen kann.
Die benutzen Boxen und Ablagen. Und jetzt schauen wir da
drauf, denken, aha, das ist ja interessant.
Das ist jetzt schon so ein bisschen optisch nahegelegt,
so manche von diesen Umgangsformen, die sind gleich.
Was ich jetzt also nicht tun werde, ist,
ich sage ihr vier,
jeder nimmt sich ein Konzept und Der erste von Ihnen,
der implementiert jetzt mal die klasse Stapel,
und zwar mit genau dieser Schnittstelle.
Und der zweite implementiert die klasse Ordner, Schnittstelle steht hier.
Heute Abend kommen Sie zurück und haben das implementiert.
Und er dritte das und der vierte das.
Das mache ich nicht. Weil jetzt gucken wir,
jetzt gucken wir ein zweites Mal hin und sagen,
was wir da auch identifizieren können, ist so,
naja,
ich kann ja mal so
über die Welt nachdenken
Ein Stapel ist eine besondere Form von Ablage. Genauso kann ich darüber nachdenken,
eine Box ist eine spezielle Form einer Ablage und für den Ordner gilt es sowieso. Das,
was die alle gemeinsam haben, ist, dass man,
also bei einer Ablage,
kann man diese Umgangsform identifizieren und bei dem Stapel kann man
die Umgangsform der Ablage identifizieren und darüber hinaus auch noch diese Operation und das spricht sich jetzt genauso für die Box,
also ein Eine Box ist eine Ablage,
in die man auch mit Text beschriften kann.
Jetzt kommt jemand daher und sagt, also wenn das die generelle Leitlinie ist,
dann muss ich ja eigentlich auch noch folgendes so betrachten.
Mal hier. Da gibt es also mit Textbeschriften,
das kann ich sowohl bei der Box als auch bei dem Ordner machen.
Also machen wir doch folgendes. Mein Begriffsverständnis für die Bibliothekswelt
oder für überhaupt für so diese Bürowelt ist jetzt folgendermaßen,
ein Ordner ist Ordnung ist eine spezielle Box und eine Box ist eine Ablage.
Jetzt mal technisch gesprochen, so wie das hier steht,
ja, warum auch nicht? Also man hat jetzt so das,
was ich Ihnen ja gesagt habe, so einen maximalen Grad von Wiederverwendung.
Und jetzt müssen wir nur noch uns selbst und wahrscheinlich auch diejenigen,
für die wir diese Modellierung machen, davon überzeugen,
dass die ohne das, ohne dass so in Stirnhunfeln hervorruft,
dass die uns auch nachsprechen können,
ein Ordner ist eine Box
Es ist so, ich weiß nicht,
ich will mich da eigentlich auch gar nicht drauf einlassen,
jetzt auf diese Diskussion, weil diese Diskussion,
also so wenig, also so wenig sachlich begründet ist.
Das, weswegen ich Ihnen jetzt diese Geschichte erzähle, ist,
was wir, sie, was wir tagtäglich tun werden,
ist, solche Modelle herzustellen. Und dann sagen Sie,
und dann sagen Sie, irgendwann kommt es Ihnen auch,
also ganz natürlich vor, spezielle Arten von Boxen sind.
Das, was wir tun, das heißt, objektorientierte Modellierung.
Und es klingt so ein bisschen, als wäre das,
was wir tun, objektiv.
Ist es aber nicht. Das, was wir tun,
ist so hemmungslos, subjektiv von unserer Wahrnehmung geprägt.
Also ich kann mir gar nichts Subjektiveres vorstellen.
Das ist ja durch nichts begründet,
der sich also jetzt ausgerechnet diese Umgangsformen an den einzelnen Konzepten
Und das sind so die Quellen für ausufernde Diskussionen darüber,
also wie man etwas modellieren kann. Und ich verrate Ihnen nicht zu viel,
wenn ich sage, also wir werden uns also diejenigen von Ihnen,
die sich mit Softwaretechnik näher beschäftigen werden,
wir werden uns mindestens ein Semester lang mit so Methoden und Techniken auseinandersetzen,
wie wir unser Verständnis darüber, was eine gute,
was eine adäquate Modellierung ist,
wie wir das mit unseren jeweiligen Kommunikationspartnern austauschen können.
Da gibt es Methoden für es wird nur eine Freude sein,
ihnen das im Sommersemester 17 nahezulegen.
So für den Moment ist also, lösen wir den Konflikt,
den ich beschrieben habe, dadurch auf.
Und das ist auch etwas, was also ganz typisch ist in solchen Modellierungszusammenhängen.
Wir führen einen neuen Begriff ein. Ich nenne das jetzt mal Archiv.
Haben die in dieser Bürowelt wahrscheinlich noch nie was von gehört,
aber ich halte das, also jetzt für eine unfassbar clevere Idee,
also so ein Problem, Das ist jetzt ironisch gemeint.
Also dadurch zu lösen, dass ich sage, naja,
also meine Welt sieht jetzt so aus Boxen und Ordner,
sind so verschiedene Arten von Archiven.
Die Box ist ein Archiv, die keine weitere Operation hinzufügt.
Der Ordner tut das. Und das hier, naja,
Archive lassen sich halt auch mit Textbeschriften.
Und das sind wiederum spezielle Abbleiben. Das heißt,
was ich durch diese Begriffshierarchien jetzt versuche herzustellen, ist,
mir ein Verständnis davon zu erarbeiten, wie will ich die Welt im Weiteren modellieren?
Und das, was hier passiert ist, naja,
also mindestens können sie sich, glaube ich,
schon vorstellen,
wie sie die klasse Ablage implementieren
Und dann, das, was wir ihnen noch zeigen werden,
so in den nächsten anderthalb Vorlesungen, ist,
wie sie diese Konzepte dann auch verwenden können, um davon abgeleitete Klassen herzustellen.
Nur mal so einen Ausblick,
wenn sie so in so halbwegs praxisrelevante Kontexte kommen,
dann gibt es also so diese Ablagenhierarchien und das,
was sie hier sehen auf der rechten Seite,
so die Schriftguthierarchie.
Jetzt kann man sich ja fragen,
oi, wie kommen die denn da drauf
Lerne ich das noch, während meines Studiums oder ist
das Ingeniosität, die vorausgesetzt wird, nichts davon.
Also gut, sie lernen schon noch was in ihrem Studium.
Lust, was ich Ihnen jetzt so mit Blick auf Wiederverwendung
sagen will. Ich unterstelle Ihnen jetzt mal,
wenn ich Ihnen sage, entwickeln Sie doch mal eine Schriftguthierarchie.
Ich kann Ihnen das so gut unterstellen,
weil ich selber ja auch so drauf bin.
Ich fange mal an mit der allgemeinsten Art von Schriftgut,
nämlich dieser Oberklasse aller Schriftgüter und die
nenne ich Schriftgut
Und jetzt setze ich mich in meinem Büro und dann mal an meinen Computer
und implementiere diese klasse Schrift gut so, dass sie maximal wiederverwendbar ist.
Weil das ist der Stempel, den ich jetzt diesem Projekt aufdrücke.
Und dann sollen sich bitte alle, die also irgendwelche konkreten Vertragsformulare,
boah, was ist jetzt schon, Vertragsformulare, Antragsformulare,
dieses Zeug hier, die sowas zu implementieren haben,
die mögen bitte direkt oder indirekt meine Klasse,
die dort implementierten Konzepte zum Thema Schrift
gut wiederverwenden
Wiederverwendung, habe ich ja gesagt, ist das Ziel.
Das, was ich Ihnen auch versichern kann, das wird nicht klappen.
Es ist, also es ist in den letzten,
sagen wir mal, 50 Jahren nicht gelungen,
allgemeine Oberklassen so zu schreiben, dass die Welt denkt,
hui, darauf habe ich ja gewartet,
dass das mal implementiert wird.
Der Schritt hin zu solchen Hierarchien ist immer von der Verwendung
zur Wiederverwendung. Das finde ich auch im Deutschen ist es
ganz hübsch gesagt
Vor Wiederverwendung kommt Verwendung. Erst muss etwas verwendet werden und
dann kann man es wiederverwenden. Informatiker tendieren dazu,
ich schreibe jetzt mal etwas, das ist wiederverwendbar,
um es für andere verwendbar zu machen.
Das ist Hybris. Das ist eine Illusion. Tun,
ich komme hier langsam so ein bisschen altväterlich vor.
Lassen Sie auch das, was Sie tun sollten, wenn Sie
eine Schriftguthierarchie entwickeln wollen. Dann sagen sie, okay,
was sind denn so die Schriftgüter, die die Leute da alle verwenden?
Ich verwende jetzt zwar schon diesen Oberbegriff, aber er sagt,
oh guck mal, da gibt es eine Vollmacht.
Was machen sie denn mit einer Vollmacht? Ja, ausfüllen
, unterschreiben. Was machen sie denn mit einem Vertragsformular?
Oh, was gibt es denn noch, ein Antragsformular?
Und dann schreiben sie, fangen Sie mal an,
das zu modellieren mit Blick auf die Umgangsform.
Und dann hoffentlich kommt irgendwann jemand von Ihnen auf die Idee,
wisst ihr was, Leute?
Da muss überall eine Unterschrift gemacht werden. Dann lass uns
das doch mal zusammenfassen zu einem Unterschriftsformular.
Meanwhile on the Ranch hat jemand anders ein Modellrechenblatt,
was immer das ist
Also modelliert. Und dann treffen sie sich irgendwo und dann
sagt sie, ey, das ist ja wie bei uns.
Lass uns das doch mal zusammenfassen, so den Code,
den du da geschrieben hast und ich, das ist ja doppelt gemoppelt.
Das werden wir jetzt mal, lass es uns mal Erfassungsmedium nennen, zusammenfassen.
So, was die Nachricht, die ich Ihnen also gebe,
ist, erst verwenden, dann wiederverwenden. Dann wird,
ich will nicht sagen, dass dann alles gut wird,
aber das ist auf jeden Fall ein tragfähigerer Ansatz,
als sich da hinzusetzen, die Eimel hochzukrempeln und zu sagen,
wir bauen jetzt als erstes mal ein extrem abstraktes Konzept.
Wenn Ihnen das gelingt, dann kommen Sie bitte zu mir. Nein,
wenn Ihnen das gelingt, dann wird Ihr Pressesprecher,
weil Sie dann also unfassbar berühmt sind, wir denen mitteilen,
dass Sie, also alles, was ich gesagt habe,
hier ad absurdum geführt haben.
Aber das nehme ich dann auch gerne an. Okay, ganz kurz,
letzte Minute, wir haben letzte Woche über das Vertragsmodell gesprochen.
Und das Vertragsmodell war ja die Geschichte zwischen,
es gibt die Beziehung zwischen einem Anbieter und einem Klienten,
der Klient nutzt, das, was von einer Klasse als Vertrag gegeben wird,
nutzt er aus.
Dazu müssen bestimmte Vorbedingungen eingehalten werden und der Anbieter garantiert dafür nach Bedingungen.
Wir können das Vertragsmodell auch im Kontext von Subtyping-Vererbung interpretieren.
Also hier sehen Sie die allgemeine Form dieses,
wie das Vertragsmodell mit Blick auf Subtyping interpretiert werden soll.
Ich werde Ihnen das jetzt mal gleich an einem Beispiel
versuchen zu erläutern
Das fängt auch ganz harmlos an, oder?
Also es gibt sowas wie einen Anbieter.
Und dieser Anbieter sagt jetzt, also ich habe nur,
ich biete an meiner Schnittstelle eine Operation, die heißt liefere Bohrstück.
Und du als Klient, du musst mindestens 500 dafür bezahlen.
Dafür garantiere ich, dass die Toleranz kleiner als 20 ist,
was immer die Einheiten hier seien. Das heißt,
statisch im Programmtext ist erkennbar für mich als Kunden,
das ist der Anbieter, und die Operation liefere Bohrstück,
zu sagen, okay,
das hört sich gut genug an.
Jetzt passiert Folgendes
Der Anbieter, so, wird von einem Zulieferer beerbt.
Das muss der Anbieter noch nicht mals wissen,
dass er von diesem Zulieferer beerbt wird, der Zulieferer,
der sagt ja einfach,
ich nehme den Code der Klasse Anbieter und mache daraus einen Zulieferer.
Und was der tut, ist,
er macht eine neue Implementation der Operation, liefere Bohrstück.
Und was der jetzt sagt ist, ich verlange 6,
600, also mehr als der Anbieter, Dafür garantiere ich aber weniger Toleranz.
Das ist also ein echt schlechter Deal für den Kunden hier an der Stelle.
Und jetzt kommt es dazu, so das ist das,
was Sie so im Programmtext, also noch so gerade so entdecken können.
Jetzt kommt es zur Laufzeit dazu, dass der Kunde,
die Exemplarvariable Kunde, wird gebunden, sagen wir zunächst mal,
an eine Exemplarvariable vom dynamischen Typen Anbieter.
Durch Polymorph Verbindung kann es jetzt passieren,
dass also ein Zulieferer an den Kunden gebunden wird.
Und dann passiert Folgendes, dass also Der Zulieferer, dadurch,
dass der eine schwächere Vorbedingung, Entschuldigung, eine stärkere Vorbedingung macht,
als der ursprüngliche Anbieter und eine schwächere Nachbedingung garantiert,
dass dieses Programm mit einer Exception unterbrochen wird.
Und die Welt fragt sich, wie konnte das passieren?
Und das konnte passieren, weil der Zulieferer, das heißt,
derjenige, der also von dem Anbieter erbt,
sich gegen diese Regel hier verhalten hat.
Wenn wir das Vertragsmodell innerhalb der Vererbungsbeziehung interpretieren,
dann darf der Zulieferer nur schwächere Vorbedingungen machen und er muss stärkere Nachbedingungen garantieren.
Ansonsten kann es passieren, dass bei der Weiterentwicklung von Objektorientierten Programmen,
dass es dazu kommt, dass dieses Programm an Stellen abbricht,
also die man vom Programmtext her seit Jahren nicht mehr angefasst hat.
So, nur noch ein Satz so aus der richtigen Welt dazu.
Wenn ich mein Auto in eine Vertragswerkstatt gebe, sagt, also,
ich gebe euch x Euro und dafür kriege ich es repariert zurück,
dann ist das der für mich statisch sichtbare Vertrag.
Wenn die jetzt dieses Auto an irgendeine Hinterrufwerkstatt weitergeben,
dann möchte ich nicht also nachher mehr bezahlen und das Auto ungewaschen zurückbekommen.
Und das, was ich möchte, ist, schwächere Vorbedingungen,
die Werkstatt verlangt von der Hinterhofwerkstatt einen niedrigeren Preis einzuhalten und
sie müssen eine stärkere Nachbedingung einhalten.
Ansonsten kann diese Art von Vertragsweitergabe
nicht funktionieren
Und dieses Konzept, das können wir auch in der objektorientierten
Programmierung verwenden. Und das wird wie immer Freds Aufgabe sein
und meine Aufgabe ist es für heute nur noch,
Ihnen ein schönes Wochenende zu wünschen.
Guten Tag
Musik Musik Musik Musik Musik Musik Musik Musik Musik Musik Musik Musik Musik So,
ich hatte so ein paar Anfragen übers Wochenende bekommen,
hey Fred, wo bleiben eigentlich die Videos?
Und es tut mir immer so leid, wenn Leute darauf
angewiesen sind. Ah, ich muss irgendwie unbedingt Freitag,
ist meine Übung und ich weiß nicht, was ich machen soll.
Und ich wollte mal so als kleines Experiment,
das geht wahrscheinlich total in die Hose beim ersten Mal.
Vor allem auf diesem alten Laptop wollte ich sozusagen meine
eigene Performance hier, wo habe ich es denn,
einfach mal aus Spaß mitschneiden
Das ist, wahrscheinlich wird Eclipse dann noch langsamer.
Aber warum nicht? So, das ist alles richtig.
Und da muss ich mir noch beibringen,
dass er bitte das hier verwenden soll.
Und da muss ich das hier entsprechend auch bei der Aufnahme aktivieren.
Das wird bestimmt lustig. Und dann machen wir ruhig 100
Prozent. Und ihr seht schon, da wird was,
da kommt was an. Das ist schon mal gut.
Nicht, dass ich hier schweige auf der Aufnahme. Okay,
dann bevor ich das mache, starte ich mal Eclipse,
weil das wird sonst ewig dauern mit diesem Aufnahmeprozess
im Hintergrund
Wir haben ja leider Studenten, die nicht an der Vorlesung teilnehmen können.
Ich glaube, besonders die Mathematiker betrifft das immer.
Und die sind immer besonders, haha,
wann ist denn endlich das Video da?
Mal gucken, ob das als kleine Zwischenlösung vielleicht irgendwie hilft.
Meistens flutscht das ja nach ein paar Wochen immer sehr gut auf den offiziellen Wegen.
So, jetzt habe ich es gestartet. Was seht ihr
denn jetzt? Das ist so ähnlich wie letztes Mal.
Hier hört irgendwo der Bildschirm auf. Okay. So,
da muss ich mich jetzt hier noch einmal kurz durchklicken.
Das ist alles okay. Das ist alles okay.
Und dann sage ich einfach mal Steuerung IS.
Okay,
Steuern alt
Okay, jetzt läuft es hoffentlich. Gut, dann kommen wir
zum eigentlichen Thema. Es soll ja um Subtypen gehen. Code,
Wiederverwendung, was ja schon so ein bisschen angesprochen wurde,
wird Guido dann mit euch nächste Woche machen und ich natürlich auch.
Und ich dachte, wir fangen einfach mit so ein paar
Diagrammen an. Wenn wir das, ach Gott,
jetzt ist das hier natürlich so ein kleiner Monitor.
Jetzt muss ich das hier auch extrem beschneiden, dass überhaupt irgendwas seht.
Wo ist denn bei euch die linke obere Ecke?
Die ist irgendwo. Warum will er denn, okay,
was haben wir hier für eine Ecke
Ah, hier ist sie. So ungefähr, ja. Ohne,
dass mal Pixel genau dahin zu biegen. Okay. Jetzt hatte ich,
manche Leute gucken sich ja auch die Vorlesungsvideos aus vergangenen Jahren an und ich hatte letztes Jahr,
als so ein durchgehendes Beispiel für die ersten fünf Vorlesungen,
das hatte ich immer in Stack genommen.
Das ist immer so, wenn ich abends einschlafe,
das letzte Woche und ich denke,
das ist der Stack und das erste, woran ich denke,
wenn ich morgens aufwache, ist auch der Stack und dann,
ja,
hatte ich ein kleines Gespräch mit Guido und dann meinte er,
gibt es nicht auch
irgendwie so anwendungsnähere Beispiele
Was für das Themengebiet abstrakte Datentypen der Stack ist.
Das ist doch für den Objekt orientierten Modellierer das Konto.
Also wir werden uns heute mit einem sehr anwendungsnahen Beispiel beschäftigen,
wo man nicht noch so eine zusätzliche mentale Hürde hat,
zu verstehen, wie Stacks funktionieren.
Okay. Ja, wir machen jetzt eigentlich das,
was wir ja nicht machen sollten, oben anzufangen,
oben anzufangen in der Hierarchie,
weil ich mache das jetzt einfach trotzdem mal.
Also ich habe hier ein Interface-Konto, ich kann ja die
Operation danach hinzufügen und dann will ich vielleicht zwei Klassen haben,
die das implementieren, das ist ja nichts Neues für euch.
Machen wir doch mal ein Girokonto,
das hat ja wahrscheinlich jeder von euch,
wo man
das Gehalt draufkommt
Und dann machen wir nochmal einen Sparuch. Und jetzt kann
man sich überlegen, was haben die denn gemeinsam?
Was kann ich sowohl mit einem Girokonto machen, als auch mit einem Sparbuch?
Und was einem da immer so als erstes in den Sinn kommt,
ist zum Beispiel Joe Zahler ein. Da tue ich mal
irgendwie vielleicht, ja, was nehmen wir denn mal?
Wir haben ja gelernt, Double ist nicht so gut.
Float erst recht nicht. Wollen wir zur Abwechslung vielleicht einen Long nehmen?
Einfach, dass es nicht so langweilig ist und wir
immer dasselbe machen, statt innen nehmen wir jetzt Long.
Ja, dann hört es nicht irgendwo bei zwei Milliarden auf,
sondern ein bisschen größer.
Okay, und ach so,
der Rückgabetyp ist dann
irgendwie Void
Das war so ein bisschen anders als Schaber.
Wisst ihr was? Ich mache jetzt mal Java statt OML,
dass ihr hier nicht nur so eine zusätzliche OML-Hürde habt.
Okay? Oh, dann ist das hier natürlich auch kein Java,
Entschuldigung. So, das versteht auch Erzähler, oder?
Gut. Dann kann man nicht nur einzeln, sondern auch abheben.
Nee, hebe ab. Wie viel soll abgehoben werden?
So. Ja, das sollte man ja sicherlich mit jedem Konto
machen kommen. Und jetzt würde ich vielleicht mal andeuten,
dass es hier irgendwie diese Beziehung gibt,
was nehmen denn da mal Implements Interface?
Das sieht doch gut aus.
Also das Girokonto implementiert dieses Interface
Unser Sparbuch implementiert auch dieses Interface. Gut,
jetzt kann man sich mal kloppen, soll ich jetzt diese Operation
hier unten auch reinschreiben oder ist uns das irgendwie klar?
Ups, nee, ich wollte, kannst du,
nee, es implementiert sich nicht selbst.
So. So. Wo war ich stehen geblieben? Genau, wir
können ja mal eine Abstimmung machen. Wer ist denn dafür,
dass sich diese beiden Operationen auch in die Klassen reinschreiben?
Einfach weil es irgendwie klarer ist. Oh, gar keiner
, okay. Und wer ist dagegen? So ein paar
Hände sind dagegen, dann lassen wir es halt sein.
Gut. Okay, und was man jetzt eben noch machen kann,
ist, man kann hier noch weitere Operationen reinschreiben.
Ich könnte zum Beispiel sagen, bei so einem Girokonto Ja
, was kann man denn machen?
Vielleicht kann man irgendwie sagen, Gebühren berechnen oder so.
Methode, rechnen oder ziehe Gebühren ab. Das macht zwar
ein bisschen ein klares Ziel, Gebühren ab.
Da übergibt man nichts und es ändert sich der Internetzustand.
Und beim Sparbuch kann man vielleicht sagen, schreibe Zinsen gut oder so, ja.
So. Tja, wie soll man denn jetzt Zinsen gut schreiben,
wenn man gar nicht weiß, wie viele Zinsen macht?
Das sollte man wahrscheinlich irgendwie hier festhalten, oder?
Wie wollen wir denn den Zinssatz modellieren?
Was für ein Datentyp nehmen wir denn dafür
Was hatten wir normalerweise so für Zinsen? Also wenn ich
jetzt sage, ich kann ja einfach die Prozent nehmen,
ein Prozent kriegt man heutzutage gar nicht mehr auf Sparbücher.
Auf der Promille nehmen. Sagen wir mal, in Promille oder so.
Gott. Und das mit den Gebühren wäre vielleicht auch sinnvoll,
dass wir hier die Gebühr irgendwie dran ablegen,
weil das kann ja möglicherweise flapper jedem Konto so ein bisschen anders sein.
Ja, sagen wir vielleicht mal Centgebühr oder so.
Also ich glaube, genauer als Cent muss es dann
nicht sein
Genau. Was ich jetzt noch nicht so dokumentiert habe,
ist, auf welche Zeiträume sich das bezieht.
Wir können ja vielleicht mal der Einfachkeit halber sagen,
dass das immer nach einem Jahr gemacht wird.
Ich glaube, realistische Kontonkonten geben euch einmal im Jahr Zinsen,
aber ziehen viermal im Jahr die Gebühren ab.
Das machen wir jetzt mal ein bisschen einfacher. Die Bank,
für die wir jetzt hier den Auftrag haben,
da wird alles nur einmal im Jahr gemacht.
Okay. Gut, jetzt haben wir schon so einen kleinen Eindruck.
Jetzt könnte man bei fortgeschrittenen Tools sagen, bitte generiere mir
den Java-Quote aus. Das kann dieses Tool leider nicht.
Dann bauen wir das doch einfach mal.
Das sollte eigentlich keine große Herausforderung für uns sein.
Fangen wir an. Fangen wir an mit dem Interface,
würde ich sagen
Was sieht man jetzt? Das sieht man.
Also ich mache mal jetzt mal ein neues Projekt.
Also bis jetzt fühlte Clips sich gar nicht so viel langsamer
um durch die Aufnahme, mal gucken.
Ein Java-Projekt hätte ich wahrscheinlich auch direkt anwählen können.
Okay, ja, wie wollen wir es nennen?
Geld. Geld regiert die Welt, alles andere ist okay,
jetzt seht ihr das wieder nicht, ist aber nicht schlimm.
Könnt ihr mir einfach glauben, dass ich da auf Finnisch geklickt habe.
Okay, und dann gehen wir mal hier in unseren
wunderbaren Source-Ordner rein, den kennt ihr ja mittlerweile auch.
Und dann sagen wir doch mal, wo ist Neo hier?
Ich möchte ein neues Interface haben,
da haben wir es
Gut, dann nennen wir das mal Konto. Ja,
wir erben sonst von nichts und so, der Rest ist alles okay,
so wie man ein normales Interface halt anlegt.
Ja, jetzt, ah, Kommander sind wir schon,
gar nicht so langsam. Gut, was hatten wir jetzt gesagt?
Ich will was einzahlen können. Zahle ein, Long-Tag.
Und ich will was abheben können, Heber A, Long-Betrag.
Gut. Man muss hier übrigens nicht unbedingt Public dahin schreiben,
da kloppen sich die Leute auch regelmäßig die Birne ein.
Ist das jetzt schlimm, wenn man das Public da
weglässt unter Listen oder nicht, bei Interfaces?
Ist das egal
Gut, dann geht's weiter im Text.
Ich werde eine neue Klasse haben. Und jetzt kann man
es vielleicht schon so ein bisschen Eclipse-Magie mal verwenden.
Also ich will ein Giro-Konto anlegen. Und jetzt kann ich,
glaube ich, irgendwo sagen, dass ich bestimmte Interfaces implementieren will.
Hier. Also über diesen Punkt reden wir nächste Woche.
Superklassen. Codeerben. Und über Interfaces, da erzähle ich euch ja
nichts Neues. Ich will also ein weiteres Interface hinzufügen.
So kann ich jetzt hier einfach sagen, Konto.
Am Grunde ist es. Das will ich haben. Seht
ihr das? Ja. Dann sage ich, okay,
so jetzt steht's hier und dann sage ich mal Finish.
So, mal sehen,
was jetzt passiert
So. Guck mal, das ist jetzt alles hier automatisch für euch geschrieben worden.
Das ist jetzt ja nicht schlimm, ihr habt ja das Programmiertektat hinter euch,
jetzt müsst ihr das nicht mehr von der Hand schreiben, okay?
Also Klaas Girokonto-Implements-Konto, das hätte man ja sonst von Hand geschrieben und automatisch kommen wir auch schon,
ja nicht besonders sinnvoll implementierte Methoden, aber immerhin,
die Methode ist schon mal da, ja,
hier eine Methodenkopf, hier eine Methodenrumpf.
Sehr schön. Mir fällt gerade so zwischendurch ein,
das ist eigentlich recht realistisch, ich glaube,
das Modell könnte noch einen ganz kleinen Tick überarbeitet werden,
Einzahlen und Auszahlen ist ganz nett,
aber dann ist das ja wie so ein schwarzes Loch,
so ein Konto, ja, ich tue was Radio,
manchmal kommt auch was raus, Evanschwarzenloch kommt,
glaube ich, gar nichts raus.
Das ist ein graues Loch. Ab und zu kommt was
raus. Aber ich will vielleicht auch mal wissen,
wie viel den gerade drauf ist
Ja, also vielleicht noch eine weitere Operation.
Deep-Betrag oder so. Da gibt es Aldogy-Betrag. Der Trage
ist irgendwie blöd, weil die Parameter so heißt.
Nehmen wir es mal lieber, gib Isaldo.
Okay. Jetzt muss ich sie zum Glück nicht unten reinschreiben.
Dafür hattet ihr euch ja entschieden. Und was passiert denn jetzt,
wenn ich das jetzt in das Interface mit dazu packe?
Ich sage also, hatte ich überhaupt einen vernünftigen Rückgabetyp dafür?
Hatte ich nicht. Voyed ist ja nicht so sinnvoll für
ein Ghetto. Warum habt ihr euch nicht beschwert bei mir
? Traut ihr euch nicht? So, dürft ihr euch
gerne beschweren. Gib Saldo. Okay, jetzt wird hier
schon gleich so ein rotes X angezeigt.
Da gehe ich mal direkt hin
Jetzt beschwert sich der Compiler. Warum? Wiederholungsfrage? Ich
habe doch gar nichts gemacht an dieser Klasse, ja.
Genau, es fehlt einfach eine Methode.
Es würde mir jetzt hoffentlich halbwegs vernünftig hier sagen,
Must-Implement in Herited, Abstract Method, Konto Gibsaldo,
okay, jetzt könnte man das da unten hinschreiben,
aber man könnte auch einfach klicken auf Ad Un-Implemented Methods.
Ich klicke da einfach mal auf, da unten ist sie.
Seht ihr sie? Ja. Wahnsinn, oder?
Gut. Dann können wir ja vielleicht mal eine Exemplarweierplan legen
für den Saldo
So. Und dann können wir den Saalo unten einfach zurückgeben.
Zack. Dann habe ich es implementiert, da kann ich
die Zeile löschen und die brauche ich eigentlich auch nicht.
Wollen wir mal was ausprobieren? Was passiert eigentlich,
wenn ich diese Zeile gar nicht habe? Ja,
ich gebe hier also etwas zurück, was es gar nicht gibt,
kriege ich dann vielleicht auch einen sinnvollen Vorschlag.
Manchmal ist die Clips ja so unglaublich schlau.
Hier haben wir es Createfield-Salo, das will ich haben.
Ja, da ist es. Also ja, das ist
ganz witzig. Also oft kann man Dinge benutzen,
die gar nicht da sind, dann beschwert sich Eclipse,
dass es das nicht gibt und sagt, soll ich es für dich herstellen?
Ja, bitte.
Vielen Dank
Und auch anhand der Typen erkennt es dann recht schnell,
das ist wahrscheinlich sinnvoll, wenn das ein Long ist.
Gut. Joa, wie zahlt man was ein?
Ich glaube, ich frage euch das nicht, oder?
Das ist zu trivial, auf den Seilung wird es was raufgetan.
Ups, Saaldo Plus, Gleichbetrag. Und wenn ich was abhebe,
tja, dann wird es eben abgehoben, Minusstadt Plus.
Ja, jetzt würde man natürlich,
wenn das jetzt die Vorlesung von letzter Woche wäre,
würde man jetzt hier Vorbedingungen formulieren,
sowas wie der Betrag muss größer als Null sein.
Und hier würde man dann sagen, hey,
du darfst irgendwie nicht mehr abheben,
als es drauf ist und so.
Wir können das ja vielleicht
einfach mal machen
Um das noch mal so ein bisschen zu wiederholen.
Also hier würde ich jetzt sagen, pass auf,
ich erwarte von dir, dass der Betrag größer ist als null.
Zack. Und dasselbe erwarten wir auch hier.
Und ich hatte es ja eigentlich gerade schon gesagt,
aber vielleicht habt ihr ja nicht zugehört.
Was kann man hier noch requiren beim Abheben? Kann man
da was requiren? Was allgemein für alle Kunden gilt.
Wollen wir noch mal ganz kurz auf unsere OML-Themen gucken,
was es so für Konten momentan bei uns gibt.
Wir haben ein Girokonto und wir haben ein Sparbuch
Ich bin ehrlich gesagt keinen Banker. Darf man ein Girokonto über
zehn Jahre? Und ein Sparbuch eher nicht, oder?
Okay, das heißt, ich darf hier gar nicht noch
eine zusätzliche Vorbedingung machen. Okay, zumindest nicht an dieser
Stelle. Gut, also wieder weg damit. Ja,
und dann kann ich unten auch entsprechend nichts entschuhen.
Das finde ich eigentlich ganz interessant. Dass der Fall gerade
eintrat. Wir können uns aber zumindest bei dem Girokonto,
oder nee, später bei dem Sparbuch Gedanken machen,
dass wir hier noch weitere Require-Oser zu tun und warum das
dann sinnvoll ist im Sinne des Typsystems.
Gut,
fehlt dir noch irgendwas
Naja, man könnte sich jetzt noch überlegen, einen Konstruktor zu schreiben.
Das würde jetzt aber am Thema nichts Besonderes ändern.
Nö, ich glaube, das lassen wir erst mal so.
Gut, dann machen wir mal eine weitere Klasse.
Wollen wir sie mal nennen? Sparbuch. Ja. Ah. Wenn du irgendwann,
das können wir mal machen, ich nehme einmal das Override,
das kommentiere ich hier einmal aus bei dem Zahl ein.
Und bei dem Heber ab mache ich es nicht
Und wenn du jetzt irgendwann dich dazu entschließt,
dass man auf einem Konto nichts einzahlen kann und auch nichts abheben kann,
du sagst, das war einfach Quatsch in der Modellierung,
das geht gar nicht mit allen Konten,
dann wird der Compiler an den Stellen,
wo du das Overhead stehen hast, wird er dich warnen und sagen,
Achtung, Achtung, du bist der Meinung,
dass du hier etwas,
dass du hier eine Operation aus deinem Interface implementierst.
Das ist aber gar nicht der Fall.
Es gibt keinen Heber ab in Konto.
Sowas würde er einem jetzt sagen. Genau. Must overhead
our implement ist Supertime Ethan
Mütlich an. Richtig, genau. Also zum Beispiel,
wenn ich das Overright hier wegnehme,
verhält sich das Programm genauso wie vorher.
Es ist trotzdem ein Overright. Auch wenn man es nicht hinschreibt.
Das hat einfach historische Gründe. Also als Java damals auf
die Welt kam, gab es dieses Ed Overright noch nicht.
Das kam erst zehn Jahre später. Und dann konnte man
das nicht mehr verlangen, dass es überall hingeschrieben wird.
In C-Sharpen muss man das Overright immer hinschreiben zum Beispiel.
Hat man irgendwann mal festgestellt, dass das sinnvoll ist.
Okay, dann mache ich das mal hier alles wieder rückgängig.
Das ist einfach eine schöne Dokumentation, die quasi von Compiler geprüft wird.
Ich würde euch empfehlen, das immer hinzuschreiben.
Wir hatten das auch in SE1 gesehen bei dem Hashcode,
damit man sich nicht vertippt.
Ist es sinnvoll,
das da genauso zu benutzen
Ich bin schon wieder zu schnell in meinem Gedankengang,
denn hatten wir nicht gesagt,
dass wir hier noch eine Gebühr brauchen für das Girokonto.
Das sollten wir vielleicht einmal kurz noch einbauen, dass es so
eine Gebühr gibt. Centgebühr, hatte ich sie genannt.
Ist das eigentlich erlaubt, Umlaute in Java-Bezeichnern zu haben?
Ich lasse euch das mal rausfinden, hier scheint das kein Problem zu sein.
Jetzt ist die Gebühr immer null, das ist ja nicht
so sinnvoll, vielleicht schreiben wir mal einen Konstruktor dafür.
Ach, wisst ihr was, ich habe keine Lust,
mir selber zu schreiben, ich lasse die mehr generieren von Eclipse.
Source, Generate Constructor, Using Fields. Ich habe
immer keine Ahnung, was die ganzen Optionen hier sind.
Ich sage einfach mal, okay, mal gucken,
was dabei rauskommt
Boah, naja, okay, also das könnt ihr noch nicht verstehen.
Das ist ein bisschen hässlich, dass hier diese Unterstriche sind.
Ich mache mal Altshift Air und über den Unterstrich weg.
Und das mache ich hier mal genauso als Shift Air unterstrich weg.
Und dann braucht man diese Qualifizierung mit dem Invest nicht mehr.
Schade. Ich hatte gehofft, dass es ein bisschen hübscher
ist. Ich glaube, möglicherweise wäre es schneller gegangen,
wenn ich es einfach selbst getippt hätte.
Okay, aber immerhin er kann es auch generieren.
Gut. Okay, ich glaube, damit haben wir alles, oder?
Also jetzt nochmal mit dem OML-Dinger mit dem Kopf.
Wir haben also diese Gebühr und wir haben alles implementiert,
was von uns erwartet wird.
Klar, sonst würde sich ja der Compiler beschweren.
Gut. Ja, dann gehen wir doch jetzt mal doch
zu dem Sparbuch
Guck mal, jetzt habe ich ja vergessen, dass es das implementiert.
Dann schreibe ich das einfach hin, Implementskonto. Und jetzt
werden jetzt wieder ganz viele Beschwerden kommen, sage ich einfach Steuerung eins.
Und add unimplemented Methods. Da sind sie jetzt.
Zahle ein, hebe ab, gib Saldo.
Ja, das jetzt alles noch mal selber zu implementieren.
Wollen wir auf so einen kleinen gemeinsamen Drogentrip gehen und hier so ein paar Dinge kopieren.
Ich kopiere mir jetzt einfach erst mal alles. Ich bin hier,
ich bin ja so ein bisschen wahllos in meiner Wahl.
Und dann überlegen wir uns gleich, was wir davon noch brauchen.
Also, so eine Gebühr gibt es hier ja nicht.
Was haben wir stattdessen? Zinssatz, wie hatten wir
das genannt
Promille. Wollen wir das lieber Zinssatz nennen?
Das würde mir, glaube ich, besser gefallen.
Zinssatz oder so. So, das war nicht mit Absicht
. Oh, Tipp, das wollte ich auch nicht.
So, Zinssatz, Zinssatz. Okay, und dann nehmen
wir das hier natürlich genauso. Zinssatz. Und ja,
manchmal ist diese Generierung und kopieren auch gar nicht so sinnvoll,
zeitsparend. Hallo, Steuern, letterst du?
So. Ah, was ist das Problem an dieser Stelle
Was ich mir mit Copy-Paste eingehandelt habe. Richtig. Du
hast gesagt, der Contrastruktur heißt nicht wie die Klasse.
Ja, in Java muss der Konstruktur ja immer heißen, wie die Klasse.
In anderen Programmierschwanken gibt es dafür Schlüsselwörter oder so.
Okay, gut. Wir machen jetzt noch gar nichts mit
diesem Zinssatz unter Gebühr, aber okay. Ich weiß nicht,
ob das für euch jetzt ein unangenehmes Gefühl war,
dieses Copy-on-Paste, so richtig schön war es ja irgendwie nicht.
Darum kümmern wir uns nächste Woche. Das könnt ihr
jetzt noch nicht wissen, wie man das behebt,
dieses ästhetische Problem oder Wartbarkeitsproblem eigentlich.
Warum wir die dann einfach auch mal benutzen? Diese Girokonten und Sparbücher,
wir machen uns mal eine weitere Klasse. Jetzt würde man vielleicht sagen,
früher hätte man sowas gesagt wie Kontomanager oder so,
aber davon ist man so ein bisschen weggekommen.
Ich nenne es einfach mal Bank, Banken verwalten ja Konten.
Gut. Wie kriege ich das denn jetzt hin,
dass ich hier mehrere Konten ablegen kann in dieser Bank?
Ich lasse euch noch mal kurz ein bisschen überlegen,
also wenn ich jetzt zum Beispiel sage Konto Konto 1 zum Beispiel und Konto,
Konto 2 und dann, ja, nicht so hübsch, oder?
Wenn ich jetzt tausend Konten haben will oder eine Million,
ich will ja nicht für jedes Konto eine weitere Exemplare,
ich habe gesagt,
du weißt es und warst schon,
du erfahrst heute
noch nicht
Ja. Man sieht einfach Kapital. Man könnte ein Eri nehmen vom Tykonto.
Das wäre eine gute Wahl, wenn man von vornherein weiß,
dass in zehn Minuten sie wären auch immer zehn bleiben.
Hatten wir noch was anderes kennengelernt, außer ARS,
wo man sagen kann, das kann so schön dynamisch wachsen und so.
Genau, eine Liste. Wisst ihr noch,
wie man Listen deklariert? Eine Liste von Konto.
Ja. Habe ich jetzt richtig im Programmatik-Tatz? So schreibt
es. So schreibt man das. Und dann Konten.
Ja. Oh, was geht jetzt nicht?
Warum ist das rot
Das macht er unten, ja. Weil man es nicht
importiert hat. Was würde man jetzt in Blue Jay machen?
Man würde sagen, Import, Shava, Yutile List.
Genau. Aber das kann sich ja keiner merken, oder?
Das kann sich keiner merken. Ihr könnt auch sagen,
einfach Steuerung, Shift, oh. Ah, die Liste
gibt es mehrfach. Jetzt müssen wir uns für einen entscheiden.
Die will ich haben. Ja, Steuerungsschiff, oh,
heißt Organize Imports. Dann müsst ihr die nicht selber hinschreiben.
Sehr schön. Dann machen wir mal einen Konstruktor.
Das ist ja wirklich fast Vorbereitung aufs zweite Programm entdeckt hat,
für die Leute, die diesen Woche 4 noch machen müssen
Wir wollen jetzt hier eine neue Liste erzeugen. Vielleicht nehmen wir
mal eine, ach nee, ich nehme mal eine List.
So, übrigens, diese Klammern hat fast jeder vergessen im Dektat.
Ich weiß nicht, woran es liegt wahrscheinlich,
weil man denkt, diese Klammern haben es dann schon abgefrühstückt,
aber man braucht auch immer diese Rundenklammern.
Warum geht das jetzt nicht? Ich habe doch listig hier
oben importiert. Immer dieselben hier? Sehr gut,
man kann von Interfaces keine Exemplare erzeugen. Was würdest du
stattdessen machen? Genau, nehmen wir eine R-Ralyst, ne?
So, das geht jetzt wieder nicht jemand anders,
warum geht das nicht?
Irgendjemand eine Idee
Ja. Ist nicht importiert, also Steuergeschäft, oh und zack.
Gut. Jetzt hören wir vielleicht auch mal ein Konto hinzufügen,
kannst du in der Bank,
ich mache das jetzt mal ein bisschen schneller,
eröffne Konto, R ist ein Konto, ja,
dann übergibt man das Konto da einfach rein,
neues Konto und dann wird das einfach hinzugefügt, ja.
Da ist es. Okay,
kann man schon mal so ein paar Konten da reintun.
Und jetzt mache ich mir einen weiteren Klienten,
einen Klienten der Bank, das können wir mal nennen.
Gibt es irgendjemand, der die Banken im Griff hat?
Sagen wir mal may.
Das ist politisch neutral
Das ist meine Main-Methode. Achso, das habe ich euch auch
noch nie gezeigt, oder? Wenn ihr einfach sagt,
Main und dann Steuerung gelehrt hast und dann Enter,
da ist die Main-Methode. So, ja,
dann machen wir uns doch mal so eine schöne Bank.
Bank, Bank gleich, New Bank. Ach, das
ist mir auch zu umständlich. Ich sage einfach mal,
Neo Bank. Mal gucken, ob er sich dann irgendwie beschwert.
Ascience Statement to New Local Varible, das will ich haben.
Name ist auch in Ordnung. Gut. Dann eröffnen wir
doch mal ein Konto. Sagen wir mal ein Girokonto.
Und da muss ich ja zwei Dinge übergeben.
Was muss ich da übergeben? Salbe und Zandgebühr.
Also sagen wir mal, da ist irgendwie,
keine Ahnung,
fünf Euro sind drauf
Wie viele Cent werden pro Jahr ein Euro pro Jahr vielleicht,
keine Ahnung? Das ist ein sehr günstiges Konto. Okay,
und dann tun wir vielleicht auch noch ein Sparbuch rein,
eröffne Konto, nu Sparbuch, Sprachbuch, Sparbuch.
Und was muss ich da übergeben? Saldo und Zinssatz,
ja, vielleicht 10 Euro und Zinssatz,
hatten wir gesagt, in Promille 1. 0,1 Prozent,
ich glaube, das kriegt man ungefähr heutzutage.
Ich glaube, das ist blöd. Nee,
ist nicht schlimm. Das wird ja dafür sorgen,
dass wir dann nach einem Jahr 1000 und einen Euro haben,
wem mir nicht alles täuscht. Gut. Okay,
dann haben wir da schon mal so ein kleines Gerüst zusammengebaut.
Wollen wir vielleicht mal gucken, was auf den Kunden drauf ist.
Ich könnte immer hier so eine kleine Vorschlafe schreiben.
So, ich werde also über alle Kunden iterieren.
Da kam ja auch in dem Betat dran, ach,
nicht um, nicht mit Unterstrich.
So. Und wieso geht das auch nicht? Nee,
es ist eine Bank. Es ist keine Kunde,
es ist eine Bank. So? Nee, auch nicht
. Was mache ich hier gerade? Ich kann gar nicht
über Banken iterieren,
fällt mir gerade auf
Das ist ja interessant. Wie kann ich denn jetzt
dafür sorgen, dass man über Banken iteriert?
Soll ich jetzt mal mit den Händen wählen und das machen,
was ihr so in einem halben Jahr verstehen werdet?
Weil das dauert sonst, glaube ich, zu lange.
So. Das ist jetzt so ein ganz kleines bisschen Magie,
das tut mir leid, ihr könnt es ja notfalls einfach mal nachlesen.
Das heißt einfach nur so viel wie über eine Bank zu iterieren,
heißt dasselbe wie über die Konten zu iterieren,
die in der Bank drin sind.
Mehr heißt das nicht. So viel Magie ist das
gar nicht. Okay, ich will also über die Bank
geht er reden
Jetzt beschwert er sich nicht mehr. Und jetzt will ich
was auf die Konsole schreiben, sagen wir mal,
das Konto, was ich gerade an der Hand habe,
kann ich mir dann nicht mal den Saldo geben lassen.
Da haben wir es, das kann ich nur in eine Variable tun.
Nee, ist ja ein Long. So. Gut,
und das will ich jetzt auf die Konsole schreiben.
Wie schreibt man noch mal was auf die Konsole?
Sonst jemand? Ja. System Out irgendwas, ne?
Also Süßo, merkt euch das mal und dann
Steuerung gelehrt hast du
Okay, also es gibt für alles eine Abkürzung in den E-Clips.
Was würden wir jetzt erwarten? 500 und 1.000, richtig?
Und vielleicht tue ich diesen Code nochmal irgendwie eine eigene Methode.
Das ist, wie macht man das,
dass ich einen Code in eine eigene Methode tue?
Ich zeige es euch einmal von Hand.
Also ich würde hier irgendwie so eine kleine Hilfsmethode bauen,
nenne ich sie mal Scheibe, Scheibe,
Konten auf Konsole oder schreibe Sal.
Was ist der Plural Saldi? Dankeschön. Ich beschreibe.
Sal denn? Saldi, Salden? Ich weiß nicht,
ich nehme das hier. Okay,
und dann würde ich jetzt
diesen Code nehmen
Würde ihn einmal ausschneiden, okay, ich kann ihn ja auch verschieben.
Ich verschiebe ihn mit der Alttaste und den Körsertasten.
So, ne? So, und dann muss ich den
hier unten aufrufen. Ich habe den Rückgabetyp vergessen. Ihr seht,
wie schwierig das ist, das von Hand zu machen.
Aber ich zeige euch einmal, dass ihr den Schmerz einmal gesehen habt.
Ach, jetzt gibt es die Bank ja ja gar nicht.
Da muss ich die Bank ja auch noch übergeben.
Ja, okay, machen wir das auch noch.
Das ist toll, wie schwierig das ist,
weil ihr werdet gleich sehen, das geht alles schon alleine.
Wenn man es mit Eclipse-Mitteln macht, und jetzt muss ich
es aufrufen, schreibe, so.
Und einmal testen, ob es funktioniert.
Ich führe es einmal aus als Shift XJ.
Und dann müsste sich unten
irgendwas tun
Es tut sich nichts, dann mache ich das mal mit
der anderen Methode, rechte Maustaste, Ron as Java Application.
Okay, zumindest das funktioniert. Und ihr seht jetzt wahrscheinlich nichts,
ne? Ich werde das jetzt einmal so weit hochziehen.
Ah, da seht ihr es. 500 um 1000,
das hat also funktioniert. Okay, das mache ich jetzt
nochmal alles rückgängig, was ich hier gemacht habe.
Also ich hatte das hier von Hand aufrufen müssen,
dann muss ich hier denken, den Parameter einzuwinden,
dann hatte ich hier den Rückgabetyp vergessen,
dann hatte ich das von Hand verschieben müssen,
dann musste ich den Namen aufdenken, muss ich auch,
aber das musste ich alles hinschreiben
So, jetzt zeige ich euch mal, wie man das automatisch machen kann,
weil das braucht man sehr, sehr häufig.
Ich markiere einfach den Quelltext und sage jetzt Altshift M
und kann das jetzt irgendwie nennen. Sagen wir mal,
wir hatten es eben genannt, Schreiberseiden auf Konsole.
Schreibe, seien auf Konsole. Und sage ich, okay
, und das war's. Das System hat automatisch verstanden,
dass es diesen Parameter anlegen muss,
dass es dann das hier entsprechend übergeben muss,
hat den Code entsprechend verschoben und hat den Aufruf hier hingetan.
Ja, also ihr habt nie die Entschuldigung zu sagen,
oh, ich habe hier so eine lange Methode,
ich müsste sie ja eigentlich unterteilen,
aber ich habe nicht
die Zeit dazu
Äh, man kann über die Konten einer Bank iterieren.
Ich hatte ja gerade so ein bisschen mit den Händen gewedelt,
weil ich hier oben behauptet habe,
eine Bank implementiert das Interface, iterierbar über Konten.
Und die Magie steckt in dieser Methode,
die einfach nur sagt, über eine Bank zu iterieren,
ist dasselbe wie über Konten zu iterieren.
Was hier genau passiert, könnt ihr erst verstehen,
wenn wir über Entwurfsmuster reden. Das ist, glaube ich
, Woche um neun oder so. Ungefähr. Okay,
das Problem hatte ich ja vorher, dass das nicht ging.
Okay, sehr schön. Das heißt, was haben wir
jetzt gemacht? Wir gehen nochmal ganz kurz hierhin zurück.
Im Prinzip haben wir gar nichts Neues gemacht.
Wir haben uns ein Interface überlegt mit irgendwie drei sinnvollen Operationen,
zwei verschiedene Typen,
die das implementiert haben
Was Interessante ist, dass diese Typen jetzt weitere Operationen haben,
ziehe Gebühren ab auf der Seite und schreibe Zinsen gut auf der Seite.
Und das kann ich nicht in das Interface reintun.
Das geht einfach nicht, weil ich kann ja nicht
hier Zinsen gut schreiben und hier Gebühren abziehen.
Das wäre irgendwie Quatsch. Vom Modell her würde das einfach
keinen Sinn machen. Okay, jetzt sage ich euch mal,
was sehr nah am Übungsbetriebe ist.
Ich gehe also wieder in Eclipse zurück. Ich würde jetzt gerne
eine weitere Methode schreiben, die über alle Konten rübergeht.
Ich kann es ja erstmal wieder hier unten hinschreiben direkt.
Ne, Entschuldigung
Die über alle Konten rübergeht und dann diese Spezialmethode aufruft,
ja. Man kann das ja vielleicht mal nennen,
man nennt es immer ganz gerne, mache Jahresabschluss, glaube ich.
Können wir doch mal dann hier vielleicht gleich genauso machen.
Also, ich iteriere über alle Konten der Bank.
Ja, und jetzt muss ich irgendwie herausfinden,
was für ein Konto ist es denn? Das ist etwas,
was man in der Objektunion sehr ungern mal zu fragen,
bist du ein Girokonto oder bist du ein Sparbüro?
Wir müssen es jetzt leider machen. Ihr wisst,
wie es geht. Ihr habt es hoffentlich vergessen,
weil man soll das ja eigentlich so selten wie möglich machen.
Ich kann also sagen, if konto instance of Girokonto
Habt ihr das schon mal gesehen? Ja, so ein
paar Leute haben es schon mal gesehen. Kann ich dann
einfach sagen, konto., wo ist jetzt mein,
mit den Gebühren, das taucht hier gar nicht auf, warum nicht?
Weil der statische Typ von Konto nach wie vor Konto ist,
erinnert euch daran noch, man muss jetzt irgendwie sagen,
ich muss mir eine Girokonto-Variable anlegen und muss dann das Konto auf Girokonto eine Typzusicherung machen.
Erinnert sich noch jemand daran, ungefähr dieselben Leute, das macht Sinn.
Gut, und jetzt kann ich bei dem Girokonto sagen,
Wo waren wir es jetzt? Wo ist meine schöne Methode?
Haben wir die noch gar nicht geschrieben oder sehe ich sie?
Haben wir die noch nicht geschrieben? Ach. Guck mal,
wir haben sie so wunderbar moduliert, auf wem sie noch gar nicht geschrieben.
Okay. Also Gebühren abziehen, ihr seht den Quelltext nicht
besonders hübsch, ich schiebe ihn einmal nach oben.
Gebühren abziehen, kriegen wir, glaube ich, gerade noch hin.
Also Public Void, ziehe, wie habe ich sie so genannt?
Ziehe Gebühren ab. Ist auch egal, wenn sie jetzt leicht
anders heißt. Genau, ich will also von meinem Saldo,
die, wie hießen sie
Komm schon der Clips. Lass mich nicht im Stich.
Die Centgebühr abziehen. Gut. Jetzt gehe ich wieder hierhin zurück.
Kann ich das jetzt hier aufrufen? Ja, da ist es.
Gut. Aber es geht auf der Kontovariable nach wie vor nicht.
Also wenn ich sage Konto.z. Das dürfte doch eigentlich nicht gehen.
Das passiert. Oh. Das ist die Magie von Equipse
. Er erkennt, dass es eigentlich nicht geht.
Und fügt dann die entsprechende Magie ein,
die wir hier von Hand hin geschrieben haben
Das ist mir ein unbekanntes Feature, das kannte ich vorher nicht.
Ich finde das so ein bisschen expliziter. Okay.
Das war ja dasselbe nur in einer Zahl. Gut,
haben wir, haben wir in dem Sparbuch dasselbe gemacht,
dass du das hier noch gar nicht, um die Tatsache Zinssatz,
das müssen wir also auch noch kurz machen.
Schreibe Zinsen gut. Wollen wir auch noch kurz schreiben.
Also, Hard Black Ford schreibe Zinsengut, gut. Huiuiuiui,
Zinsberechnung, das war jetzt in Promille,
hatten wir gesagt, könnte man dann nicht einfach sagen,
ich nehme meinen Saldo,
multipliziere ihn,
hallo,
mit dem Zinssatz
Und das Ganze teile ich dann durch 1000, weil es ja Promille sind.
Und das Ganze addiere ich dann auf meinem Saldo drauf.
Kann irgendein Mathematiker da mal drei Sekunden rausschauen und sagen,
dass das sinnvoll ist, was ich da gerade tue.
Ja, okay. Gut, ich schreibe Zinsen gut.
Dann kann ich das jetzt hier hoffentlich so ähnlich machen.
Also wenn es sich stattdessen um ein Sparbuch handelt.
Und jetzt einfach mal als Kontrast, können wir jetzt mal
die Equips-Variante nehmen. Oh, da fehlt das off.
Also wenn ich jetzt tatsächlich sage, kontopunkt, schreibe Zinsen gut.
Ja, also mach das selbe. Es ist nur ein
bisschen unleserlicher. Er macht es nicht wirklich auf den Konto,
sondern er macht erst mal diese Typzusicherung.
Das ist wirklich ein Sparbuch, sondern man muss das
noch mal ein bisschen komisch geklammert werden
Okay. Jetzt schreibe ich ja drunter mal was. Warum? Warum will man
sowas in langfristigen Softwareprojekten nicht in seinem Code drin stehen haben?
Wenn es so ein Konto ist, dann mache dies.
Wenn es so ein Konto ist, dann mache das. Naja,
jetzt kommt irgendwann hier der Modellierer und sagt, ach,
wir haben auch irgendwie so eine dritte Art vom Unterkonto.
Mir fällt gerade nichts Sinnvolles ein. Geld finde ich einfach
nicht so interessant. Und was wird dann passieren?
Tja, das wird hier nicht entsprechend irgendwie behandelt.
Es ist also kein Girokonto, es ist kein Sparbuch,
dann passiert einfach nichts.
Das ist wahrscheinlich nicht
so sinnvoll
Nun, jetzt könnt ihr euch vorstellen,
solche iFLs-Ketten habt ihr in einem Programm, was vielleicht aus 10.000 Silent Quad besteht,
da habt ihr bestimmt 50 oder 100 Stück von solchen FLs-Dingern.
Das heißt, ihr habt vielleicht einmal im Monat so einen Instance-Off-Tag,
wo es heißt, lasst uns mal alle Instance-Offs durchgehen und durch unseren Code,
ob die immer noch alle Fälle abdecken.
Das ist, weiß ich nicht, Beschäftigungstherapie. Okay, was könnte man denn stattdessen machen? Also ich habe irgendwie,
ja, einmal diese Methode ziehe, Gebühren ab,
einmal diese Methode schreibe, Zinsen gut und ich will das halt einmal,
dass das einmal pro Jahr gemacht wird,
wenn man jetzt mal hier so in diese Modellierung reingeht,
könnte man da irgendwie ja was machen, dass man sagt,
egal was für ein Konto das ist, einmal im Jahr dieselben,
immer dieselben, niemand anderes,
irgendeine Idee.
Es soll für alle Konten funktionieren und sozusagen Uniform,
egal was für ein Konto das ist.
Ja. Richtig, man könnte im Interface eine Operation hinzufügen.
Wollen wir sie mal nennen? Mache Jahresabschluss. So zum
Beispiel, ja, mache Jahresabschluss. Gut,
die tue ich da jetzt einfach mal rein und schaue mal,
wie Eclipse das findet, dass ich die da reintue.
Also, wollt, mache Jahresabschluss, Und jetzt gibst du sofort
die roten Kreuze. Er beschwert sich jetzt. Ein Girokonto
ist kein Konto, denn ein Girokonto weiß noch nicht,
wie man einen Jahresabschluss macht.
Dann sage ich doch einfach mal Add-on-Implemented Methods.
Dann müsst du die jetzt irgendwo hier unten erschienen sein,
da ist sie. Was kann ich denn jetzt Sinnvolles tun
in dem Mache-Jahresabschluss? Irgendjemand eine Idee. Richtig,
wir führen die Methoden mit den Gebühren aus Assozie, Gebühren ab.
Sehr schön. Dann gehen wir in das Sparbuch,
hier wird er sich wieder beschweren, dann sage ich,
hey, machen wir doch mal einfach die Methode dahin zu,
dann müsste sie jetzt hier unten auftauchen.
Da ist sie Und was machen wir da jetzt, vielleicht mal jemand anders?
Ja. Genau, wir schreiben einfach die Zinsen gut.
Sehr schön, das will er auch. Und was vereinfacht sich
jetzt? Kann ich jetzt stattdessen hier irgendwas anderes hinschreiben?
Das ist ja mein Ziel, ne? Irgendjemand,
der vielleicht noch nicht dran war. Wir haben jetzt
so eine schöne Operation im Konto hinzugefügt, ja?
Genau, du hast vorgeschlagen, hey, konto.mache Jahresabschluss.
Und was passiert jetzt mit dem Coach hier unten
Den können wir löschen. Ah, ein Traum meines jedes Programmierers
. Code, der furchtbar ist, einfach weg damit.
Ja? Sehr gut. Wir können das sehr vielleicht einmal machen.
Ich tue das jetzt vielleicht nochmal in eine eigene Methode.
Altshift M war das ja, nennen die vielleicht auch mal Mache-Jahresabschluss innerhalb dieser Klasse.
Das ist jetzt, finde ich, jetzt nicht so schlimm.
Und jetzt will ich, dass der Jahresabschluss, Mensch,
dass der Jahresabschluss vorher gemacht wird.
Ich schiebe das einfach mal darüber ab. Zack. Ja,
mache erst den Jahresabschluss und dann schreib doch mal die Seiten auf die Konsole.
Und dann schauen wir, dass das passiert,
was wir erwarten, was passieren sollte.
Ist das jetzt
der Fall
Ja, guck mal. Also das auf meinem Girokonto ist
jetzt weniger Geld drauf und auf meinem Sparbuch sind jetzt,
ja, ein Cent Zinsen gut geschrieben worden für 10 Euro,
die drauf waren. Das ist doch super. Okay,
jetzt habe ich nur noch zwei Minuten, ich glaube,
zwei Minuten ist ein bisschen wenig,
um nochmal ein neues Thema anzufangen.
Vielleicht nochmal so eine kleine offene Fragerunde. Gibt es hier
noch irgendwas, was ihr nicht verstanden habt?
Dann einfach machen. Okay, dann sehen wir uns
nächste Woche.
Vielen Dank