So, hallo miteinander. Ich freue mich, dass Sie alle da sind.
Wir haben heute das Vergnügen miteinander, uns mit Interfaces,
nachdem wir die Interfaces haben, diese Interfaces umzusetzen auf Datensammlungen.
Wir sind heute ein anderes Gespann,
und zwar wird heute Sandra Schröder den Teil von Fred übernehmen.
Viele von ihnen kennen sie ja aus den Übungen, die sie auch betreut.
Fred ist leider erkrankt. Wir hoffen, wünscht man ihm
von mir aus alles Gute, dass seine Stimme wiederkommt.
Ich denke, wir werden es auch zu zweit heute hinbekommen.
Wir haben heute Also wir haben beim letzten Mal ja schon
uns mit Interfaces beschäftigt. Heute sieht das Thema erstmal nicht danach aus,
als ob es damit weitergeht. Aber es ist ein anderes,
ganz wichtiges Thema, was wir in der Informatik brauchen.
Informatik handelt von Informationsverarbeitung. Und da reicht es uns natürlich nicht,
den einzelnen Wert zu haben, ob das nun eine Kleidkomma
oder eine Festkommazahl oder eine Zeichenkette, nein, wir brauchen mehr.
Und wenn wir viele Daten verarbeiten wollen,
zum Beispiel die Daten der Produktion, die Daten über ganz viele Menschen,
über Organisationen, über Messwerte, was auch immer,
dann müssen wir Daten verarbeiten,
die wir irgendwie versuchen können,
Und diese Zusammenfassung, wenn wir uns mit Objekten beschäftigen,
sind natürlich, werden natürlich als Objekte behandelt.
Und dafür gibt es das englische Wort Collections,
das ins Deutsche übersetzt als Sammlungen bezeichnet wird.
Also es hat nichts mit den Kunstsammlungen zu tun,
sondern eher mit Mengen. So, und wir werden damit loslegen,
dass wir erst mal betrachten, worum geht es,
wie geht es damit, was können wir damit machen?
Und klar, der Weihnachtsmann darf mit zugucken.
Es geht los mit unterschiedlichen Typen
Mengen und Listen. Mengen kennt man auf jeden Fall irgendwie aus dem Abitur,
da gab es Untermenge, Teilmenge, solche Sachen, so Mengen, Operationen.
Tatsächlich spielen die hier mit rein, wenn wir die betrachten,
was diese Mengen, die wir hier haben,
was die können, muss man das Mikro ein bisschen wegnehmen,
damit ich es nicht so reinpuste,
damit die Leute am Stream nicht einen Herzkasper kriegen.
Ja, also das sind die Mengen und die Listen,
die kennen sie auch irgendwo her, weil Listen kennt man einfach,
aber die Listen hier in der Informatik,
in der Datenverarbeitung sind noch ein bisschen was anderes,
Listen sind Ketten.
Ja, hier steht jetzt die theoretische Informatik,
tatsächlich haben wir dort auch sowas zu tun,
aber was wir zunächst betrachten wollen, Mengen
Das sind Sachen, die ungeordnet sind und da kommt
jedes Einmal vor. Das passt tatsächlich mit dem,
was sie von Mathematikunterricht irgendwo vom Abitur her kennen.
Etwas ist enthalten in einer Menge und es ist nicht enthalten in einer Menge.
Da wird nicht gefragt, ist es als erstes, als zweites,
als drittes reingefügt worden? Ja, also die deswegen ungeordnet.
Aber es kommt auf das Enthaltensein an. Also hier,
etwas ist in einer Menge enthalten, das kennen wir aus der Mathematik.
Während Listen so etwas ist wie so eine Reihe.
Also so wie Eine Reihe von Paketen auf einem Förderband.
Ja, da gibt es ganz klar eine Reihenfolge.
Eine Reihe von Noten in einer Notenlinie.
Die werden in einer bestimmten Reihenfolge abgespielt. Ja,
und hier zum Beispiel in einer Liste ist das V eben
oder dieses Element eben an der zweiten Stelle, wie auch immer. Ja,
und wenn wir das jetzt mal uns noch ein bisschen genauer angucken,
dann sieht das von der Theorie her,
also von dem Ansatz, von dem, was dahinter steht,
an Regeln so aus, diese Aneinanderherrung, hatten wir schon,
dass wir diese Aneinanderreihung von Elementen haben,
die immer gleichartig sind.
Das Wort gleichartig hilft uns schon oder hilft es schon auf die Sprünge,
wir hatten ja diesen Begriff Typ Den hatten wir beim letzten Mal auch als abstrakter Datentyp.
Also nicht nur die Daten sind gleich,
sondern die Operationen, die man damit auch macht.
Dieser objektorientierte Typ, das sollten sie sich vielleicht daran erinnern.
Ja, so meine Maus hole ich auch wieder.
Ja, das heißt, die sind hintereinander. Das heißt,
es ist eine Folge und damit auch schon ein Reihenfolger.
Und da die hintereinander sind, ist auch klar,
es ergibt sich daraus, etwas kann mehrfach vorkommen.
Also tatsächlich können wir zwei, drei Sachen hintereinander haben. So,
und Das Ganze fängt an, wir haben hier mit Rekursion,
können wir das machen, Rekursion haben Sie schon kennengelernt,
wir können anfangen mit der Lehrenliste und da kommt dann wieder
eine Liste ran und diese Liste enthält dann ein oder mehrere Elemente,
dann wieder, wieder, wieder.
Auf diese Weise kann ich eine Kette machen, die theoretisch,
das ist ja hier theoretisch unendlich lang ist.
Praktisch ist unser Speicher irgendwann voll, aber erstmal kann so
eine Liste in der Länge überhaupt nicht beschränkt. So,
häufig werden diese Listen einfach nur so benutzt, dass ich sage,
es geht, es gibt mir das erste Element,
gib mir das nächste Element.
Ja, also das heißt, sie werden nacheinander durchlaufen,
deswegen steht hier am nächsten Punkt sequenziell,
wo ist die Maus wieder hin,
Sequentiell und damit können wir nacheinander immer das Gleiche mit den
Elementen machen, weil die sind ja vom gleichen Typ.
Hier unten sind noch ein paar Beispiele, was man mit Solisten machen kann.
Natürlich kann man eine Lehrerliste erzeugen, man kann was dranhängen oder
man kann ab einem bestimmten Punkt den Rest sich geben lassen.
So, natürlich kann man so suchen, ob etwas drin enthalten ist,
aber wir wissen ja schon, etwas kann mehrfach enthalten sein.
Das heißt, die Antwort auf etwas suchen,
das kann auch, da können auch mehrere Antworten geben.
So, oder man kann ermitteln,
ob, wenn man schon an der 17. Position bin,
gibt es denn da noch was weiteres oder höre ich jetzt
auf mit durchsuchen
Diese Operationen, die können wir uns jetzt am Beispiel mal angucken.
Also wir nehmen jetzt hier eine Liste von Strings.
Dieses Drinks sind Namen, die können also für Personen stehen beispielsweise.
Und die haben zum Beispiel, sind das jetzt hier Personen,
die sind in der Schule eingeteilt, dass da kein Quatsch passiert,
müssen die nacheinander aufpassen oder an bestimmten Positionen aufpassen.
Und wenn wir sagen, eine Reihenfolge, dann gibt es
natürlich da Plätze, die in gewisser Weise aufeinander folgen.
Und wenn wir jetzt etwas einfügen wollen,
zum Beispiel an der zweiten Position, ja,
also die zweite Position wäre diese hier,
wir wollen jetzt hier etwas einfügen,
was passiert dann mit den anderen,
die da sind
Wird das gelöscht? Wird das überschrieben? Genau, wir
schieben das einfach weiter. Ja, weil der Riss,
der hintere Teil wird als Liste betrachtet und wenn wir jetzt hier etwas einschieben,
dann würde das so aussehen, wupps, wird Platz gemacht und dann wird hier was eingefügt.
Ja, und dann gibt es hier jemand Neues. Ja,
also das heißt, jeder Teil, jedes Stück der Liste kann wieder als Liste betrachtet werden und deswegen, wenn man da was einfügt, wird der andere Teil einfach verschoben. Sehr schön. So,
wenn man jetzt etwas entfernt, ja,
zum Beispiel wir sehen jetzt mal hier, der Peter,
der ist zweimal drin,
einmal hier und einmal hier und da hat er festgestellt,
ach nee, so viel möchte ich nicht Pausenaufsicht machen,
ich will da mal was anderes tun,
nehmt mich mal raus und dann nimmt man den Peter raus,
an der zweiten Position, wo er vorkommt,
dass es wäre also hier diese und dann können sie schon raten,
dann wird das passieren, der Rest der Liste,
in dem Fall hängt hinten dran nur noch der Jan,
der wird dann nur nach vorne geschoben,
schauen wir uns an, wie das aussieht, ja,
der Jan ist ja dran und dann wird das nachgeschoben,
ja, und damit haben wir wieder eine Liste,
also das, was wir hier haben,
ist immer
eine Liste
Und man betrachtet sogar als Liste, das ist ein bisschen ein Ausnahmefall,
für den ersten Blick, weil das Ding leer ist,
wenn es kein Element enthält, ist es trotzdem eine Liste.
So, das hat natürlich noch eine Reihenfolge. Soweit zur Liste.
Wir merken uns, es gibt eine Folge, man darf mehrfach vorkommen.
Gehen wir zur Menge. Zunächst erstmal vom Ansatz her,
hatte ich schon gesagt, wir hatten es eben schon mit dieser Enthaltensein,
das kennen Sie aus der Mathematik,
deswegen machen wir hier ein bisschen schneller.
Es ist eine Sammlung von Elementen, auch wieder hier gleichartig,
das heißt der gleiche Typ.
Und jedes darf aber hier, das ist der Unterschied,
nur einmal vorkommen.
Und es gibt keine Reihenfolge
Das zweite hier, das interessieren wir uns jetzt erstmal nicht so sehr mit den Backs,
das gibt es auch noch, aber das ist eine Besonderheit.
Wir gucken erstmal die ursprüngliche Menge an. Und da gibt es also,
ich kann was hinzufügen, entfernen, prüfen,
ob etwas drin ist, Vereinigungsmenge, Teilmenge, sowas Schnittmenge,
das kennen sie aus der Mathematik vielleicht noch.
Ich hoffe, sie erinnern sich. Und ich kann auch noch sagen,
zum Beispiel so etwas wie, wie viele Elemente gibt es denn?
So, was können wir mit dieser Menge machen?
Wir nehmen als Beispiel eine Liste, nicht Liste. Nein,
Liste wollen wir nicht, sondern wir wollen einen Text analysieren.
Und dieser Text enthält bestimmte Worte oder enthält sie eben nicht
Und ursprünglich ist der Text natürlich irgendwie in der Reihenfolge,
aber wenn wir nur sagen, kommt etwas vor oder nicht,
dann brauchen wir die Reihenfolge nicht mehr,
dann können wir mit der Menge umgehen.
Und da können wir zum Beispiel zwei Mengen haben. Ja,
wir haben hier eine Textmenge, noch eine Textmenge und könnten
jetzt überlegen, was kommt denn in beiden vor?
Ja, oder was ist übrig,
wenn man die einen Menge von der anderen entfernt?
Das wäre jetzt hier auch denkbar, also Teilmengen, Vereinigungsmengen.
Dieses ganze Zeug geht es, darum geht es hier
Wir hatten jetzt Mengen, wir hatten Listen,
es gibt tatsächlich noch mehr hier oben auf der Voragentfolie,
war noch Back genannt.
Das ist eine Spezialform davon. Etwas, was noch relativ häufig vorkommt
, heißt Map. Ja, Map ist eine Abbildung,
das klingt erstmal sehr abgefahren und sehr abstrakt.
Tatsächlich gibt es das relativ häufig. Ich habe hier unten mal
ein Beispiel angegeben für ein Telefonbuch, zum Beispiel brauchen sie das.
Da haben sie Namen, Telefonnummer oder auch Name,
Adresse oder ein Buch und die SBN-Nummer
Oder jemand, ein Benutzer einer Bibliothek, was für Bücher
hat er denn ausgeliehen? In ganz vielen Fällen brauchen wir
so etwas und das ist dann so einfach wie so,
wie man, können wir uns vorstellen,
wie in der Tabelle mit zwei Spalten.
Und zwar, das eine ist der Schlüssel, ja,
das, wovon wir ausgehen.
Und das zweite ist der Wert, worauf verwiesen wird. Ja,
und in unserem Beispiel, wenn wir mit dem Text das machen,
dass wir die Wörter abbilden und ihre Häufigkeiten zählen.
So wird nebenbei bemerkt, Textanalyse gemacht mit statistischen Mitteln.
Diese statistischen Mittel sind sehr erfolgreich. Man kann nämlich,
es gibt so die Metapher,
wenn einem Autor in einem Text etwas besonders wichtig ist,
benutzt er dieses Wort mehrfach
Ja, also ein Wort, wo es um Software geht,
da wird das Wort Software ziemlich häufig drin vorkommen.
Und da kann ich das mit einem anderen Text vergleichen.
Welches Wort kommt denn da drin häufig vor? Und da
kann ich ermitteln, okay, das kommt da häufig vor.
Also das geht ein bisschen was anderes. Und tatsächlich sind
diese Verfahren sehr leistungsfähig. Es ist mittlerweile sogar so,
dass viele maschinellen Übersetzungsverfahren, die aus einer Sprache in die andere übersetzen,
gar nicht versuchen, den Text zu verstehen und sagen,
das ist Subjekt, das ist Objekt, das bezieht sich auf das,
das bezieht sich auf das, sondern die arbeiten ganz einfach mit Häufigkeiten.
Also das ist hier auch sowas, hier geht es um Worthäufigkeit,
wir machen hier keine Übersetzung, aber einfach nur,
die häufig das Wort und die Häufigkeit wäre dann so ein
String und Indit Shop Paarung.
Und wir können uns das vorstellen, wie auch wie so
eine Tabelle. Links stehen die ganzen Worte,
rechts stehen die Häufigkeiten
Okay, soweit, das gibt es auch noch,
das werden wir in der Übung nicht so im Detail haben,
aber es kommt ganz häufig vor,
man braucht es in der Praxis ganz häufig.
Und jetzt zu dem Begriff Sammlung, der stand ja ganz
am Anfang schon da. Sammlung ist sozusagen der Überbegriff über
all das, was wir gerade gemocht haben. Immer,
wenn wir gleichartige Objekte haben, sprechen wir von Sammlungen.
Der Begriff Engel, der englische Begriff Collection ist schon gefallen.
Also das ist ein Objekt, das Singe zusammenfasst.
Und die Sammlung, dass es vielleicht bemerkenswert ist,
selbst kann selbst wieder als ein Objekt behandelt werden
Eigentlich haben wir viele kleine Teile drin. Wir wissen schon
aus den vorangegangenen Folien, was sind Sachen mit gleichem Typ,
mit gleichem Wert. Und jetzt wollen wir diese Sachen,
die zusammenfassen und das selber ist auch wieder ein Objekt.
Ja, gut. Jetzt gibt es hier noch andere Begriffe
dafür, über die Sie vielleicht auch mal stolpern könnten.
Behälter, also Container, das ist letztlich kein anderes Wort dafür.
So, Kleinigkeit vom letzten Mal, da hatten wir den Begriff Referenzen.
Das sind also ein Verweis auf ein Element,
ich habe gar nicht das Element selbst.
In der Tat ist es hier so,
dass wir in dieser Collection drin nicht die Objekte selbst haben.
Wir haben dort nicht wirklich den String drin,
sondern wir haben nur den Verweis, das Training steht irgendwo anders.
Damit können wir die ganz einfach verwenden, prüfen, erzeugen, löschen.
Und ist auch fast egal, welcher Typ da drin ist,
weil wir haben ja nur den Verweis auf den Typ.
Aber das ist ein bisschen fortgeschrittenes Thema. Wir bleiben erst
mal dabei, Sammlungen sind Elemente vom selben Typ.
Jetzt sollten wir wieder fragen, wir wollen ja gleich mit Java
was machen damit. Was kann man damit tun? Ja,
und jetzt müssen wir schauen, was kann man,
es gibt ja die unterschiedlichen Arten,
ist die Frage,
gibt es
eine Reihenfolge
Und da können wir sagen, ja, entweder keine oder Benutzer definiert,
oder es gibt eine automatische Reihenfolge, das kann auch sein.
So, und dann kann das zweite Punkt, den wir auch schon hatten,
bei den Mengen, kein etwas mehrfach vorkommen, also Duplikate.
Ja, entweder sind sie zugelassen, ich kann etwas mehrfach haben oder nicht, dann gibt es das nicht. So,
und das gleich gegenübergestellt, Sachen,
die wir eben schon mal hatten, ja,
also hier, es gibt das Mehrfach,
es gibt das nicht mehrfach und jetzt hatten wir schon über die Liste gesprochen,
anfangs,
ja,
also die Reihenfolge ist da und dafür kann ich mehrfach
die Sachen haben und bei der Menge kann ich es nicht mehrfach haben,
es ist nur enthalten oder nicht und dafür habe ich
keine Reihenfolge
Zu. Ein paar Beispiele dazu. Ja,
ich könnte zum Beispiel sagen, ich habe so ein Spiel-Scrabble,
kennen sie vielleicht mit den Buchstaben da drin.
Mehrfach können die da drin sein und sie können auch nicht mehr drin sein,
Geld im Geldbeutel, ja. Bei einer Liste,
wenn sie die Musik irgendwie auf ihrem Abspielgerät ihrer Wahl gespeichert haben,
dann kommt es ihnen auf die Reihenfolge an.
Es darf auch mehrfach vorkommen. So, oder so eine
sortierte Liste, zum Beispiel, sie haben eine Wetteraufzeichnung.
Wie viele Geregen war in den letzten Wochen, in den letzten Monaten,
um vorherzusagen, wie viele Regen werden wir denn Weihnachten haben?
Von Schnee wollen wir ja bitte lieber nicht reden.
Ja, so, oder sie wollen sie wollen eine,
sie empfangen, erwarten ein Baby. Ja,
und das Baby soll einen Namen kriegen und da gibt es eine Liste von Wunschnamen.
Die wird dann irgendwie noch geordnet und dann wird die Hälfte rausgestrichen.
Hoffentlich sind sie dann so weit, wenn das Baby da ist,
dass sie dann auch einen Namen haben.
Ansonsten haben sie 14 Tage Zeit, sich das noch zu überlegen.
Gut, also das wäre eine Menge,
es bringt keinen Sinn in dieser Liste, Namen mehrfach zu haben.
Also für verschiedene Sachen, ach gut, wir haben noch Weihnachten,
da gibt es einen Wunschzettel, ist ganz klar,
das sollte geordnet sein, dass man also die wichtigsten Sachen oben hat.
Nicht, dass sie dann irgendwas bekommen, was zwar auf dem Zettel steht,
aber sie hätten was anderes viel lieber gehabt.
Ja, so das ist noch, ja,
und damit hier unten, damit das noch komplett wird,
nehmen wir hier für unten auch noch was.
Ja, auf die Sportfreunde kriegen auch noch was.
Also es gibt eine Tabelle mit Spielständen und die Reihenfolge
gespielt da natürlich eine Ordner,
eine Rolle
So, jetzt haben wir hier sechs verschiedene Kategorien gehabt.
Davon haben wir über zwei schon gesprochen und über dieses geordnete Menge.
Nein, wo waren wir denn drüber? Genau, über die,
über diese Paare, hatten wir ja auch schon gesprochen,
die Map, die kommt jetzt hier nicht so direkt vor.
Lassen Sie uns schauen, wie das aussieht in der Welt von Java.
Ijava ist das so, wir bekommen das mitgeliefert.
Das ist nicht in allen Programmiersprachen so,
das ist einer der großen Vorzüge von Java.
Die Bibliotheken, die sie mitbekommen, liefern wirklich viele Sachen,
die sie brauchen.
Das heißt, sie müssen
so etwas nicht
selbst schreiben
Sie können einfach darauf zugreifen, Sie müssen nicht mal genau wissen,
wie es funktioniert. Da kommen wir gleich zu dem Interface.
Ja, das ist die nächste Folge dann. Wir wissen,
was ich damit machen kann, so ein bisschen ähnlich,
wie wir es bis jetzt mit Text hatten und wie wir
es dann in Java uns anschauen werden.
Und das bekommen wir. Zum Beispiel gibt es hier
das Java Collections Framework. Framework ist ein Begriff,
der in der Informatikleiter auch ein bisschen inflationär benutzt wird.
Irgendwie ist alles ein Framework, Rahmenwerk auf Deutsch ist keine
gute Übersetzung. Also irgendwie ein Zusammenstellung von Sachen,
die einem in irgendeiner Form helfen
Und diese Collection sind halt alles, was mit den Sammlungen zu tun hat.
Die Klassen, die wir da brauchen, die Interfaces.
Und die helfen uns, das so weit zu benutzen,
dass wir eigentlich nichts mehr dazu entwickeln brauchen.
Wir können einfach da unsere persönlichen Weiterentwicklungen dranhängen.
Und wir schauen uns jetzt von diesen beiden Sachen,
von diesen davon erstmal an, dass List und das Z,
Z wird die Menge, List war die Liste.
Okay, fangen wir damit an, nochmal zu wiederholen.
Wie war denn das mit dem Interface
Das Interface war ja nur die Definition dessen,
was wir als Methode dort haben, als Operation haben.
Sie ändern sich letzte Woche, ja, das Interface,
da war die Definition, war ja nicht,
dass wir da noch dahinter geschweifte Klammer aufgeschweifte Klammer zu haben.
Also zum Beispiel hier hinter Seis müsste ich eigentlich,
wenn es eine Java-Methode wäre, geschweifte Klammer auf,
da kommt der Quelltext, was macht der wirklich, geschweifte Klammer zu.
Ja, das haben wir nicht. Tatsächlich haben wir hier
nur die Operation und die Angabe der Datentypen und natürlich, wie das Ding heißt. Ja,
das war das Interface und das Interface ist soweit,
was ein bisschen so, sah so ähnlich aus wie eine Klasse,
kann auch aber keine Objekte bilden,
sondern ist nur die Verpflichtung für jemanden anders,
ein tatsächlich diese ganzen Methoden auch zu implementieren.
Der Compiler wird das überwachen und wir,
sie vergessen das, dann gibt es eine Fehlermeldung.
Okay, also das Interface für Set liefert uns,
beschreibt uns alles, was wir mit Set machen können.
Und die haben wir tatsächlich dieses Prinzip des Information-Highting wieder.
Wir kriegen keine Informationen, wie wird denn die Seis berechnet?
Ja, oder wie ist denn die Suche bei Contains?
Da wird ja durchsucht irgendwie die Menge. Und wie das
genau gemacht wird, das kriegen wir gar nicht gesagt.
Und sie werden vielleicht sagen, ach,
ich möchte das aber gern wissen.
Nein,
wir wollen es gar nicht wissen
Weil wir uns nicht abhängig machen,
vor allem wenn wir es genau wissen würden,
würden dann irgendwelche Spezialitäten implementieren und dann ändert jemand die Basisklasse,
zum Beispiel zur Performance-Optimierung oder für verteilte Speicherung, ändert jemand, wie diese Klasse
Set jetzt intern arbeitet und da würde uns das nicht mehr funktionieren. Nein,
wir halten uns nur an dieses Interface und das hilft uns,
dass wir keine Änderungen mehr machen müssen, wenn sich hier drin was ändert.
Also wir schauen uns jetzt nach dem,
war doch ein bisschen Wiederholung zum Interface, was haben wir hier?
Beispiel, sei es, hatte ich eben schon gesagt,
die Zahl der Elemente, die da drin ist. Sie werden jetzt sagen,
sei es hat da was mit Größe zu tun,
SML XL oder in Amerika 6XL, wenn sie wollen,
ja, nein, für diese Collections ist es immer gleich,
mit sei es, das ist für jede dieser ganzen Collections,
wir hatten ja eben diese Tabelle hier, ja,
für jede dieser Collections ist,
sei es definiert als Anzahl der Elemente.
Also, das kann man sich durchaus merken gleich, die Zahl der Elemente.
Und das trifft für alle Collections zu, nicht nur für Set.
Wenn ich suchen will, dann heißt das nicht etwas Search,
sondern heißt, ist das Enthalten Contains. Und zwar,
bei dem Set ist es ja ganz klar,
da gab es ja nur,
es ist enthalten oder es ist nicht enthalten,
weil keine Reihenfolge dabei war
Und für das Einfügen in Fernen gab es hier Ad und Remove und dann noch Clear.
So, das hier unten hatten wir schon.
Kleiner Hinweis, hier steht so in Etrin.
Wer das genau angeguckt hat, der denkt sich,
hä, was ist denn das für ein E?
Ja, Sie kennen vielleicht das C im Kringel, das heißt Copyright.
Nein, das ist es nicht. Hier ist es
ein Platzhalter, weil wir können unterschiedliche Elemente hier machen.
Wir können also so eine Collection für einen bestimmten Datentyp
für einen Elementtyp machen. Sie können eine Collection machen,
wo sie selbst Strings haben. Sie können eine Collection haben,
wo sie Kleidkommazahlen drin haben oder sie können eine Collection haben,
wo sie Objekte vom Typ Buch drin haben.
Ja, also sie können auch ihre eigenen definieren.
Also deswegen wäre dieses Set, na, meine Mauer ist wieder,
das Set kann man hier anpassen für einen speziellen Typ, für einen speziellen Elementtyp.
Schauen wir uns das mal an, wie das in Java aussieht.
Wir nehmen wieder das Beispiel mit den Babynamen, ja,
zunächst definieren wir, dass wir ein Set brauchen von Strings.
Ganz klar, Babynamen sind, also Namen sind,
bestehen aus Charakters, aus Zeichen und wir nehmen da ein Set,
jetzt geben wir auch den Variablen-Namen gleich Babynamen.
So, und jetzt schauen wir hier, jetzt erzeugen wir das Ding.
Und jetzt wundern wir uns, was ist denn das hier?
Hashset. Zu Hash werden wir gleich nochmal kommen.
Hash ist eine verschlüsselte Form, wenn sie so wollen,
so ähnlich wie so ein Hashcode, kennen sie auch bei Verschlüsselungsverfahren.
Eine Zahl, die dafür steht, was der Inhalt ist.
Wir kommen gleich nochmal dazu. Aber das entlassen wir einfach erstmal so stehen,
dass man hier eine Klasse nimmt, die Hashset heißt als Basisklasse dafür,
um ein Objekt zu erzeugen.
Und jetzt weise ich hier Werte zu, ich sammle Werte,
zum Beispiel erst sage ich, gebe ich einen Zähler,
wie viel Stück habe ich da schon drin und dann füge ich,
welche füge ich Werte hinzu, in dem Fall hier mal diese vier,
vielleicht hat die junge Familie schon eine Ahnung,
dass das ein Mädchen wird.
Und wenn ich dann wissen will, wie viel das sind,
kann ich mir das geben lassen. Ich kann einfach,
Babynamen ist jetzt das Objekt Collections. Wie hatte ich vorher gesagt,
drei Folien vorher, eine Collection selber ist wie ein Objekt anzusprechen,
also hier, das war,
hier oben haben wir mit dem Namen Babynamen diese Collection erzeugt,
dieses Set Und hier frage ich dieses Set,
liebe Set, was ist denn deine Seiss?
Also wie viele Elemente hast du denn enthalten?
Und da wird was zurückkommen und jetzt ein kleiner Hinweis,
ja, hier kommt nicht vier zurück, sondern drei.
Und zwar deswegen, weil wir haben hier gemogelt,
wir haben die Anna ein zweites Mal hinzugefügt.
Und sie wissen ja von vorhergehenden Folien schon,
im Set kann ich alles nur einmal drin haben.
Und wenn sie das noch zehnmal hinzufügen, wird trotzdem Anna nur einmal enthalten sein.
Wenn sie es entfernen, ist es nicht mehr enthalten,
wenn sie es hinzufügen, ist es enthalten.
Aber egal wie oft sie es hinzufügen. Also das
kümmert sich sozusagen beim Hinzufügen, ohne dass wir wissen,
wie es genau funktioniert, darum,
dass ein Wert nicht zweimal enthalten ist
So, und dann kann ich zum Beispiel fragen,
wenn der Wert, wenn der Julia,
der Name Julia drin enthalten ist, dann passiert irgendwas,
in dem Fall hier, wenn das nicht enthalten ist,
dass der Verneinungsoperator, dann füge ich Julia noch hinzu.
Und wenn ich mir überlege, Annika, doch nicht,
dann nehme ich das wieder raus oder ich will
die ganze Liste löschen, dann geht das auch.
Wir sollten das jedenfalls nicht so machen,
das ist noch ein anderer Punkt
Okay, wir haben jetzt gerade gesehen, wir müssen uns hier darum kümmern,
dass etwas, ob etwas identisch ist oder nicht.
Ja, also die Anna, die war schon mal dabei.
Also wir können uns vorstellen, was hier intern passiert.
Da wird geprüft, ist denn Anna schon da?
Und tatsächlich spielt hier die Frage von Vergleich eine Rolle.
Und das ist ein Punkt, den sollten wir,
das bitte wieder zu merken, das brauchen wir ganz häufig.
Der Unterschied zwischen Gleichheit und Identität. Es ist nicht das Gleiche.
Sie wissen das vielleicht in der deutschen Sprache, derselbe und dergleiche.
Ja, darauf möchte ich jetzt nicht rumreiten.
Es gibt umso nette Mitmenschen, die einen dann korrigieren.
Das ist nicht derselbe, sondern dergleiche. Hier geht es
jetzt um den Unterschied zwischen Gleichheit und Identität. Ja,
ich habe hier das mal als Beispiel gebracht, zwei gleiche Werte.
Zum Beispiel 13 Grad, gestern und 13 Grad im Januar
, bedeutet noch lange nicht, dass das identisch ist.
Es sind nur gleiche Werte. Ja,
also hier in dem Fall zwei Personen, ja,
die können durchaus den gleichen Namen haben und sogar das gleiche Geburtsdatum.
Aber das bedeutet noch lange nicht, dass es sich um
die gleiche Person handelt. Ich hoffe mal,
Ihnen passiert nicht so was Schlimmes mal, dass jemand,
der strafrechtlich verfolgt wird,
genauso heißt und im gleichen Geburtsdatum hat wie Sie und auf einmal die Polizei freut sich, jetzt habe ich ihn.
Und dann wupp, sind Sie nicht mehr atmen Sie gesiebte Luft,
schwedische Gardinen, ja, das wäre irgendwie dumm.
Wenn das nur, da müssen Sie dann nachweisen,
nein, ich bin nicht identisch.
Ich bin nur zufällig gleichbezüglich Namen und Geburtsdatum.
Es wird ja hoffentlich noch Gründe geben,
dass Sie dann wieder da rauskommen aus der Situation.
Ja, also das wäre die Gleichheit. Identität bedeutet,
im Objektorientierten, die Referenzen verweisen tatsächlich auf das gleiche Objekt.
Ja, in dem Fall hier eine Person von mir aus Teammitglied
oder hier eine Familienbeziehung, das verweist beides auf die gleiche Person.
Ja, und dann geht es wirklich um die Identität dieser Person
Die beiden Sachen hängen miteinander zusammen. Also wenn jemand
wirklich identisch ist, dann sind die Werte auch gleich.
Also hier, dieses Mitglied vom Team K hat das gleiche Name und
gleiche Geburtsdatum und hier auch gleicher Name und gleich Geburtsdatum.
Hier oben an dem Beispiel sehen wir, umgekehrt gilt das bitte nicht.
Soweit zum Thema Gleich und nicht gleich. Das müssen wir
aber irgendwie in einer Form unterbringen, dass die Objekte,
mit denen wir umgehen und die Collections selbst als Objekte,
dass sie das können.
Und tatsächlich gibt es dafür eine Operation,
die uns hilft, das zu ermitteln.
Und diese Imperation heißt Equals
Eagles ist etwas, das ist in der Wurzel aller Objekte,
in dem Überobjekt aller Objekte in Java formuliert,
dieses Überobjekt heißt, die Klasse heißt, wie man vermuten sollte,
für Objektorientiert, wie Wurzel allen Gutens,
ist ein Objekt, Objekt steht ja für gut,
Objektorientiert ist super, ja, und wir haben,
das steht in der Klasse Object und die gehört zum Paket Language,
wo die Basissachen drin sind und steht unter Java Lang Object zu finden,
also das ist die Paketbezeichnung und zu dieser Klasse Objekt,
die die Wurzel von allem ist,
hören unter anderem dann diese Methode Equals.
Wir kommen gleich noch zu Hash Code und Two String und die Eagles-Methode,
die liefert wieder, liefert ein Bulienresultat wieder, wahr oder falsch,
ob ein anderes Objekt das Gleiche ist wie ich.
Also ich kann dort hier Nathalie Winter vergleichen, bist du
die gleiche wie die Nathalie Winter? Und dann wird das
Objekt mit seiner Equals-Methode, wird dann zurück antworten Bulien,
True oder False. True im Falle von Identität und False
im Fall von nicht gleich, oder wie? Ja,
und hier können wir fragen, ist es gleich mit dem Und ja,
sehen wir jetzt hier unten, wenn wir die Frage stellen,
Identität oder Gleichheit, hier geht es um Gleichheit.
Ja, also die Gleichheit ist standardmäßig, wird die Identität verglichen.
Ja, und wir gucken jetzt, müssen wir jetzt mal
gucken, was ist denn damit alles gemeint?
Ja, wir vergleichen die Referenzen und damit ist es tatsächlich
dieser Wert der Identität. So, wenn wir jetzt,
ich hatte schon gesagt, das ist eine Basisdefinition,
die mit mit der Sprache Java definiert wird, die trifft für alle Objekte zu.
Da gibt es noch drei weitere Sachen, die sollte ich,
wenn ich, dass ich sie hier auf der Folie habe, wenigstens kurz erläutern.
Vielleicht nehmen wir erstmal Two String, das ist relativ einfach.
Wenn wir so ein Objekt in irgendeiner Form darstellen wollen,
zum Beispiel in Form einer Fehlermeldung,
mit dem und dem Objekt gibt es ein Problem,
dann müssen wir dieses Objekt ja irgendwie darstellen.
Da muss es einen Namen bekommen. Ja,
und da könnte man natürlich sagen, eine Intellege schauen,
aber es gibt vielleicht ganz viele Intacher, das würde uns nicht reichen.
Oder wir könnten sagen, ja, eins dringen.
Das würde uns auch nicht reichen. Sollten wir vielleicht noch
was mehr geben und was dann zurückgegeben wird,
im Falle, braucht man ein String von diesem Objekt,
das sagt die Methode to string.
Und tatsächlich soll jedes Objekt, jeder Typ, sollte diese Methode kennen.
Jeder Typ sollte sagen, ja, wenn ich mal gefragt werde,
wer bist denn du, dann gebe ich das und das zurück.
Zum Beispiel beim String gibt man zurück den Inhalt des Drings.
Bei der Collection gibt man vielleicht die zurück, die Werte,
die ersten fünf Werte und dann pünktchen Pünktchen oder wie auch immer.
Also ich kann das festlegen. Das ist der to string und die Methode Hashcode,
die gibt eine Zahl zurück, eine binäre Zahl,
die dafür steht, die Identität ermitteln zu können.
Also weil zwei Sachen mit gleichem Hashcode sagen auch,
das sind identische Elemente. Und tatsächlich ist dieser Hashcourt,
der kommt dann gleich nochmal vor. Ja,
wenn wir ein Ereignisobjekt schaffen, etwas neu bauen,
dann muss das Equals natürlich anders erwettelt werden als bei einem anderen Objekt.
Das Equals ist für jede Sache anders. Wir müssen diese
Gleichheit festlegen. Und deswegen müssen wir manchmal dieses Equals,
da reicht uns der Standard, den wir bekommen von Object eben nicht,
wir müssen das neu machen.
Und das nennt sich etwas Neumachen, nennt sich Rehdefinition.
Man könnte auch sagen, einfach nur, ich überschreibe das,
was ich als Standard vorgegeben bekomme. Das heißt,
hier schreiben Sie sich ruhig dran, überschreiben des Standards,
das ist das Gleiche,
was wir hier mit Reh definieren meinen
Wichtig ist, wir brauchen dieses Equals,
zum Beispiel bei einer Sammlung, müssen wir alle Elemente vergleichen.
Sind die denn drin? Um das zu vergleichen.
Soweit, das Equals brauchen wir für die Gleichheit.
Wir gehen mal weiter. Wir hatten bis jetzt die Klasse
. Set beziehungsweise das Interface-Set. Und jetzt schauen wir uns
nach an, wie das mit dieser geordneten Reihe ist.
Die Liste waren ja die geordnete Reihe. Auch hier haben wir solche Sachen,
also wieder hier gesehen hier oben, es handelt sich um ein Interface.
Das Interface ist von Collection abhängig, abgeleitet mit Extense.
Und wir brauchen Die ganzen Operationen, die wir in Set
schon hatten, die gehören hier auch dazu.
Das heißt, wir finden, sei es, wir finden Contains,
das, was wir vorher alles schon mal hatten.
Und zusätzlich haben wir Sachen, die uns helfen, in der Reihenfolge zurechtzukommen.
Diese Reihenfolge wird durch eine Nummer angegeben, die Platznummer.
Und diese Platznummer steckt in Index. Jetzt, wenn sie sagen,
oh, hier ist doch wieder dieses komische E,
tatsächlich haben wir hier oben auch die Möglichkeit,
eine Liste für verschiedene Typen einzugeben.
Wir können eine Liste für Strings angeben, wir können eine Liste für Kleidkommerzahlen angeben,
für Indexer angeben, was auch immer wir wollen.
Und hier wird der Index mitgeholt, wird der Index für ein bestimmtes Element geschrieben.
Ich kann etwas hinzufügen, einer bestimmten Stelle, ja,
also der Zugriff, ich hole etwas,
dass ich dort etwas verändere oder dass ich in Ermittler,
in welchem Element ist denn was?
Das hier tatsächlich ist eine Suchoperation, ja,
ich suche zum Beispiel den Namen Klara in meiner geordneten Liste,
wenn ich denn eine geordnete Liste hätte, ja,
wann wieder Hofpausenaufsicht ist, zum Beispiel könnte ich sagen,
okay,
Klara ist an fünfter Position dran,
das wäre hier Index offen,
da müsste hier dann Klara angeben
Wir schauen uns das in Java an, und zwar wieder dieses Aufsichtsbeispiel.
Wir erzeugen diese Aufsichtsliste und wir nehmen hier eine Liste,
die heißt jetzt Linkedlist. Wir übergehen das einfach,
bitte akzeptieren Sie einfach, das Linkedlist hier,
ein passendes Beispiel ist, da gibt es in den Collection-Klassen ganz viele.
Wir nehmen jetzt Linkedlist und statt dem E, was wir vorhin hatten,
wir wollen uns jetzt um den Typ String bemühen,
weil String, wir wollen ja für den Namen haben,
und da machen wir diese Aufsichtsliste, wir sehen hier,
wir fangen an, damit, dass wir die erstmal erzeugen,
ja, also vom Interface-Typ List Erzeugen wir die.
Und das Objekt, was wir tatsächlich nehmen, ist,
stammt von der Klasse Linklist und bekommt den Namen Aufsichtsliste.
So, dann fügen wir was hinzu, ganz lustig,
1, 2, 3, 4,
5. Und jetzt merken Sie hier, wir fügen den Peter zweimal ein.
Das entspricht dem Bild, was wir vorhin hatten.
Ich gehe mal zurück und zeige Ihnen nochmal das Bildchen,
was wir hier hatten. Wo war denn das? Hier
unten, ja. Also nein, noch eins weiter zurück.
Zurück, zurück, zurück, zurück. Ja,
also wir hatten hier, hier genau, so war das,
sah das vorhin aus.
Ja, wir hatten den Peter an der, an dieser Position.
Also das jetzt in Java sieht so aus.
Nein, wo bin ich denn jetzt gelandet
Genau, hier war ich. Da hatte ich mich 26, war das.
Okay, also hier bin ich gelandet und füge Peter,
Paul, Mary, Peter, Jan ein.
Es sind Duplikate erlaubt. Deswegen kommt,
wenn ich nach der Länge frage, die 5 raus.
Und wenn ich jetzt sagen möchte, Jan soll jetzt
eine andere Position, dann verschiebe ich den Rest.
Das, was wir vorhin in der netten Animation gesehen hatten.
Ich füge hier vorne was ein und dann verschiebt sich der Rest um eine Position weiter.
Das hat halt damit zu tun, dass intern,
die nicht mit Fest mit ihrer Position behandelt werden,
sondern sie werden als Kette behandelt
Und wenn Sie sich vorstellen, eine Fahrradkette,
da kann ich ja auch, wenn ich da eine Lücke habe,
so ein Kettenschloss reinmachen und dann rutschen die anderen einfach eins weiter.
Es wird deswegen nichts rausgenommen. So ähnlich ist das ja
auch. Können wir uns das gut so vorstellen.
So, und ich kann natürlich hier auch jemanden wieder rausnehmen.
Zum Beispiel an welcher Stelle kann ich hier noch angeben?
So, damit haben wir eine lange Kette.
Damit haben wir eine Menge, also wir können hier
mit Mengen und mit diesen Listen
jetzt umgehen
Jetzt können wir mal überlegen, wenn ich das durchgehen will.
Es sind ja immer die gleichen Elemente. Da möchte ich
mit allen das Gleiche machen. Und da können wir tatsächlich
uns wieder zu Pass, dass wir im Computer sinnlose,
einfache Operationen superschnell immer wieder machen können.
Und dafür wollen ja das benutzen. Das ist die
größte Stärke der Computer. Sie sind nicht besonders schlau,
aber schnell. Und das schnell kriegen wir dadurch hin,
dass wir die Sachen immer wieder machen. Und das ist
die Iteration. Iteration heißt ja nichts weiter als wiederhole das Ganze.
Und wir haben eine Schleife, diese vor Each-Schleife.
Und die sieht so aus, dass ich vor,
dann gebe ich an, worüber das gemacht wird.
Und dann mache ich damit irgendetwas
In dem Fall zum Beispiel hier die Liste ausgeben,
zum Beispiel irgendeine Liste kann das sein,
die zum Beispiel in der Liste von Personen,
wir hatten eben eine Liste von Strings, hier nächste von Personen.
Und was ich hier mache, ich greife auf ein Element aus
der Personenliste zu und füge das und mache damit eine Operation,
nämlich P., gib Name.
Und dieses Gib Name wird dann also Name, Vorname,
was auch immer, zurückgeben. Und was ich hier mache,
ist, diese Zeile zwischen den geschweiften Klammern steht unterhalb vor,
die wird so viel ausgeführt,
wie dort Elemente drin sind
Ich brauche mich nicht mehr, und das ist jetzt
das Besondere, das kommt mit der Liste.
Das kommt damit, dass wir die Personenliste so definiert haben
in Java, das ist schon alles da.
Wir müssen uns nicht darum kümmern. Ja,
ich muss erst ermitteln, es sind sieben Elemente drin.
Und dann muss ich es genau siebenmal durchführen. Nein,
ich mache das einfach nur für diese Liste und mache damit,
und da kommt genau so viel ausgeführt, wie Elemente drin sind.
Mehr brauchen wir da nicht. Okay,
das war jetzt Einschleife, nämlich diese Vorschleife.
Und die können wir verwenden, wenn wir solche Sammlungen haben.
Und dann können wir natürlich auch noch die übliche nehmen,
wo wir wirklich mit der Anzahl arbeiten, wo wir wirklich sagen,
ja, Ich will das siebenmal haben, ich will das fünfmal haben.
Das können wir, die bleibt die natürlich auch noch.
Aber dieser andere war einfach eleganter, weil sie brauchen sich
nicht darum zu kümmern. Selbst der Fall,
selbst der Fall, dass diese, ich gehe nochmal zurück,
selbst der Fall, dass diese Liste leer ist,
würde funktionieren, weil dann wird das nämlich gar nicht ausgeführt.
Ja, das ist eigentlich der Punkt, das ist das echt,
das spart einem Fehler, weil ich weiß nicht,
wer von Ihnen schon da Fehler gemacht hat.
Typischerweise gehört das zu den häufigsten Fehlern, was bei so Bedingungen passiert. Ja,
so eine logische Bedingung ist es schön,
das erste ist das letzte Element in so einer Schleife,
da machen die Leute ganz viel Fehler und diese Fehler sind hier mit dieser eleganten Form der Liste,
wenn ich die Liste gleich als Iterator verwende,
gar nicht möglich
Okay, also es gibt die eine,
es gibt die andere Schleife und es gibt natürlich auch noch Wireschleifen,
die man machen kann, wenn man noch nicht weiß,
wie viele Elemente es sind.
Mit dem Set weiß ich ja ganz genau, wie viele
Elemente es sind. Mit der Liste weiß ich auch,
weil ich habe ja die Set und die Liste.
Manchmal gibt es aber auch Fälle, wo sie das nicht vorher wissen.
Zum Beispiel, sie bekommen Datenpakete gezielt, sendet übers Netzwerk,
da wissen sie von Anfang nicht bei jedem Protokoll,
wie viel danach kommen.
Das sagen sie, okay, es gibt dann so ein Endezeichen.
Und wenn noch eins kommt und es ist nicht das Endezeichen,
dann mache ich weiter, weiter, weiter.
Und das wäre der Punkt, wo wir hier
die Weileschleife verwenden können
Soweit zu den Sammlungen. Wir haben ganz,
ganz viele verschiedene behandelt und wir müssen jetzt entscheiden,
welche nehmen wir denn? Sie haben eben schon gesehen,
ich habe so ein bisschen gemogelt, wir haben plötzlich die Linklist gehabt,
wie viel gibt es da, mögen Sie fragen?
Brauche ich da so ganz viele? Zunächst müssten wir uns
klar sein, was müssen wir damit alles für Operationen machen?
Was ist das, was wir einen Umgang haben wollen?
Wir müssen zunächst erstmal wissen, welches Interface wir nehmen.
Und das hängt natürlich davon ab, was wir damit machen wollen.
Kommt es uns auf die Plikate an,
kommt es uns auf die Reihenfolge an, wie auch immer.
Und nachdem wir das entschieden haben, wissen wir erstmal,
wie wir suchen müssen, welcher Teil da in dieser ganzen Collections für uns zufriedenstellend arbeiten wird.
Und dann wählen wir eine Implementierung. Zum Beispiel für List
gibt es zwei. Im Yava Collection Framework, das war
JCF, wer haben die Arraylist? Arraylist heißt also,
ich habe feste Plätze und ich habe die Linklist,
wo das variabel ist.
Und für Set gibt es auch zwei. Wir hatten vorhin
schon mal das Hashset und da gibt es noch ein Treeset.
Der Unterschied für uns als jemand,
der das benutzen möchte,
worin besteht der denn
Der zeigt sich erstmal nicht, weil wir haben über
das Interface festgelegt, sie sollen diese Operationen verstehen.
Sie sollen diese Operationen aufweisen. Und da das das
gleiche Interface ist, unterscheiden die sich nicht.
Tatsächlich ist es Hashset und Triset, hat erstmal die gleichen Operationen.
Nur wenn wir dann, wenn es ums Zeitverhalten geht,
bei ganz vielen großen Datenmengen, dann spielt es eine Rolle.
Ja, also das müssen wir uns bitte merken.
Wir finden das nah dran. So, damit sind wir
auch schon am Schluss. Ich überklebe,
ich gebe gleich an Sandra, die uns das noch zeigen wird,
wie das in Java aussieht.
Wir machen noch
eine kurze Zusammenfassung
Wir haben Sammlungen festgelernt, kennengelernt,
die ganz verschiedene Arten haben, aber eins ist allen gleich.
Sie sind gleichartige Mengen drin. Gleichartige Elemente drin. So,
dann hatten wir zwei wesentliche Unterschiede, zwei wesentliche Gruppen.
Das eine waren die Listen, diese Listen hatten was mit
der Reihenfolge zu tun und das andere waren Mengen,
die das Enthaltensein hatten, weil es keine Duplikate gab.
So, und das Ganze haben wir als Interfaces benutzt,
damit wir flexibel wählen können, was ist die schnellste Implementierung?
Wir sind jetzt nicht so weit gegangen, dass wir gesagt haben,
was ist jetzt der Unterschied zwischen Linked List Und Tweelist,
oder Hashtag und Treeset, da sind wir nicht drauf eingegangen,
weil es das ab diesem jetzten Zeitpunkt noch nicht interessiert.
Sie bekommen das zu Anfang alles vorgegeben.
Wenn Sie es doch schon mal wissen wollen,
schauen Sie einfach in die Hilfe von Java oder in die Java-Bücher,
dann finden Sie das sehr gut.
So, damit würde ich gerne dich übergeben, Sandra.
Vielen Dank, soweit. Ich hoffe, Sie kommen damit
gut zurecht. Und wir schauen uns das jetzt. Wir lassen
uns das gerne zeigen, wie das in Java aussieht.
Ja, mach mal
So, Test, Test, Test, alles gut.
Alles klar. Gut. Ja, ich bin nicht Fred,
wie das schon mal aufgefallen ist. Mann,
ihr seid ganz schön viele, das ist wirklich beeindruckend.
Ich war noch nie in so einem großen Raum,
zumindest nicht hier vorne
Genau, ich vertrete heute Fried, der ist leider krank
und dann werde ich, kann man das sehen, jo.
Werde ich mit euch dann heute live programmieren, also so wie Fried das immer macht.
Ich versuche es zumindest. So, wir haben hier ein Projekt,
das kommt euch wahrscheinlich ein bisschen bekannt vor,
bei Blatt 9 hatten wir auch schon so einen Dateiverarbeiter mit hier dieses Interface,
Dateiverarbeiter und da hatten wir unterschiedliche Implementierungen,
da gab es irgendwie diesen Kurzauflister,
den Langauflister und dann solltet ihr noch einen Textdateiauflister machen.
So, dann haben wir hier noch diesen Verzeichniswanderer,
der in irgendeiner Weise diesen Dateiverarbeiter benutzt,
wir können ja mal hier so raufklicken Gut,
und was gibt es da?
Der bietet uns eine verarbeitete Operation an. Was können wir
damit machen? Wir können da einen Pfeil reinstecken.
Und der Verzeichniswanderer benutzt das in irgendeiner Weise. Können wir
auch mal reinschauen. Der Verzeichniswanderer, gut. So,
ich mache das mal größer. Der hat hier zwei Exemplarvariablen,
wo wir einmal das Startverzeichnis speichern, ist vom Typ File,
Files, so eine, ja, interne Repräsentation von einer Datei,
so ein abstrakter Datentyp sozusagen.
Und dann können wir da wunderbare Sachen mitmachen. Wir können prüfen,
ist es nur read only oder wir können den Namen abfragen,
den absoluten Fahrt abfragen
Und dann speichern wir uns hier als zweite Variablen den Dateiverarbeiter.
Und wie wir hier sehen, benutzen wir hier nur das Interface.
Wir benutzen keine konkrete Implementierung davon. Das heißt,
hier kann eine Referenz stehen, auf einen Dateiverarbeiter.
Wir wissen halt noch nicht, was dynamisch, also was zur Laufzeit passiert.
Was gibt es denn noch? So einen Konstruktor,
der geht mir irgendwie an, wo soll ich denn hier suchen?
Also, dass es das Aktuelle gibt, das aktuelle Verzeichnis an.
Also, dass er dann, wenn wir dann das reinstecken,
wenn wir das aufrufen, gib mir doch einfach mal alle Dateien,
die in dem aktuellen Verzeichnis sind.
Das wäre dann in dem Fall von diesem Bluejay-Projekt hier
Kann man, glaube ich, auch noch andere Sachen angeben.
Was ist denn hier noch interessant? Wir haben aber
diese öffentliche Methode Start und die ruft dieses Untersuche auf,
das können wir uns ja einmal mal angucken.
Also wir geben ein Verzeichnis rein,
ein Startverzeichnis und da lassen wir uns alle Dateien ausgeben.
So und die wären auch in so einer Art Sammlung gespeichert,
das sieht hier so ein bisschen komisch aus mit diesen Ecken mit eckigen Klammern.
Ist auch so was wie eine Sammlung, muss uns jetzt nicht weiter interessieren.
Es kann sein, dass wir da irgendwie nahe zurückbekommen,
deshalb fangen wir das hier auf. So und guck mal
, das haben wir schon mal gesehen in der Vorlesung.
Hier gibt es so eine erweiterte Vorschleife, was macht die?
Wir gucken uns die Sammlung Files an und da stecken ja
Elemente von Typ Pfeil drin. So. Und dann wurde ja gesagt,
dann brauchen wir noch so eine Variablen-Benennung.
Dann können wir ja noch so weitere Sachen aufrufen.
Also ist sie versteckt, kann man drauf lesen und so
weiter und so fort. Genau. Und dann wird abgefragt,
ist es nun ein Directory oder ist es ein Pfeil?
Und in dem Fall, wenn es ein Directory ist,
rufen wir Untersuche auf. Was ist denn dieses Untersuche?
Da befinden wir uns genau drin. Das heißt,
wir machen ja einen rekursiven Aufruf und suchen so lange
den Verzeichnisbaum, bis wir halt Dateien gefunden haben.
Und die können wir dann weiterverarbeiten. Hier in dem Fall
wird jetzt dieser Dateiverarbeiter aufgerufen
Aber wir benutzen einfach nur diese verarbeite Methode oder Operation,
übergeben das Pfeil. Aber was dann da irgendwie gemacht wird,
ist dem Verzeichniswanderer total egal. So, kleiner Einblick nochmal
in das Projekt. Vielleicht hat sich das der ein oder
andere in der Übung ja schon mal angeschaut. So,
dann gucken wir uns mal die eigentlich interessante Klasse an.
Das ist nämlich die Dateiliste. Wie sieht denn das aus
? Wir haben hier einmal so eine Exemplarvariable und einen Konstruktor
und dann haben wir hier nur noch vier Methoden
So, dann gucken wir uns mal die Exemplarvariable an.
Die heißt einmal Dateien und dann sehen wir hier sowas komisches.
Das haben wir in der Vorlesung auch gerade gesehen,
aber ich wiederhole das nochmal.
Was machen wir hier? Wir definieren uns eine Liste,
die Elemente vom Typ Pfeil enthalten kann.
Also dieses Pfeil, was wir eben im Verzeichniswanderer gesehen haben.
Dieser abstrakte Datentyp, der eine Datei repräsentiert aus unserem Dateisystem.
Das heißt, Dateien darf auf Objekte zeigen,
die Listen sind und entsprechend auch Elemente vom Typ Pfeil enthalten
Das ist doch schon mal schön. So. Und hier ist
diese verarbeite Methode, die durch das Interface,
wie heißt das nochmal, Dateiverarbeiter vorgegeben ist.
Und die wollen wir jetzt mal implementieren,
was sagt uns denn die Methode hier, der Schnittstellenkommentar,
der sagt uns, Fügel, die übergebende Datei zu der Teilliste hinzu.
Hat da jemand eine Idee, wie man das machen könnte?
Ja? Genau. Also der Vorschlag war hier,
wir müssen erstmal hier unsere Liste ansprechen,
dann können wir hinzufügen mit Ed und dann machen wir hier
Datei rein
So, wenn man jetzt nicht so weiß,
wir haben jetzt zwar schon so eine kleine Übersicht bekommen mit den Operationen,
die es gibt, aber man denkt so, ja,
ich habe jetzt eine Liste,
was gibt es denn jetzt für Operationen?
Ich bin zu Fall, um bei Google nachzugucken,
dann kann man hier so Steuerung, ja,
kann man Steuerung und Leertaste drücken, für die,
die das noch nicht kennen?
Und dann kann man sich hier so ein bisschen durchklicken,
was gibt es denn hier so? Und dann kann man hier sehen,
ah, es gibt ein Ad,
was wir eben gerade benutzt haben,
dann gibt es noch ein Ad mit einem Intager,
weil ja Listen irgendwie so eine Reihenfolge auch definieren
Und wir Positionen für unsere Elemente angeben können,
können wir dann auch einen Pfeil an einer bestimmten Position einfügen.
Sowas gibt es hier noch, at all.
Dann können wir wirklich so richtig Listen sogar noch übergeben,
also eine ganze Liste von Elementen.
Aber wir benutzen jetzt mal das Ad. So,
übersetzen wir, das Übersetzen funktioniert schon mal, probieren wir
das mal aus. So, wie war es nochmal?
Wir erzeugen uns einen neuen Verzeichniswanderer. So eine Dateiliste,
kann ich hier Start auswählen,
tu die Dateiliste rein
Mensch, was sagte mir hier? Eine Night-Pointer-Acception. Die
ist uns ja schon mal irgendwie über den Weg gelaufen.
Hat jemand eine Idee? Warum hier eine Night-Pointer-Acception geschmissen wird?
Ja, da hinten. Genau, richtig. Wir haben
noch keine Liste erstellt. Wo kann ich denn diese Liste
jetzt am besten erstellen? Ja. Wie bitte? Genau
, einen Konstruktor. Dann mache ich das einfach mal.
Ich kompiliere das mal. Mensch, Fehler.
Warum bekomme ich einen Fehler? Der sagt irgendwie,
er kann das nicht instanziieren. Naja gut,
weil wir wissen ja, List ist ja ein Interface.
Haben wir eben gerade in der Vorlesung gelernt.
Das heißt, und wir haben ja viele mögliche Implementierungen,
die uns dieses Java Collection Framework anbietet.
Und deshalb können wir jetzt zum Beispiel Arry List nehmen.
So. Genau, funktioniert. So, das müssen wir jetzt nicht
nochmal ausprobieren. Gut. Wir können uns jetzt mal Schreibe
auf die Konsole angucken, das ist vielleicht nochmal ganz spannend.
Dann sehen wir nämlich auch was, wenn wir den Datei,
wenn wir diesen Verzeichniswanderer mal aufrufen, können wir mal was sehen.
Genau, was steht hier? Schreibt alle Einträge auf die
Konsole zusammen mit ihrem Index. Das mit dem Index,
das ignorieren wir jetzt erstmal. Es ist mir jetzt erstmal egal,
ich möchte alle Elemente, die in Dateien drinstehen,
also in dieser Liste, die möchte ich jetzt nacheinander hinschreiben.
Wie könnte man das denn machen
Also du meinst, sowas system.out. Was kann ich denn
da reinschreiben jetzt? Ja, das mit den Lernens dringen,
das brauchen wir nicht. Das macht einen automatisch. Es
ist schon das, was wir haben wollen. Genau,
in dem Fall wird da einfach nur, was weiß ich,
was da rauskommt, wahrscheinlich irgendeine komische Bezeichnung für diese Referenzvariable hier,
was Java intern ist, keine Ahnung.
Also wir würden aber nicht diese Liste rausgeben.
Dann machen wir mal diese For-Each-Schleife. Wie war es nochmal?
Schreibt das mal abstrakt hin. Irgendwie muss hier dieser Element-Typ hin,
weil wir müssen ja wissen, auf was für einen Element-Typen wir zugreifen,
dann irgendein Name für diesen Element-Typen und die Sammlung.
So noch geschweifte Klammern. Genau, was wäre die Sammlung?
Wir können das ja jetzt mal von rechts nach links ersetzen.
Was wäre denn die Sammlung? Okay,
das wäre in dem Fall, ich löse das mal
auf Dateien
So, und wir wissen ja jetzt auch, welcher Elementtyp Dateien hält.
Also was für Elementen, was für ein Typ diese Elemente haben.
Was ist das? Genau, ja. Pfeil, genau.
Richtig. So, jetzt können wir hier irgendwie noch einen
beliebigen Namen. Datei bietet sich vielleicht an. So,
und jetzt können wir auch unser System Outprint LN benutzen.
Natürlich dürfen wir jetzt nicht das abhängig von Dateien machen,
dann sind wir immer noch nicht weiter.
Wir können ja zum Beispiel Datei, was haben wir denn hier so?
Da gibt es auch irgendwie Get Name oder sowas.
Das ist doch
ganz nett
Was? Das ist, ja, das ist fancy, ne?
Finde ich auch. So. Also immer, wenn du,
na, wenn du hier diese Punktnotation machst und Steuerung,
Leertaste machst, bekommst du diese Liste.
Bitteschön. Genau, was hatte ich denn jetzt gemacht?
Get chname. Gut. So. Können wir ja mal ausführen
, dann sehen wir ja mal vielleicht was.
Kompilieren, funktioniert.
Der Teilliste
Und dann können wir jetzt an der Teilliste,
schreibe auf Konsole aufrufen und wir sehen,
dass er mir jetzt hier diese ganzen Dateien auflistet,
die sich in diesem Blue Jay-Paket befinden, also in dem Ordner.
Das ist doch toll. Gut. Also, was passiert denn hier intern?
Also wir haben jetzt hier uns quasi eine Variable definiert,
wo es immer eine Referenz auf ein Fallobjekt stehen kann.
Und in dieser Vorschleife geht da jetzt immer jedes Einzelne Element in der Liste
durch und ändert sozusagen immer die Referenz auf das Element in der Liste Dateien.
Das ist das, was da passiert. Hat jemand eine Idee,
also diese For-Each-Leife, die gibt es seit Java 1.5 und wie könnte man,
stellen wir uns mal vor, wir benutzen jetzt Java 1.4,
aus welchen Gründen auch immer.
Und wir müssen jetzt diese komische alte Vorschleife benutzen.
Wie könnte ich denn jetzt da eigentlich über die Liste iterieren?
Aber wir brauchen irgendwie einen Index, dann muss ich
bis irgendwas iterieren. So, das kommentieren wir hier
mal aus
Ja. Ach so, da oben. Ja, ja
. Genau, richtig. Das gibt uns schon mal die
Grenze dafür. Time Punk Size. Und eine Idee,
wie ich auf die Elemente in irgendeiner Weise komme,
also ich meine, wir haben ja so die Möglichkeit,
mit der Position zu arbeiten, meine Liste, ja,
da hinten.
Genau, da können wir auch einfach gucken, wenn wir es einfach nicht wissen.
Wir wissen, wir brauchen irgendwie eine Möglichkeit,
dass wir über einen Index auf ein Element kommen.
In dem Fall ist es Get. Und dann können wir
mit unserem Schleifenzähler hier dann auf das Element zugreifen.
So, und dann natürlich noch System Outprint LN, mache ich jetzt nicht.
So, eins möchte ich noch hier gerne machen,
lösche alle Einträge, bedeutet also, wir wollen,
ja, die ganzen Elemente aus unserer Datailliste löschen.
Ja, dahin? Claire, genau, wunderbar.
Eine andere Möglichkeit wäre auch einfach, dass wir das einfach neu initialisieren.
Also mit New Arraylist, File war das.
Könnte man auch machen, muss man nicht.
Das ist eine gute Frage. Es wurde gerade gefragt,
ob man das hier machen kann.
Da teilen gleich nahe setzen. Wie ist die Meinung dazu
? Wer würde das so machen, Hand hoch?
Wer würde das nicht so machen, Hand hoch?
Genau. Und wer mag mir jetzt sagen,
warum man das nicht so machen will?
Genau, richtig, ne?
Also wir haben dann hier eine neue Referenz drin.
Und wenn wir jetzt Dateien in irgendeiner Weise weiterverwenden wollen, ne?
Wir sind jetzt zum Beispiel wieder Verarbeite aufrufen wollen.
Dann machen wir, ja, rufen wir Verarbeiter auf Nall
auf und wir kriegen eine Nightpoint Acception.
Richtig. Ist aber trotzdem eine gute Frage.
Huch. So. Das mit der Gesamtlänge, das könnt ihr
dann in einer Übung machen. Wunderbar. Gibt es da
Fragen zu? Zu dem Listenkrams.
Wie spät haben wir es jetzt? Viertel nach drei,
Kiel. So? Das brauche ich nicht mehr. Dann
mache ich mal das nächste Projekt auf. Das ist ein
anderes Projekt, was ihr in der Übung machen werdet.
Da geht das um das Geburtstagsparadoxon, was ihr dann simulieren sollt.
Das ist ein Projekt, das lässt sich noch nicht ganz kompilieren.
Hier gibt es dann einen Fehler, weil noch eine Implementierung zu diesem Interface Party fehlt.
Das sollte dann in der Übung machen. Das ist aber egal,
das wollen wir uns gar nicht angucken, was heute interessant ist.
Das ist dieser klasse Tag. Können wir ja mal reinschauen
. Also diese Klasse Tag modelliert Tag. So,
und zwar auf ganz, ja, ganz simple Weise.
Wir haben hier ein Exemplar Variable, die eine Tagnummer repräsentiert. Und das bedeutet,
diese Tagnummer stellt einfach nur einen Tag in einem unbestimmten Jahrstadt,
also wir wollen unabhängig von dem Jahr einfach sagen,
ja, das ist jetzt der 1. Januar,
das ist der 12. Mai, was auch immer.
So, und das können wir dann so initialisieren,
dass wir, wenn wir einen Konstrukteraufruf machen für dieses Objekt,
dass wir hier einfach einen Intager übergeben,
wird den noch so ein bisschen überprüft,
es ist kleiner Null,
es ist größer als die maximal Tage pro Jahr
und so weiter und so fort
Das ist vielleicht noch ganz witzig, gibt zufälligen Tag,
kann ich mir irgendeinen Tag geben lassen und dann wird ja auch berücksichtigt,
dass wir auch ein Schaltjahr haben,
aber das ist dann unwahrscheinlicher zu bekommen, dieses Schaltjahr,
weil es kommt ja nur alle vier Jahre vor.
Gut, dann können wir damit ja mal ein bisschen rumspielen.
Ich habe hier mal die Direkteingabe. So,
dann machen wir uns mal einen Tag,
ich übergebe mal null, das entspricht dann dem 1. Januar.
So, ziehe ich mir hier mal rein,
gebe dir
einen Namen
Und noch eins, so, ich habe jetzt zwei Objekte,
die jeweils den 1. Januar repräsentieren.
Und jetzt kommen wir ja so ein paar Vergleiche machen,
wenn ich sowas mache, vergleiche ich ja Referenzen,
der gleichgleich gleiche Operatorvergleichsreferenzen. Das heißt also, wir erwarten,
weil wir zwei verschiedene Objekte haben und wir haben da jeweils zwei Referenzen uns erzeugt,
kommt da False raus,
wie ihr erwartet oder wenn wir jetzt zum Beispiel,
ah,
mit A vergleichen ist es natürlich True
So. Genau. Und jetzt,
das haben wir jetzt auch schon in der Vorlesung jetzt gehört,
interessiert uns ja aber wahrscheinlich nicht die Referenz,
sondern ob die beiden gleich sind.
Wir hatten das ja mit der Frau Winter, mit den beiden Frauen,
die Frau Winter heißen und beide im Jahr 91 geboren sind.
Hier haben wir es jetzt zum Beispiel so, dass wir
zwei Objekte haben, die jeweils den 1. Januar repräsentieren.
Und wir möchten jetzt wissen, wir möchten jetzt gerne haben,
wenn wir dieses Equals aufrufen, A,
Equals B,
dass da natürlich Tu rauskommt
Aber da kommt Falls raus. Nämlich, weil,
hier in dieser Klasse ist kein Equels drin.
Und das bedeutet, dass nun mal dieses Equels,
also diese Standard-Implementation Equels aus der Klasse Object genutzt wird.
Und das vergleicht Referenzen. So, das heißt also,
es wird immer dieses je geprüft. So, aber
das wollen wir ja nicht. Wir wollen ja wissen,
wenn ich jetzt hier ein Objekt mit 1. Januar habe und
da ein Objekt mit 1. Januar, will ich sagen,
ja, die beiden sind gleich.
Gut. Dann fangen wir doch einfach mal an,
das zu machen
So, die Signatur, die sah ja so aus,
muss natürlich öffentlich sein, wir wollen sie ja darauf her zugreifen können.
Bulien, ja, sie sind gleich, nein, sie sind nicht gleich.
Equals. Und dann kommt hier ein wichtiger Teil.
Hier wird Object übergeben. Man kann sich jetzt natürlich überlegen,
ja, ich will doch eigentlich einen Tag mit einem anderen Tag vergleichen.
Also ich rufe hier dieses Equals an meinem Tagobjekt auf und
dann gebe ich doch natürlich auch ein Tagobjekt rein,
weil was macht denn das für einen Sinn?
Weil hier, Java definiert das so,
dass ich mein Tagobjekt mit allen anderen möglichen Objekten auch vergleichen
Ob das ein tolles oder nicht, weiß ich nicht.
Also es klingt erstmal irgendwie ein bisschen bekloppt.
Warum sollte ich einen Tag mit einem Benutzer vergleichen können?
Ja. So, aber das ist nach Java halt so
definiert. Und deshalb muss die Methodensignatur immer so aussehen.
Gut. Und ich habe ja gesagt,
wir möchten gerne das so definieren, die Gleichheit,
wenn das eine Objekt die Tagnummer null hat und das andere
die Tagnummer null hat, dann ist es gleich.
Oder also auf jeden Fall, dass die beiden
die gleichen Tagnummern haben
Dann kann ich doch sowas sagen. Ich befinde mich ja
hier in der Klasse Tag. Das heißt also,
ich kann hier auf meine Exemplarvariable zugreifen und könnte ja jetzt so was machen.
Dann habe ich es ja miteinander verglichen. Da sagt mir
der Köln Peile aber, nein, das geht, ach so,
warte mal, vielleicht sollte ich auch einen Return schreiben.
Das wäre vielleicht mal hilfreich. So, dann sagt mir der Kompeile aber,
nein, hier, Cannot Find Simble erst mal,
weil ich das nämlich O genannt habe und ich,
oh, J. So, jetzt sagen wir der Kompeile aber,
ich kann dieses Symbol, also diese Variable Tagnummer nicht finden,
weil ist ja klar, hat den statischen Typ Object.
Und Object wird garantiert keine Exemplarvariable haben, die irgendwie Tagnummer heißt.
So. Genau, das heißt also, was können wir machen? Wir müssen irgendwie sicherstellen,
dass, weil wenn jetzt hier irgendwie ein Tag reingegeben wird,
dass wir dann auch irgendwie auf diese Exemplarvariable zugreifen können.
So, und jetzt kommt ein neues Schlüsselwort für die Sinntags in Java,
womit wir das halt testen können,
was für ein Typ diese, auf was für ein Objekt,
von welchem Typ dieses,
oh jetzt hier verweist.
Und das sieht folgendermaßen aus
Ich kann abfragen, oh, Vinstance of Tag. Das bedeutet,
ich frage hier ab, so oh, ich weiß,
du bist vom statischen Typ,
aber ich möchte jetzt gerne wissen,
auf welches Objekt du zeigst und was für ein Typ das hat.
Und ich möchte gerne sicherstellen, dass es diesen dynamischen Typ Tag hat.
So, und wenn das der Fall ist,
vergleicht dann doch das hier. So, und wenn nicht,
also es ist quasi unsere notwendige Bedingung,
die müssen wenigstens vom gleichen Typ sein
Wenn das nicht der Fall ist, Return falls.
Und das macht die Standard-Implementierung von den Equals in dem Object
auch so. Also wenn ich dann irgendwie zwei ungleiche,
also zwei Elemente von ungleichen Typen vergleiche,
dann gebt er auch Fords raus.
So, und jetzt könnte das ja eigentlich funktionieren.
Ich rufe Equals auf meinem Tagobjekt aus, mach hier diesen Test,
ob da wirklich auch der Typ Tag dahinter steckt.
Und dann müsste er mir jedoch sagen,
könnte ich hier ja genau diesen Vergleich machen,
weil ich das hier jetzt sichergestellt habe.
Ich kompiliere das
Und es funktioniert immer noch nicht. Warum? Was für
einen statischen Typ hat O denn? An dieser Stelle.
Noch jemand anders, ja? Ja, du. Ist
immer noch object, genau. Also Java checkt es nicht,
dass wir hier diesen Test gemacht haben,
diesen Typtest und nimmt halt hier immer noch Object an.
Ich habe mir sagen lassen, es gibt Programmiersprachen,
die das dann sozusagen merken, dass man diese If-Up-Frage macht,
dass man auf diesen Typ geprüft hat und dann dieses,
oh hier anders behandelt.
Das geht aber in Java nicht. Wir müssen es jetzt explizit mitteilen.
Das heißt also, wir möchten gerne eine Variable haben,
mit der wir auf diese Exemplare Variable zugreifen können.
Das heißt also, wir möchten eine Variable vom statischen Typ Tag.
Dann definieren wir uns doch jetzt einfach mal einen Tag.
Zweiter Tag sozusagen. Dann mache ich das hier eben mal weg.
Und dann weiß ich dem, dass hier ja eben mal
zu. Weil jetzt habe ich ja meine Variable.
Oh, genau. Richtig gut. Aufgepasst war ein Test
So, und dann kann ich ja hier meinen Return.
So, jetzt aber nicht mehr O, sondern zweiter Tag.
Wer meint, das funktioniert? Also es ist kompiliert, meine ich.
Also hart hoch, wer meint, dass das funktioniert?
Wer meint, dass es nicht funktioniert? Das ist komisch. Na gut,
aber wenn wir jetzt kompilieren, funktioniert es nicht,
aber es ist auch irgendwie klar,
wir haben hier jetzt uns eine Variable,
eine Referenzwar-Reable vom Typ Tag definiert und das hier ist immer noch vom Typ Object.
Wir müssen Java jetzt zusichern, dass wir wissen,
dass es sich hier um ein Objekt vom Typen Tag handelt,
das hier kann Java so nicht wissen.
So, und jetzt kommt noch eine komische Sache sozusagen hinzu.
Wir sichern ihn zu mit diesem Ausdruck hier, ja,
ich weiß, das hier ist ein Tagobjekt.
Und ich möchte, dass es jetzt auch so behandelt.
So, und dann funktioniert es tatsächlich. Und dann können wir
nämlich auch diesen Vergleich hier machen. So, das heißt,
was für eine Situation haben wir hier vor der IF-Bedingung?
Wir bekommen hier dieses Object O rein.
Das hat den statischen Typ Object, das wissen wir,
welchen dynamischen Typ ist,
hat das wissen wir nicht
Zumindest nicht so. So, und dann gehen wir jetzt hier,
wenn jetzt hier diese F-Bedingungen zutrifft, wissen wir,
dass dieses Objekt, diesem dynamischen Typ Tag hat.
So. Aber dann müssen wir Java noch sagen, gut,
ich möchte jetzt eine Variable vom statischen Typ Tag,
damit ich hier auf meine Tagnummer zugreifen kann und mache hier sozusagen diese Zusicherung,
ja, dieses Objekt, worauf O zeigt,
ist auch vom Typ Tag.
Wunderbar. Und das funktioniert jetzt.
Das können wir jetzt
mal ausprobieren
So, dann machen wir hier wieder.
Tag A. Und dann können wir jetzt sagen, A,
Equals, wir. Ach, verdammt. Ist true.
Das funktioniert jetzt.
Du meinst, wenn ich dich jetzt richtig, weil ich habe das akustisch nicht ganz verstanden,
aber ich versuche das mal, wo ist denn das jetzt?
Du meinst jetzt, dass man sagt, oh,
ist gleich Tag von O, so? Das wird nicht funktionieren,
weil da haben wir eigentlich die gleiche Situation wie vorher,
dass, also wenn wir sozusagen hier dieses, diese Zusicherung hier weglassen,
weil O immer noch den statischen Typ Object hat,
das heißt, obwohl, ich probiere mal,
ich probiere mal,
Moment,
jetzt bin ich gerade
ein bisschen verwirrt
Okay, es funktioniert nicht. Ja. Also er kriegt hier
diese, genau, er kriegt diese Zusicherung noch hin.
Also du meinst ja hier diesen, ja, okay,
er kriegt diese Zusicherung zwar hin,
aber der statische Typ von O ist weiterhin Object.
Und dann sucht er hier nämlich weiter nach der Tagnummer.
Also wir können dann zwar diese Zuweisung hier machen,
aber dann das hier können wir nicht mehr machen.
Okay, gut, jetzt habe ich auch verstanden,
was du meinst.
Gut. Ups. Gut
So, ja. Gut. Okay. Das funktioniert jetzt.
Alles klar. Dann wird ja schon irgendwie was von Hashcode erzählt.
Da wollte ich jetzt auch mal ein bisschen was zu erzählen,
aber erst mal. Zu was? Zudem? Ja?
Nee. Man kennt jederzeit nur die plötzliche Schlüssel.
Ja, ich komme da später zu
Zu dem Schlüsselwort. Also es wurde nach Overwrite gefragt,
das kann ich, ja, ich kann das auch jetzt an der Stelle erklären.
Also wonach gefragt war, war nach diesem hier,
man kann ein Java sogenannte Annotation verwenden.
Und genau, das kann mich dabei unterstützen,
wenn ich jetzt zum Beispiel sage, gut,
ich habe jetzt irgendwie vergessen, wie diese Equits-Signatur nochmal aussieht.
Ich übergebe jetzt doch einen Tag, weil es erscheint mir ja sinnvoller.
Und ich habe dieses Overwrite dazu und ich kompiliere das jetzt,
dann sagte mir, ja, ich kann das nicht überschreiben.
Das bedeutet, also ich kann es nicht jetzt,
also ich kenne diese Methode nicht, weil er kennt die Methode,
Aus Equals, nämlich nur so, in dieser Signatur.
Also ich versuche eine, eine Methode neu zu definieren,
die es in Object gar nicht gibt.
Und dafür kann ich dieses Overwhite benutzen.
Meintest du das? Zweitens, ich glaube auch Checkles,
das ist nicht das. Nein. Ich habe natürlich auch,
ich habe natürlich nur deine Glatte anzeigt,
zum Beispiel der, gleich auf euch,
stärkt es weiter,
Du meinst jetzt, dass ich hier so einen Gleichgleich mache?
Ja. Okay, du meinst sowas? Ja,
da muss man glaube ich, ich glaube, es geht.
Man muss nur bei der Klammerung ein bisschen aufpassen.
Irgendwie, dass man hier so eine Klammerung macht,
also anstatt dann eine extra Variable zu deklarieren.
Kannst du eigentlich auch direkt diese Zusicherung machen?
Es ist halt nur nicht so schön lesbar,
aber du kannst es machen, ja.
Ich finde es halt mit der zusätzlichen Variable
ein bisschen schöner
Kompeil. Gut. Okay. Dann wollte ich noch mal hier
was mit Mengen machen. Da, wofür muss ich,
ich mache das hier in der Direktangabe. Punkt, Sternchen.
Damit bekomme ich die Lists und Sets oder allgemein die Collections.
Und dann mache ich mir hier eine neue Hash-Set.
Vom Typ-Tag. Ich möchte jetzt gerne eine Menge von Tagen haben.
Ziehe ich mir hier rein. Und da packe ich mir
jetzt, mache ich hier wieder Tag an,
da ist nur Tag
So. Und das sind wieder zwei Tage, die wieder den 1. Januar repräsentieren.
Und die möchte ich jetzt in diese Set reintun.
Da kann ich Set A machen. Ach komm. Zack. So,
und jetzt kann ich ja, wir wissen ja,
dass dieses Set so ein Size anbietet und wir wissen auch,
dass A und B sind gleich nach unserer Definition von Equals
Und wir wissen, in Mengen sind keine Duplikat erlaubt.
Was gibt uns, sei es jetzt raus,
wer meint, da sind keine drin?
Wer meint, da ist eins drin?
Wer meint, da sind zwei drin? Okay,
ich gebe das mal raus, Überraschung ist in zwei drin.
So, da wundert man sich jetzt natürlich, wieso?
Wir haben doch dieses blöde Equals definiert, das müsste doch jetzt eigentlich funktionieren.
Und da kommt jetzt dieses Hashcoat nämlich ins Spiel.
Das brauchen wir nämlich auch noch damit, dass wirklich funktioniert.
So, und das sieht so aus
Dieser Hash-Code ist eine Methode, die ein Intager zurückgibt und sozusagen,
also ihr bekommt noch eine ganze Vorlesung so zu Hash-Tables und Hashing und so,
da wird das nochmal ein bisschen genauer erklärt.
Jetzt braucht ihr euch nur zu interessieren,
dass dieser Hash-Code aus den Werten,
also aus dem Zustand eines Objekts sozusagen alles auf eine Zahl reduziert, also abbildet.
Und die wird gebrauchen und immer, wenn wir dieses Equips redefinieren,
wenn wir uns da in eine eigene Implementation ausdenken sozusagen,
dann muss auch immer dieses Hash-Code-Redefiniert sein,
sonst funktioniert das nicht
So, und deshalb ist es auch der Grund,
warum unser Hinzufügen von den Tagen noch nicht so richtig hinhaut,
weil das nämlich intern auch genutzt wird.
Hier können wir es zum Beispiel auch dieses Overright dazu tun,
weil, was nämlich auch immer gerne passiert ist,
dass man sowas macht, dass man Hashcode mit einem kleinen Zeh schreibt.
Da würde er nämlich auch meckern, dass er sagt,
ich kenne die nicht, die gibt es in Object nicht.
So, die gibt es nämlich nur mit einem großen Zeh.
So, und dann können wir noch dieses Overright benutzen.
Gut. So. Und dafür zwischen diesen beiden Methoden,
das sind ganz besondere Methoden zwischen Equals und Hashcode, gibt es einen Vertrag.
Das werdet ihr in der Übung auch noch anwenden und lernen.
Und dieser sagt, Wenn dieser Ausdruck Truhe ist,
also wenn A und B gleich sind, dann muss auch gelten,
dass diese Hashcodes, also einmal Hashcode von A,
gleich dem Hashcode von B ist.
Also die müssen gleiche Werte liefern. So,
andersrum muss es nicht unbedingt gelten. So,
und genau, jetzt könnten wir uns ja mal überlegen,
wenn die hier gleich, wenn zwei Tage gleich sind,
dann müssen wir auch irgendwie den gleichen Wert liefern.
Und das wollen wir anhand des Zustands von den Objekten machen.
Was würde denn hier Sinn machen
Vorschläge? Also es muss irgendwie hier, wenn ich jetzt sage,
ah, ist 1. Januar und B ist 1. Januar,
also Tagnummer ist gleich eins und der hat Tag Nummer gleich eins,
was könnte man dann hier beim Hashcore zurückgeben,
wenn wir uns hier so die Exemplarvariabler angucken?
Dann würde das doch eigentlich Sinn machen, die Tagnummer zurückzugeben,
weil wenn ich jetzt hier den 1. Januar habe,
Also bei Objekt A habe ich den 1. Januar drin stehen,
also die Null,
bei dem anderen Objekt habe ich die Tag Nummer 0 stehen,
dann ist ja der Hashcode bei den beiden,
wenn ich das hier zurückgebe.
Auch gleich. Und das ist so, was
das Hashcode eigentlich macht. Gibt es da Fragen zu?
Nein. Okay. Ist klar, genau,
dann können wir das jetzt nämlich nochmal ausprobieren.
Jetzt haben wir das ja gemacht. Huch. Kompal.
Ach ja, klar.
Das muss weg
Kompiliere ich das? Und dann probiere es nochmal,
ah, jetzt muss ich nochmal alles von vorne machen.
Punkt, äh, stimmt. Ja. Zack. Und
dann wieder Tag A. Dann wieder den Januar.
So, und dann fügen wir die wieder hinzu
Äh, Quatsch. Ah. So,
und dann können wir jetzt natürlich wieder entsprechend Size aufrufen.
Und jetzt hat es funktioniert. Jetzt haben wir wirklich nur ein,
ein davon drin, weil da jetzt, dadurch,
dass wir dieses Hash-Code hinzugefügt haben und das jetzt nämlich ordentlich funktionieren kann,
werden diese Duplikate jetzt erkannt.
Also wenn ich jetzt noch einen 1. Januar reintun würde,
noch einen 1. Januar,
dann wird sich an der Anzahl nichts ändern.
Und dann können wir ja nochmal wirklich den ganz sicheren Test machen.
Quatsch. Wir fügen jetzt den 2. Januar hinzu
So, und dann sollte ja entsprechend, genau, sind jetzt zwei drin.
Wir können uns ja mal aus Spaß mal ganz kurzes angucken,
was da für einen Wert rauskommt, wenn wir das nicht redefinieren.
Nur mal so aus Spaß, weil wir so Spaß dran haben.
So. Oh nein. Ah, ich brauche ja nur
einen Tag. So, und dann mache ich hier.
Und dann kommt da echt ein Mucks raus. So,
und dann mache ich, also was heißt Morks?
Er benutzt halt die Implementation, aus Object,
sondern jetzt kann ich mir das noch von ihm hier angucken.
Kommt auch eine ganz andere abstruse Zahl raus und die ist auf
jeden Fall anders als dies Ungleich zu dem hier oben.
So. Ja, Moment. Two String, genau.
Ha war hier, glaube ich, sogar schon drin.
Hier wurde tatsächlich eine Two String über neu definiert.
Wenn man das weglässt, dann gibt da irgendwas ganz Komisches raus.
Wir können das ja mal machen, aus Spaß,
wie ich das schon mal gesagt habe
Und, wie sieht das dann aus?
Ach ja, ach, kompilierend wird auch überbewertet.
So. Tag. Ah, ist gleich, nur Tag.
Gucken wir mal, was rauskommt. A.2String. Dann kommt sowas
raus. Dann macht er irgendwie so einen komischen Bezeichner.
Und das, was hier jetzt definiert wurde,
ist dann wahrscheinlich eine viel, viel schönere Präsentation als,
ah Mann. So, ja, two string.
Und dann steht er auch wirklich schön
1. Januar
Genau. Ich will. Ich was? Ich kann auch gerne an dich abgeben. Ja,
also ich wäre mit meinem Teil fertig,
wenn es keine Fragen mehr gibt, nach den Ferien,
ich glaube, es gibt keine Vorlesung mehr, ne,
dieses Jahr?
Dieses Jahr gibt es auch bestimmt noch ganz viel Vorlesung.
Also, auf jeden Fall, nächstes Jahr kommt Fred wieder
und dann ist er bestimmt wieder gesund.
Ich wünsche euch schöne Weihnachten, einen guten Rutsch ins
neue Jahr und ja,
viel Spaß noch
Ja, das stimmt. Vielen Dank, Sarah. Sandra,
Sandra, sorry. Ich würde gern die letzten fünf Minuten verwenden.
Vielen Dank, dass Sie mir die noch schenken.
Und zwar möchte ich allen Ihnen und denjenigen,
die im Livestream zuschauen oder die, dass sich dann Electure to go angucken,
noch was kurz sagen über die Frage der Anwesenheit bei Vorlesungen.
Und zwar, es gab vor zwei Wochen ungefähr einen ganz
netten Artikel in der Zeit, der sich David beschäftigte,
damit anfing. Herzlichen Glückwunsch, man hat viel erreicht,
das Land Nordrhein-Westfalen hat jetzt die Anwesenheitspflicht für Unis entfernt,
aber das ist nicht der Punkt, weswegen ich Ihnen das sagen wollte.
Ich wollte darüber sprechen, dass dort eine Statistik angeführt wurde,
wie Vorlesungsbesuch mit Lassen Sie ihn noch an, ja.
Wie die Vorlesungs, wie der Vorlesungsbesuch mit Leistung korreliert.
Da hat jemand eine Statistik gemacht. Sie wissen,
Statistiken sind so eine Sache, aber ich denke,
da ist ein wahre Kern drin. Und zwar,
was wir wir erwarten würden, ist es natürlich so,
wer häufiger anwesend ist in Lehrveranstaltungen, hat am Ende bessere Leistungen.
Soweit nicht überraschend. Das heißt, wenn man es umkehrt,
die Leute, die ein bisschen weniger anwesend sind,
haben wir ein bisschen weniger, weniger gute Leistungen. Aber,
und jetzt kommt der überraschende Punkt und deswegen wollte ich das sagen,
es gibt eine große Differenz in dieser Statistik,
wenn man unterscheidet, zwischen den Leuten,
die normalerweise gute Leistungen haben und die normalerweise etwas schlechtere Leistungen haben.
Und der überraschende Punkt ist, und das ist das,
Take-away für heute. Die Leute, die sehr gute Leistung haben,
da sieht der Abfall, wenn sie nicht da sind, geringer aus.
Der Leute, die schlechte Leistung haben, da ist der Abfall an Leistungen,
wenn man nicht anwesend ist, viel, viel größer.
Das ist sozusagen das Goodie oder das Schlechte,
jedenfalls, wie sie wollen, dass den Leuten,
die eigentlich das am nötigsten haben, die Abwesenheit am meisten schadet,
zu viel noch als letzter Kulturblock,
als Statistikblock,
wir wünschen ihnen schöne Feiertage,
alles Gute