Hi, jetzt bin ich doch noch mal da,
und zwar mit einem Video zum Thema Typzusicherung.
Keine Sorge, das ist kein neuer Stoff.
Das war alles schon in Vorlesung 3 dran.
Da gab es noch ein paar Unklarheiten und deswegen möchte ich
das noch mal auf eine andere Art und Weise erklären.
Aber wie gesagt, keine Sorge, kein zusätzlicher Stoff,
einfach nur eine andere Erklärung. Jetzt mal zu dem Szenario,
was wir da hatten. Wir haben eine Klasse Konto,
die hat die Methodenzahle ein, hebe ab.
Dann haben wir ein Sparbuch, die erbt von Konto,
erbt logischerweise dann auch Zahle ein und hebe ab
und hat eine zusätzliche eigene Methode,
schreibe Zinsen gut
Dann haben wir eine Klasse Girokonto, die erbt auch von Konto.
Logischerweise erbt sie dann auch Zahl-Einheber ab und hat dann noch
eine zusätzliche eigene Methode, Ziel, Gebühren ab.
Dann haben wir hier eine Bank, die hält einfach nur
eine Liste von Konten. Diese Liste hat ein Element-Typ-Konto,
da dürfen wir, weil Sparbuch und Girokonto ja vom Konto erbt,
dann sowohl Referenzen auf Sparbücher als auch auf Girokonten reintun,
mit eröffnendem Konto,
kann man einfach nur eine Referenz auf ein Objekt hier der Liste hinzufügen.
Und hier haben wir einfach nur ein Ghetter,
um uns die Liste nach außen geben zu lassen
Dann haben wir hier die Klasse Start-up, die erzeugt hier eine neue Bank,
weil es ist eine Referenzvariable vom Typ Bank zu und ruft darauf,
eröffne Konto auf, einmal mit dem Girokonto,
mit einem Saldo, einem Zins,
saßen wir mit dem Sparbuch mit dem Saldo und einem Zinssatz.
Und dann haben wir noch eine Methode, veröffentliche Bilanz.
In dieser Methode lassen wir uns hier einfach die Konten von der Bank geben,
dass wir eine Liste mit Referenzen auf Girokonten und Sparbücher und über
diese Diese Liste iterieren wir hier mit einer erweiterten Vorschleife.
Und das bedeutet ja nichts anderes, als dass wir uns
jedes Element der Liste rausnehmen. Es ist ein einer Referenzvariablen
vom statischen Typ Konto zuweisen und damit dann irgendwas machen.
Und wir wollen hier an der Stelle,
also diese beiden Zeilen sind die, um es geht,
an der Stelle wollen wir eine Methode aufrufen,
die es nur in Girokonto gibt.
Und das dürfen wir eigentlich nicht.
Ich nehme das hier mal weg
Und schreibt jetzt mal Konto, Punkt, Ziehe, Gebühren ab.
Und hier an der Stelle sagt mir dann Compiler schon,
hey, sie gebühren ab, ist in Konto nicht definiert.
Wir dürfen grundsätzlich immer nur auf einer Referenz variablen,
die Methoden aufrufen, die in ihrem statischen Typ definiert sind.
Dabei ist es vollkommen egal,
ob dieser statische Typ durch eine Klasse definiert wird,
wie hier bei uns, also eine Klasse,
von der wir geerbt haben oder ob der durch ein Interface
definiert wird,
das wir implementieren
Warum ist das so, dass wir nur die Methoden aus dem statischen Typ aufrufen dürfen?
Naja, in dieser Liste haben wir ja sowohl Girokonten als auch Sparbücher.
Wenn wir jetzt an der Stelle beim Itterieren ein Sparbuch erwischt haben und versuchen,
jetzt auf einem Sparbuch die Methode Zielgebühren ab aufzurufen,
wie es da gar nicht gibt,
dann knallt das Programm natürlich, weil wir eben,
wie gesagt, versuchen, eine Methode aufzurufen,
die es in der Klasse, die dieses Objekt,
was gerade der variablen Konto zugewiesen ist,
was da
gar nicht drin vorhanden ist
Das dürfen wir also nicht machen. Deswegen nehme ich das
hier schnell mal wieder weg. Wir dürfen also auf einer Referenzvariablen
immer nur die Methoden aufrufen, die in dem statischen Typ definiert sind.
Warum hilft uns aber diese Zeile dann dabei? Das zeige ich
gleich mal an einem etwas allgemeineren Beispiel. Wir haben hier,
eine Referenzvariable Konto, die ist vom statischen Typ Konto,
dieser Kasten hier, so eine Klasse symbolisieren.
Da sind zwei Methoden drin, zahle ein und hebe ab.
Und dieser Referenzvariablen reisen wir jetzt ein Objekt der Klasse Giro-Konto
zu. Das dürfen wir, weil Giro-Konto von Konto erbt
Und diese Ellipse hier soll jetzt so ein Objekt symbolisieren.
Und in diesem Objekt sind die beiden geerbten Methoden enthalten,
zahle ein und hebe ab. Und logischerweise auch die Methode,
ziehe Gebühren ab, die in Girokonto ja zusätzlich definiert wurde.
Da wir aber nur Methoden aufrufen dürfen,
die im statischen Typ definiert sind,
kommen wir über die Referenz variable Konto,
nur an Zahle ein und hebe ab heran.
Nicht aber an Hebegebühren ab.
Die wollen wir denn aber jetzt gerade haben.
Wie kommen wir also dahin
Wir definieren uns eine zweite Referenzvariable, die nennen wir mal
Giro-Konto und die ist vom statischen Typ Giro-Konto.
Über die dürfen wir potenziell sämtliche Methoden aufrufen, die in
der Klasse Giro-Konto definiert sind, also auch Ziehegebühren ab.
Deswegen lassen wir in dieser Referenzvariable jetzt auf dieses Objekt
zeigen und das machen wir hier mit dieser Zuweisung.
Es wird ja immer das, was rechts vom Gleichheitszeichen ist,
dem, was links vom Gleichheitszeichen ist,
Und bei Referenz Variablen bedeutet Zuweisung einfach immer nur,
dass sie auf ein und dasselbe Objekt zeigen.
Wir haben im Moment auch ein kleines Problem,
weil uns der Compiler jetzt das so noch nicht erlauben würde.
Deswegen müssen wir eine Typ-Zusicherung machen. Typ zu sich und bedeutet,
dass wir sagen, hey, in diesem Moment zeigt,
wir sind uns ganz sicher,
dass in diesem Moment die Referenz Variable Konto auf ein Objekt der Klasse Girokonto zeigt.
Das heißt, vom dynamischen Typ Girokonto ist,
nochmal SE1-Wiederholung, der statische Typ einer Referenz war Jables,
immer der Typ,
mit dem
die Variable deklariert wurde
Der dynamische Typ ist immer der Typ des Objekts, das gerade zugewiesen ist.
Dementsprechend hat durch diese Zuweisung die Referenz war jable Konto,
den statischen Typ Konto und den dynamischen Typ Girokonto.
Und weil wir das hier zusichern, dass der dynamische Typ
von Konto, Girokonto ist, dürfen wir hier diese Referenz
Valiable vom statischen Typ Konto, in der Referenz Valiablen,
vom statischen Typ Girokonto zuweisen und haben jetzt auf einmal
zwei Zugriffswege auf ein und dasselbe Objekt über diesen Zugriffsweg
Kriegen wir leider immer noch nur diese beiden Methoden.
Aber über diesen Zugriffsweg kriegen wir alle drei Methoden.
Also auch die Methode, Ziel, Gebühren ab.
Ich zeige euch das nochmal am Code. An der Stelle hier,
dass hier ist unsere Typ-Zusicherung, an der Stelle durch diese Zuweisung
weisen jetzt zwei Referenzvariablen auf ein und dasselbe Objekt zu.
Und eine davon, nämlich Girokonto, ist vom statischen Typ Girokonto.
Das heißt, durch diese Zuweisung Haben wir dieses Szenario erreicht,
dass wir zwei Zugriffswege auf ein und dasselbe Objekt haben.
Und über diesen Zugriffsweg vom statischen Typ Girokonto dürfen wir ja alle Methoden aufrufen.
Und dementsprechend hier mit Punktoperator auch, ziehe Gebühren ab.
Diese Methode ist halt nur in Girokonto definiert.
Und deswegen haben wir das hier machen müssen.
So viel dann von mir zu Typ Zusicherung.
Ich wünsche euch ganz, ganz viel Erfolg für die Klausur
und wir sehen uns dann