Von vorgestern, nachdem also der wesentliche Teil des Konzepts dieser Lehrveranstaltung
auf Axel Schmolitzky zurückgeht, steht er hier nicht nur ehrenhalber,
sondern als Gründer dieses Konzeptes mit auf den Folien.
Viele von denen hat er auch gemacht. Zu ihrer hoffentlich
großen Freude wird auch Fred Winkler, sie, dieses Semester wieder begleiten.
Wir haben uns überlegt, nachdem das ja so auch durch die Rückkopplung,
durch sie im letzten Semester, wir haben das als ganz positiv wahrgenommen,
uns hat es auch Spaß gemacht.
Wir werden wieder so eine Aufteilung machen, die da heißt,
dreiviertel Stunde ungefähr werde ich hier vorne etwas auf Ebene von Folien
ihnen zeigen und Fred wird die zweite Hälfte der Veranstaltung
dann mit der Hand am Arm, wird er die Konzepte implementieren.
Heinz Zülikoven, Professor Heinz Zülikoven oder seit heute,
Professor im Ruhestand, Dr. Heinz Zülichhoven, wird,
nachdem er die letzten Gefühle, also bis zurückliegend ins letzte Jahrtausend,
diese Veranstaltung mitgeprägt hat.
Wir versuchen ihn zu gewinnen für einen Gastauftritt in dieser Vorlesung
hier zu sein.
Das kriegen wir auch hin,
das zu aber später mehr
Sind die handelnden Personen, die ihnen im Laufe dieses Semesters
hier auf dieser Bühne begegnen bzw. nicht begegnen werden, worum es geht.
Nur, dass das für alle klar ist. Hier ist jetzt nicht,
leider ist ihr nicht, italienisch für Anfänger ohne Vorkenntnisse.
Hier ist objektorientierte Programmierung und Modellierung und wir werden versuchen,
sie am Ende dieses Semesters dazu gebracht zu haben,
dass sie kleine interaktive, objektorientierte Systeme schreiben können.
Das ist also nochmal Ja, das ist der Sprung,
ist wahrscheinlich nochmal genauso groß wie vom Anfang des Wintersemesters,
zum Ende des Wintersemesters, was wir da im Detail vorhaben,
werde ich im Laufe meiner Dreiviertelstunde auch noch drauf kommen.
Zunächst Videoaufzeichnung ist ein bisschen was Organisatorisches.
Wir versuchen das genauso wie im letzten Jahr zu handhaben.
Also die Kollegen von Lecture to Go nehmen das Zeug auf,
stellen das so schnell wie möglich dann im Internet zur Verfügung.
Die Folien stellt, glaube ich,
auch was dazu dar
Ja, werden ebenfalls zeitlich synchronisiert dem Video hinzugefügt.
Ich werde mich wie immer bemühen, die Folien,
also in einem eher in Minuten zu messenden Zeitraum vor der Vorlesung hier bereitzustellen.
Da sind immer noch so letzte Erkenntnisse, die ich berücksichtige,
wenn ich doch mal durch die Folien gehe.
Also so spätestens so 13, 13.45 Uhr sollten die ihnen
auch schon so zur, wenn sie denn Lust haben,
sollten die ihnen im Kommen sie zur Verfügung stehen.
Der Kommen sie Raum ist ansonsten natürlich auch schon eingerichtet.
Ich habe gesehen, da sind erst 70 Leute angemeldet.
Zu befehlen, ungefähr nach meiner Erzählung, noch so 430.
So, die an dieser Lehrveranstaltung teilnehmen werden.
Also, sie gehen jetzt ins Komsi. So, wer
sind Sie? Also, Sie sind natürlich zuallererst diejenigen,
die ich auch schon in SE1 gesehen habe.
Sie sind aus diesen Studiengängen und jetzt kommt die Frage,
wer fühlt sich zu der Menge von Menschen,
die ich gerade versucht habe, zu charakterisieren, nicht zugehörig.
Also keine neuen Gesichter. Gut, dann für
den Rest nochmal hallo
Wir haben Ihnen, Fred und ich, haben Ihnen zum Ende
des letzten Semesters schon versucht, ins Gewissen zu reden.
Sie haben ungefähr 40 Stunden pro Woche, um ihr Semester
zu begleiten und acht Stunden davon sollten uns gehören.
So in ungefähr der Aufteilung, also anderthalb Stunden Vorlesung,
drei Stunden Übung und satte drei Stunden Vor- und Nachbereitung
gönnen wir Ihnen.
Das hoffen wir,
dass Sie die Zeit finden
Das auch zu machen. Wir sind der Überzeugung,
dass jetzt gerade so der, weil die programmatischen Anforderungen an
sie werden im Laufe des Semesters so etwas höher werden,
dass sie das, nutzen sie die Chance,
diese drei Stunden zu haben im Laufe des Semesters.
Diesen jungen Mann kennen sie auch schon, der Organisator der SE2-Übung,
Christian Speeh steht ihnen auf allen Kanälen zur Verfügung.
Da hat sich also auch nichts geändert,
also der hat das Programm,
insbesondere ihre Betreuung hat er wie gehabt,
hoffentlich wieder
allerbestens im Griff
Noch was, so, das habe ich mir von Christian hier sagen geben lassen,
wie sind die Übungen organisiert, Beginn der Übungswoche donnerstags.
Gleich, so ist ja auch ein wunderbar gelegt,
also sie haben ja gleich ein langes Wochenende, Karfreitag, Ostermontag fallen selbstverständlich aus.
Diejenigen, die an diesen Tagen zu Übungen angemeldet sind,
kriegen jetzt von uns die unfassbar liebevolle Aufforderung,
help yourself oder organisieren sie sich selbst. Ich zeige gleich noch,
also wie der Füllstand der einzelnen Übungen ist,
ich gehe mal davon aus,
dass sich da Ruhe ein Wille ist, ist auch ein Weg,
also wir werden sie Wir lassen niemanden über,
sie kriegen das weg.
Sie und wir kriegen das dann zusammen schon hin.
Die erste Hälfte des Semesters wird, was die Übungen anbetrifft,
werden sie Bekanntes wieder Bekanntes, Wiedererkennen.
Also werden sie Bekanntes wiedererleben. Die Laborphase 1,
also das ist so ungefähr so bis zu den Pfingstferien,
ist also wie gehabt, drei Stunden in der Vogt-Köln-Straße.
Jede Woche gibt es ein Übungsblatt, Arbeit in Programmierpaaren.
Und am Ende dieser Phase soll es
ein Programmierdiktat geben
Und das ist ja vom Konzept her, haben Sie das
auch schon kennengelernt. Wir werden weitere Sprachelemente von Java kennenlernen,
die Sie dann auf Ansage, denke ich,
auch flüssig in Programmiersprachlich sauberen Code übersetzen können.
Die Laborphase 2 soll dann ihren Horizont ein klein wenig öffnen.
Und zwar werden wir dann von der engen Taktung der wöchentlichen
Übungsblätter übergehen zu 14-tägigen Übungsblättern und sie werden auch nicht mehr
zu zweit in einem Paar arbeiten,
sondern sie werden in einem Team von
insgesamt dann vier Studierenden
Arbeiten. So, das geht jetzt, also das geht jetzt immer weiter.
Also danach kommt also so im Laufe des, ich weiß gar nicht,
dritten oder vierten Semesters bieten wir Ihnen ein Programmierpraktikum an und da gibt es dann eine Aufgabenstellung,
die schon deutlich über zwei Wochen hinausgeht. Die Idee ist,
Sie jetzt so langsam aber sicher vom Zügel zu lassen,
weil so in spätestens, sagen wir mal, drei Jahren,
wenn Sie dann also da draußen arbeiten können, wollen als Softwareentwickler,
da gibt Ihnen auch nicht mehr jemand eine wöchentliche Aufgabe,
die Sie allein oder empire bearbeiten wollen, sondern da heißt es,
hier ist das Ziel so sieh zu,
wie du da hinkommst, on time on budget,
die Funktionalität zu implementieren und bis dahin müssen sie gelernt haben,
sich zu organisieren.
Und sie kriegen jetzt Stück für Stück,
kriegen sie jetzt die Methoden und Täglichniken beigebracht, die es braucht,
um in so einer Art und Weise arbeiten zu können.
So, die Laborphase 2 bereitet sie,
also schon in homöopathischen Dosen schon mal darauf vor,
dass sie diesen Weg gehen können.
Das ist Stand 31.3., also gestern ist das der Stand der Übungsgruppen.
Sie sehen Dass die Morgentermine morgen Stundgold im Mund,
da sind noch freie Plätze vorhanden.
Das ist so für sie zur Übersicht, wie sie sich,
wo sie sich dann auch eintragen können, falls das noch nicht passiert ist.
So an der Anzahl der freien Übungsgruppen lese ich mal so ein bisschen ab,
dass noch viele von ihnen sich noch nicht irgendwo eingetragen haben, tun sie das.
So, dann war also, wann haben wir das gemacht?
Irgendwann im Februar haben sich Fred und ich hingesetzt
Und ergebnisoffen die Frage in den Raum gestellt, was machen wir denn in SE2?
Was kommt da eigentlich noch? Wäre ja vielleicht günstig,
wenn wir uns noch mal kurz überlegen, was haben wir eigentlich in SE1 gemacht?
Was war denn da? Hey, komm,
wir haben noch 14 Wochen, haben wir vorgelesen.
Muss doch ungefähr, das müssen wir doch noch zusammenkriegen.
Wir haben das dann auch zusammengekriegt, aber dieser Moment,
also ich jetzt so in der Sekunde nicht hätte sagen können,
was der Inhalt der 14 Vorlesungen gewesen ist,
uns auch dazu gebracht, so ihnen jetzt die Chance zu geben,
sich noch mal vor Augen zu führen,
womit wir uns eigentlich beschäftigt haben in SE1.
Und was wir glauben, was sie mitbringen,
wenn sie hier in dieser Veranstaltung sitzen. So,
jetzt gucken sie da mal drauf und denken, aha,
Objekte, Klassenoperationen, ja, ja, ja,
war was, boah, ist auch schon so lange her,
oder?
Oh, strukturierte Programmierung, heieieiei.
Weiß noch jemand,
wofür UML steht
Okay. Unified Modeling Language. Da weiß jemand,
wofür AP steht. Vielleicht die... Ist jemand vom Kontaktstudium
für ältere Erwachsene hier?
Wissen Sie
wohl für APO steht
Das ist die autosuppeparlamentarische Opposition. Wir sind uns da,
wir wissen wovon wir reden. Lang, lang ist es her,
aber AP steht nicht für außerparlamentarische Instruktion, nein,
das heißt es nicht, sondern das steht für Application Programming Interface.
Das haben sie gelernt. Und weitere von den Themen,
die dort stehen. So, jetzt machen wir ihn,
haben Fred und ich uns überlegt,
wir machen Ihnen ein Angebot und das ist nicht
ein Angebot im Sinne eines berühmten Films namens der Pate,
sondern es ist ein echtes Angebot
Dass sie, sie können das jetzt auch nicht ablehnen.
Sie müssten jetzt schon rausgehen, um dieses Angebot abzulehnen.
Ich werde jetzt nochmal, also wirklich in aller Kürze,
durch so ein paar Themen gehen, die,
ich habe nicht den Anspruch,
SE1 innerhalb von 30 Minuten jetzt zu wiederholen.
Ich möchte jetzt nur noch, das wäre ja auch zu schön.
So, ich werde jetzt nur noch mal so ein paar von
den Themen streifen, die wir in SE1 berührt haben.
Und Fred wird dann in seinem Programmierteil,
wird er Also nochmal darauf eingehen,
also wie diese Konzepte umgesetzt werden, weil das gleich,
also auch so den Startpunkt darstellt für das,
was sie so an Programmieraufgaben, Übungsaufgaben im Laufe dieses Semesters zu bewältigen haben.
So, womit fingen wir an? Nein,
das ist jetzt eine andere Reihenfolge als die,
die wir ursprünglich gewählt haben,
aber wie kann man sich die ganze Geschichte,
die wir in SE1 erzählt haben,
wie kann man sich die
nochmal vergegenwärtigen
Kontrollstrukturen in Imperativen und in objektorientierten Programmiersprachen. Es kann nur drei geben.
Es gibt drei. Und damit könnte man die ganze Geschichte der Informatik,
der Softwareentwicklung, könnte man hier auch beenden und sagen,
gut, wenn ihr wisst, wie die Sequenz geht,
Fallunterscheidung und Wiederholung.
Damit kann man eigentlich alles programmieren. Das ist ungefähr so,
wie zu sagen, gut,
wenn man ein Kiste Sand und Wasser hat und dann braucht
es noch irgendwas,
dann hat man Samantha,
dann kann man
auch Häuser bauen
Dann wird er den Architekt oder einen Bauingenieur wahrscheinlich auch sagen,
ja, das stimmt. So in der Allgemeinheit,
es ist aber noch nicht das Ende der Geschichte.
Aber wir haben uns im Wesentlichen mit diesen drei Kontrollstrukturen beschäftigt.
Und die haben wir in unterschiedlichen Ausprägungen, haben wir die auch kennengelernt.
Also die Sequenz kann man nicht in unterschiedlichen Ausprägungen kennenlernen.
Aber die Fallunterscheidung, if than else, Switch sind und verschiedene Arten von Fallunterscheidungen.
Wir haben verschiedene Arten von Wiederholungen kennengelernt, die Pre-Checkloop,
die Post-Checkloop, die Schleife, die Vorschleife in unterschiedlichen Ausprägungen.
Also um die verschiedenen Arten von Wiederholungen bzw. Fallunterscheidungen jeweils anwendungsgerecht abbilden zu können
. Wir sind von da aus Haben wir uns angeschaut,
nicht von da aus, aber in dem Zusammenhang,
also wenn man schon über Kontrollstrukturen spricht, irgendwas wird da manipuliert.
Und dieses irgendwas sind Variablen. Variablen sind dadurch gekennzeichnet,
sie haben einen Namen, häufig auch als Bezeichner bezeichnet.
Das Wesentliche an den Variablen, dass ich jetzt im Weiteren eingehen werde,
ist aber, dass die einen Typ haben.
Und dieser Typ bestimmt, welche Menge von Werten eine Variable annehmen kann.
Hier sehen sie so einfache Beispiele dafür.
Und das war so ganz grundlegend für unsere die weitere Arbeit,
weil wir uns doch mit dem Typbegriff auch weiter beschäftigt haben.
Und hier sehen Sie jetzt so die erste Definition,
mit der wir uns auch versucht haben,
der Datentyp ist die Zusammenfassung von Wertebereichen und Operationen zu einer Einheit.
Das, was die Programmiersprache Java ihnen mitgibt,
sind sogenannte elementare Datentypen und sie sehen hier verschiedene Beispiele dafür,
welche Wertemengen damit jeweils verbunden sind, also für den Datentyp Integer,
welche Wertemenge der hat und welche Operationen,
weil das ist immer diese Einheit,
Wertemenge und Operationen auf einem Datentyp,
die einen Typen ausmachen
So, jetzt sind wir zwei Dinge zu,
haben wir zwei Dinge zusammen, Kontrollstrukturen und elementare Datentypen,
aber das ist noch nicht die ganze Geschichte gewesen.
Dafür bräuchte man, also auf der Ebene bräuchte man keine objektorientierte Programmiersprache.
Wir haben uns auch angeschaut, wenn wir mit Datentypen umgehen,
wenn wir mit Kontrollstrukturen umgehen, also gibt es Hilfsmittel,
die uns zum frühen Zeitpunkt ermöglichen,
Aussagen über die Korrektheit eines Programms zu machen.
Und es gibt ein Hilfsmittel, das haben Sie auch
schon kennengelernt im Rahmen Ihrer Verwendung von BlueJ als Programmierumgebung.
Das ist der sogenannte Compiler, der Compiler,
der ein Stück Gammtext entgegennimmt und es auf verschiedenen Ebenen auf Korrektheit hin überprüft.
Einer der wesentlichen Überprüfungen ist die syntaktische Korrektheit des Programmes und
das bedeutet und im Rahmen dieser Überprüfung ist die Überprüfung,
ob ein Programm korrekt typisiert ist, ein wesentlicher Bestandteil.
Die Klasse von Programmiersprachen, die Sie jetzt kennenlernen,
beziehungsweise das eine Element dieser Programmklasse von Programmiersprachen, dieser Staat,
sogenannten statisch getypten Programmiersprachen Java, kann Ihnen schon zur Compile-Zeit sagen,
ob Ihr Programm Typ Fehler enthält.
Sie werden im Laufe ihres Studiums,
werden Sie auch noch sogenannte dynamische Programmier,
dynamisch getypte,
dynamisch typisierte Programmiersprachen kennenlernen
Und das ist eine, also eine wesentlich andere Klasse von Programmiersprachen,
die es auf der einen Seite ihnen erlaubt,
oder sagen wir mal, ja, die es ihnen erlaubt,
statisch nicht korrekt, typisierte Programme zu schreiben,
wobei man sich jetzt so, wenn man,
wenn ich mir selbst zuhöre, warum sollte jemand sowas wollen?
Sie werden diese Klasse von Programmiersprachen kennenlernen,
weil die ihnen sehr viel Flexibilität in der Programmierung ermöglicht.
Und Flexibilität versus Stabilität, statisch getypte Korrektheit ist ein Gut,
das sich also im Laufe so während der Programmierung Ich will nicht sagen,
immer gegeneinander abgewogen werden muss, weil man entscheidet sich ja schließlich für eine Programmiersprache.
Aber es gibt ganze Organisationen, die setzen auf dynamisch getypte Programmiersprachen,
weil sie ihnen eine größere Geschwindigkeit bei der Programmierung ermöglichen.
Das Für und Wider werden sie dann noch in anderen Lehrveranstaltungen
namentlich Softwaretechnik, werden wir da noch diskutieren.
So für den Moment so eine Sprache wie Java erlaubt es ihnen,
statisch korrekt getypte Programme zur Ausführung zu bringen und sonst
gar nichts wirken
Die, was Fehlervermeidung anbetrifft, wenn das ein hohes Gut bei
der Programmentwicklung ist, ist das ein nicht zu bestreitender Vorteil.
So, von den elementaren Datentypen sind wir dann hin,
also zu selbstdefinierten Datentypen und wir haben da als Mittel kennengelernt,
das, was einem objektorientierte Programmiersprache mitgeben, nämlich wir können Klassen schreiben,
Java-Programme bestehen aus Klassen und aus sonst gar nichts.
Wir haben innerhalb zur Klassendefinition die Mittel kennengelernt, wir können
eine öffentlich sichtbare Schnittstelle für diese Klassen definieren in Form von Operationen. Sie sehen hier eine verändernde Operation,
diese verändernden Operationen arbeiten auf den sogenannten Exemplarvariablen und die Exemplarvariablen sind für so,
das ist so eine der Programmierregeln, die wir uns auferlegt haben,
sind immer als privat zu deklarieren, will heißen,
die sind von außen, wenn man eine Klasse bezüglich ihrer Schnittstelle betrachtet,
sind die nicht sichtbar, nach außen hin sichtbar, sind nur die als öffentlich deklarierten Methoden einer Klasse.
So, in dem Kontext kann man auch darüber sprechen,
dass so eine Klasse, eine selbstgeschriebene Klasse, eine Doppelrolle ausfüllt,
Einerseits sind die Klassen mit ihrer öffentlichen Schnittstelle nutzbar für Klienten,
sprich für diejenigen, die die Dienstleistung einer Klasse ausnutzen wollen und was die die Klienten von einer Klasse sehen,
sind Operationen und welche Parameter brauchen diese Operationen, um sie,
um sie benutzen zu können.
Die zweite Rolle einer Klasse, etwas,
was man nach außen hin verspricht, muss man nach innen auch implementieren.
Dazu gibt es dann also die Methoden Rümpfe einerseits,
also das, was die Methoden nach außen versprechen,
die Methoden Rümpfe implementieren und gleichzeitig welche Exemplarvariablen braucht es,
um die, das was in den Methoden an manipulierenden Operationen versprochen wird, um das realisieren zu können.
Und als letztes Mittel, um eine Klasse zu implementieren,
sind hier noch die privaten Hilfsmethoden genannt.
Also es ist nicht so Holzschnittartig, Methoden öffentlich, Exemplarvariablen privat.
Es gibt so eine dritte Möglichkeit, also sich selbst in Klassen zu strukturieren,
das sind die privaten Hilfsmethoden zur Implementierung öffentlicher Methoden.
Ich weiß nicht wirklich, warum, also Axel,
dieses Bild hier gewählt hat
Boah. So, also da kann man jetzt viel zu sagen,
aber ich halte es jetzt,
also es ist jetzt meine Interpretation,
eine nach außen hin sichtbare Schnittstelle muss nicht immer hübsch sein.
Und eine Implementierung muss nicht immer hässlich sein.
Das kann, also ein entschiedenes sowohl als auch sein.
Und soweit wie ich die Geschichte kenne,
ist also so Jackle und Hyde,
also diese eine Person ist ja dadurch gekennzeichnet,
dass die denn
jeweils anderen nicht kennt
Der schaltet ja dann um und dann ist ja jemand anders.
Das ist also gar bei einer Klasse,
die implementiert wird, ja gar nicht so.
Ich werde, hallo Axel, ich bin mir ziemlich sicher,
dass du diese Vorlesungen nicht im Internet anschaust.
Dafür muss der selbst viel zu viel vorlesen als Professor an der Fachhochschule.
Wir müssen das mal, wenn wir nochmal SE2 machen,
dann überlegen wir uns,
ob das wirklich die geeignete Darstellung ist für die Doppelrolle
einer Klasse
Dann haben wir also Klassen implementiert. Das ist ja schon
nicht schlecht. Jetzt können wir also selbst Programme schreiben und
es hat so öffentliche Methoden und private Variablen.
Und jetzt kommen wir noch mit etwas daher, die sogenannten Interfaces, Schnittstellen.
Was ist das denn? Und wozu ist das gut?
Dass wir jetzt noch so ein zusätzliches Sprachelement von Java kennenlernen,
also das heißt in Java Interfaces, in anderen objektorientierten Programmiersprachen,
heißt das anders, ist aber so vom Konzept her,
ist es da auch jeweils vorhanden und nicht immer vorhanden,
aber das ist häufig vorhanden.
Was sind Interfaces, das sind so wenn man es in
einem Wort sagen möchte, ein Interface ist ein Versprechen.
Ein Versprechen bestehend aus Methoden, Methodenköpfen, genauer gesagt.
Also nur der Name der Methode und die Anzahl der,
und die Typisierung natürlich der Parameter.
Keine Implementation, keine Methodenrümpfe, deswegen auch nicht.
Also als Objekt instanziierbar. Es braucht für diese Realisierung dieses
Versprechens immer Klassen. Jetzt kann man sich erstmal fragen,
Interface ist, wozu soll ich das verwenden?
Das ist einem durchaus berechtigte Frage. Das ist als Sprachmittel
auch noch nicht allzu lange. Also jedenfalls nicht so lange,
wie es objektorientierte Programmiersprachen gibt, in diesen Programmiersprachen als Mittel integriert,
sondern es erst später hinzugekommen.
Und was sie jetzt hier sehen, ist eine Verwendung
des Sprachmittels Interface im Zusammenhang gleich mit einer Klasse.
Also das Interface-Konto verspricht eine bestimmte Dienstleistung in Form von Operationen
und die Klasse Konto Impel sagt jetzt, okay,
ich verspreche jetzt dieses Versprechen einzulösen.
Und das tue ich, indem ich das dahin schreibe und
dann muss ich halt Implementationen von Einzahlen auszahlen.
Gibsaldo muss ich muss ich dann vorlegen. So,
und jetzt kriegt man eine allererste Ahnung an der Stelle vielleicht.
Also warum? Also Interface ist ein sinnvolles Sprachkonstrukt sein können.
Das Motto heißt, wir können jedes softwaretechnische Problem durch das Einführen einer Abstraktion lösen.
Jedes. Und wir können jedes Performance-Problem durch das Wegnehmen einer Abstraktion lösen. Und in diesem Spannungsfeld,
also das werden Sie jetzt im Weiteren auch noch kennenlernen,
ich werde dann sagen, wir können das so machen,
es diese Vorteile und diese Nachteile, oder wir können das so machen.
Und dann hat es diese Vorurteile und jene Nachteile.
Da werde ich sie jetzt, also hoffentlich weiter zu befähigen,
dass sie diese Abwägung treffen können und um das tun zu können,
müssen sie halt unterschiedliche Möglichkeiten der Realisierung kennenlernen. So,
wenn wir uns also dazu entscheiden,
zunächst mal ein Interface-Konto zu spezifizieren und dann eine Klasse zu schreiben,
die dieses Interface implementiert, dann haben wir zunächst mal die Möglichkeit,
uns eröffnet, auch andere Implementationen für dieses Interface vorzunehmen,
ohne dass es Klienten, der es Interfaces kontos eigentlich betrifft,
weil der Zusammenhang zwischen Interface, implementierender Klasse und Klientenklasse,
den sehen Sie hier, wenn also eine andere Anbieterklasse,
unser Interface implementiert, dann wird es die Klientenklasse,
also im Idealfall gar nicht merken.
Und das ist also Austauschbarkeit, Änderbarkeit, Erweiterbarkeit, diese Entwurfsziele,
diese sogenannten nicht-funktionalen Anforderungen an Software-Systeme werden durch dieses Sprachmittel unterstützt.
Das, was sie da auf der Folie jetzt auch noch sehen,
ist das, was wir hier geschaffen haben, ist,
dass wir zwischen Klientenklasse und Anbieterklasse eine Entkopplung vorgenommen haben.
Und Entkopplung ist etwas, können Sie,
werden Sie noch Software-Engineering-Bücher zu kennenlernen,
ist ein hochgehandeltes Entwurfsziel für die Entwicklung großer objektorientierter Software-Systeme
Dann sind wir also soweit, dass wir so
ein Stück Trennung auch ein, Entkopplung auch einführen können.
Wir können also jetzt Systeme gestalten auf der Ebene von Klassen,
selbst definierte Typen. Und wir haben also mit Interfaces die Möglichkeit,
diese, wie schon gesagt, diese Entkopplung vorzunehmen.
Und jetzt müssen wir uns nochmal unseren Typbegriff. Also jetzt
haben wir so ein Sprachmittel eingeführt und wie das immer so ist,
ist, also wir haben einen Effekt erzielt und denken,
alles ist gut, aber leider Gottes hat dieses, das Einführen,
nicht nur, aber auch das Einführen der Interfaces hat einen Einfluss darauf, auf unser Verständnis des Typbegriffs.
Wir haben bis jetzt, so wie ich das so... So,
wir müssen uns jetzt mit dem hier erweiterten Objekt orientierten Typbegriff beschäftigen,
die es so definiert, Typ definiert das Verhalten von Objekten durch eine Schnittstelle,
ohne die Implementation der Operationen und des inneren Zustands festzulegen.
So, jetzt sind wir wieder was, also unser Typbegriff ist,
jetzt haben wir also das, was Schnittstellen sein können, haben wir in diesen Typbegriff integriert. Das nächste,
der nächste Effekt, der jetzt durch die Einführung von Interface ist,
ich habe ja von Entkopplung gesprochen, der nächste Effekt,
der Eintritt ist,
dass wir uns die Unterscheidung zwischen dem sogenannten statischen Typ und dem dynamischen Typ,
einer Variable vor Augen führen müssen,
weil wir haben uns da jetzt nicht, ich will nicht sagen,
ein weiteres Problem geschaffen durch die Einführung von Interfaces,
wenn man eine Möglichkeit geschaffen, Entkopplung,
bloß diese Möglichkeit ist mit einem gewissen intellektuellen Aufwand bezüglich dessen,
wie sich so ein Programm zur Laufzeit verhält,
verbunden.
Und das gucken wir uns hier an der Stelle ein
Jetzt nehmen wir mal für den Moment an,
jetzt bitte nicht wieder, wo ist die, da ist sie.
So, es gäbe mal so eine Klasse Konto und es soll so
eine richtige Klasse sein, also nicht so ein Interface.
Und dann können wir Objekte von der Klasse Konto erzeugen und
sie den Bezeichner K der Variablen K zuweisen.
So, dann ist also der statische Typ von K ist Konto.
So, ja, so what, ja.
Alles andere würde uns jetzt auch überraschen, oder?
Und über diesen statischen Typ weiß ich halt, welche Operationen
sind an diesem Bezeichner aufrufbar. Also sowas hier. Okay,
der Compiler, wie gesagt, kann das statisch überprüfen.
Mit der Einführung von Interfaces und diesen neuen Möglichkeiten gibt es
jetzt also andere Effekte, die wir betrachten müssen.
Wenn wir jetzt nämlich davon ausgehen,
dass Konto keine Klasse mehr ist, sondern Konto ist ein Interface,
dann ist diese Zeile jetzt anders zu interpretieren und nicht anders,
dann muss man diese Zahl jetzt so interpretieren.
Es gibt also eine Variable K, die ist vom Typ
des Interfaces
Was der Compiler überprüfen kann, ist, okay,
es gibt also eine, da will jemand jetzt ein Objekt
erzeugen und dieses Objekt sei von der Klasse konto simpel.
Jetzt muss der Compiler also erstmal nachschauen,
gibt es eine Klasse konto simpel, wenn dem so ist.
Gut, dann kann ich die also auch Objekte von dieser Klasse erzeugen.
Und dann weise ich das Objekt der Klasse konto
simpel an einen Bezeichner vom Typ Konto zu.
So, der statisch sichtbare Typ von K
ist Konto
Von dem Interface, nämlich der dynamische Typ von K ist jetzt Konto simpel,
weil ich ein Objekt der Klasse Konto simpel an diesen Bezeichner gebunden habe.
Okay, soweit so gut. Jetzt sei es darüber hinaus
so, es möge eine Klasse Konto anders geben.
Wenn ich von der jetzt von dieser Klasse ein Objekt erzeuge und es an den Bezeichner K zuweise,
dann ist der statische Typ von K immer noch Konto,
bloß der dynamische Typ von K ist jetzt Konto anders.
Und die Frage, welche Operation aufgerufen wird,
wenn ich jetzt einen K die Operation einzahlen,
Aufrufe habe ich ja wahrscheinlich zwei Möglichkeiten,
nämlich Kang von Konto simpel oder vom Konto anders,
die Implementation aufrufen, ist abhängig davon,
von welchem dynamischen Typ der Bezeichner gerade ist, der kann sich ändern.
Das ist so, also sie beginnen jetzt,
also wir sind ja nicht jetzt,
aber so im Laufe des ersten Semesters haben sie angefangen,
das Wunder der Polymorphie,
das Wunder der Vielgestaltigkeit von Bezeichnen zu entdecken und das,
was ich ihnen hiermit hier und heute verspreche,
ist,
dass dieses Wunder ist noch viel größer
Als das, was sie bis jetzt kennengelernt haben.
Und am Ende des zweiten Semesters schon im Laufe des zweiten Semesters wird ihnen dieses,
wird ihnen dieses Wunder noch das ein oder andere Mal begegnen.
Also nicht, dass sie sich wundern. Es ist alles wird gut. So,
ein zweites großes Thema, nachdem wir jetzt also mit Kontrollstrukturen,
Typen, Klassen, Klassenvariablen, Methoden,
Interfaces uns beschäftigt haben, ist, wir haben uns dann,
also so nach meiner dunklen Erinnerung, so in der zweiten Semesterhälfte,
haben wir uns viel mit dynamischen,
also zunächst mit statischen und dann aber auch mit dynamischen Datenstrukturen auseinandergesetzt.
Einer davon habe ich hier mal so beispielhaft nochmal aufgelegt,
die Liste, wodurch es die gekennzeichnet,
also die dynamische Liste kann beliebig viele Elemente enthalten.
Es kann auf beliebige Positionen in der Liste zugegriffen werden und so weiter und so weiter.
Ich hoffe, ich löse jetzt bei Ihnen so Ja,
ja, stimmt. Also wahlweise, ja, ja,
stimmt, da war was oder komm,
jetzt mach mal hin, das wissen wir doch alles.
Okay, okay, für die zweite Gruppe, entschuldigen Sie,
ich rede im Wesentlichen zu der ersten Gruppe. So,
wir haben, also hier, grün sind das hier dargestellt,
das sieht bei Ihnen auch so aus,
sind die sogenannten sondierenden Operationen auf einem Interface und das hier,
oder auf einer Klasse, nachher in einer implementierenden Klasse und was in Rosa dargestellt ist, sind die sogenannten verändernden Operationen.
Also wenn die Objekte dann nachher anders sind als vor dem Aufruf der Operation. Das ist ja bei den sondierenden Umgangsformen nicht der Fall. So,
und jetzt sehen wir auch wieder den Zusammenhang,
also dass Listen so als Konzept, ja, ist schön und gut,
das, was man einmal in den Java, in JCF,
in Java Collection Framework, das, was einem zunächst,
nicht zunächst mal, aber das, was einem dort auch begegnet,
ist dieses Sprachkonstrukt, das ich gerade nochmal erklärt habe,
nämlich das Interface, das, was sie sehen, ist,
ach guck mal da, es gibt sowas wie eine Liste,
ich muss das nicht selbst implementieren, ich kann dieses Interface verwenden,
das haben wir uns gerade angeschaut, dann haben wir uns auch angeschaut,
wissen Sie bereits, wenn ich mich wieder ein Interface verwende,
wird es auch eine implementierende Klasse geben müssen.
Und siehe, da gibt es auch. Und wir haben
dann so im Laufe des Semesters so uns auch angeschaut,
wie ich das vorhin schon so sagte,
was sind die Vor- und Nachteile der verschiedenen Implementationen von List,
also hier in diesem Fall, von Linked List oder Arraylist.
Beide implementieren dieses Interface und je nachdem, welchen Anwendungsfall man betrachtet,
also welche Arten von Operationen häufiger vorkommen,
wird man sich dann entscheiden für die Linked List als Implementierung oder die Arraylist als Implementierung.
Beide implementieren dasselbe Interface
Und wir haben uns dann als eine dynamische Datenstruktur,
wir haben uns noch mit Bäumen beschäftigt, Graphen habe ich,
glaube ich, nicht vorgelesen, oder?
Fred? Habe ich nur als Folien irgendwann mal gesagt,
nee, du musst jetzt so sagen, doch,
klar, ich erinnere mich.
Fred sagt, er erinnert sich nur an Carol.
Okay, wir haben uns als eine dynamische Datenstruktur dann noch
mit dem Stack beschäftigt
Über Schlangen habe ich auch noch gesprochen. Der ist Deck als die klassische dynamische Datenstruktur,
die nehmen wir mal, diese Ausgangssituation,
dadurch gekennzeichnet ist,
dass also auf dem Stack liegen diese beiden Elemente und dann wird auf den Stack die Operation Push aufgerufen,
dann ist ein obendrauf wird ein X gelegt,
dann wird ein Z draufgelegt und dann rufen wir Pop auf,
das heißt ein Element soll heruntergenommen werden vom Stack
und dann sieht der Stack halt so aus
Und dieses Prinzip der Organisation bezeichnet man als Lifo,
last in first out. So, das ist,
wenn ich jetzt über UML und API und Lifo und FIFO first in first out,
das ist die Organisationsstruktur der Schlange. Ich weiß nicht,
ob sie das amüsant finden, fänden,
dass sie einfach mal die sämtliche zwei und drei buchstabigen Abkürzungen,
von mir aus auch vier buchstabige,
wo wir gerade über Lifo und FIFO kennen,
dass sie die aufsammeln und ob die für sie im Rahmen
ihrer Ausbildung eine Rolle gespielt haben
Ja, sich möglicherweise wundern, wie viele von denen,
also in der Softwareentwicklung eine Rolle spielen.
So, der ist Deck, so,
damit haben wir uns so in den letzten Wochen des Semesters beschäftigt,
als eine Ausprägung einer dynamischen Datenstruktur.
Jetzt habe ich darüber gesprochen, so,
das sei es mal für den Moment,
womit wir uns in der Vergangenheit beschäftigt haben.
Und das ist der Plan für dieses Semester.
Wir befinden uns gerade im Rap-Up
Und sie sehen, womit sie sich, also,
und ich könnte mal ganz kurz was dazu sagen,
womit wir uns in der Vorlesung beschäftigen werden und nur ein einziges Wort darüber,
also was ihnen in den Übungen begegnen wird und das hier ist,
also diesen Begriff wollte ich kurz erläutern.
Sie werden jetzt im zweiten Semester, ja.
Ich weiß, meine Zeit ist zu Ende
To home the bell talls, yeah. Sie werden sich
mit einer Programmierumgebung namens Eclipse beschäftigen. Und da kann ich
jetzt nur sagen, herzlich willkommen. Eclipse ist die Programmierumgebung im Java-Umfeld,
mit der nach bestem Wissen und Gewissen sich auch die allermeisten Leute,
die sich mit Java außerhalb der Universität beschäftigen, die die verwenden.
Das heißt, die sind jetzt schon angekommen,
also mindestens auf der Ebene der Verwendung der Programmierumgebung,
sind sie schon im professionellen Umfeld angekommen.
Blue Jay ist ab nächste Woche, ist es dann Geschichte,
Freirad, Kinderkram. Jetzt geht's an die richtige Programmierumgebung.
Also da können Sie jetzt schon spätestens in drei, vier Wochen,
können Sie einen Haken dran machen. Eclipse wird sie dann,
solange sie sich mit Java beschäftigen, gibt es eine hohe Wahrscheinlichkeit,
dass Ihnen das im wirklichen Leben auch begegnet. So,
ansonsten sehen Sie jetzt hier hoffentlich auf, nein,
nicht hoffentlich, ich vermutlich auf die Begriffe,
die in der Vorlesung für das Semester stehen,
schauen Sie ähnlich verwundert, wie auf das,
was ich Ihnen für das erste Semester angeguckt gekündigt habe und weniger verwundert als auf das,
was ich Ihnen gerade erläutert habe,
was wir im ersten Semester gemacht haben.
Was ein Satz. Wir werden uns also mit so Themen,
also jetzt die ersten paar Wochen, werden wir uns mit einem Thema beschäftigen,
das sich vergleichsweise juristisch anhört, nämlich mit Vererbung.
Wir werden uns mit dem sogenannten Vertragsmodell der Softwareentwicklung auseinandersetzen.
Das sind zwei ganz fundamentale Prinzipien der objektorientierten Programmierung.
Und deswegen werden wir das auch in einiger Breite behandeln.
Wir werden dann so in der zweiten Hälfte oder sagen wir
mal so im zweiten Drittel des Semesters,
werden wir uns mit so Fragestellungen beschäftigen
Muss man über die reine Kenntnis der Programmiersprache hinaus, braucht es noch,
also etwas mehr Gedankengut, um größere Softwaresysteme zu strukturieren.
Und ich stelle die Frage jetzt zwar so offen in den Raum,
aber die klare Antwort darauf heißt, ja.
Und deswegen werden wir uns mit so einem Modellierungsansatz und Möglichkeiten der Strukturierung,
so vor allem der Begriff der Entwurfsmuster,
wird uns da begleiten, werden wir uns beschäftigen.
Das Ziel der Beschäftigung mit diesen Themen ist,
dass sie nicht nachher vor einem Haufen von Klassen stehen und denken,
verdammt nochmal
Wo habe ich denn das jetzt eigentlich schon wieder implementiert?
Und dann auch nicht durch Sicht dann durch tausende Zeilen lange
Klassen bewegen müssen oder durch in zig Klassen nachgucken müssen,
wo eine bestimmte Funktionalität implementiert ist. Das wird alles passieren,
dass wenn sie diese Vorlesung gehört haben, ist es aber ihr Problem,
also weil sie dann bestimmte Sachen nicht beachtet haben,
die sie hätten vermeiden können.
So, im letzten Teil der Vorlesung werden wir uns dann
schon mit etwas abgehobeneren Themen des Objekt, der Objektorientierten Programmierung beschäftigen,
insbesondere Und das ist das Letzte, was ich dazu sagen möchte,
ist, werden wir uns mit etwas beschäftigen.
Das wird sie auch ihr Berufsleben lang verfolgen. Das ist
das sogenannte Refactoring. Sie haben etwas gebaut und sie wissen,
was sie getan haben. Und sie wissen, es ist
nicht gut. Den wenigsten von uns ist es vergönnt,
Software im ersten Wurf so zu schreiben, wie sie sein soll.
Selbst nach eigenen Maßstäben sein soll. Und deswegen bringen wir ihnen bei,
Techniken, mit denen man Software so verändern kann,
dass sie wieder Qualitätsansprüchen genügt, ohne dass sie ihre Funktionalität verändert.
Man sieht dann jemand fragt, nach einer Woche, was haben sie getan?
Weil nach außen hin sichtbar ist eigentlich kein Unterschied.
Dann können sie sagen, ich habe meine Software girly factord,
Mike. Ja, dann haben sie ein Problem.
Ja, bitte. Das ist alles so für die Freunde
der deutschen Sprache, bitte ich jetzt schon um Verzeihung.
Also ich gucke das nochmal nach,
wie man das im Deutschen bezeichnen könnte,
aber das tue ich,
während Fred jetzt das Ruder übernimmt und willkommen Fred Winkler
in RC
Musik So, ich glaube,
dieses Mikro wurde nicht für Leute mit langen Haaren designt.
Ich sehe wahrscheinlich aus, wie jemand aus Herr der Ringe, oder?
Haben die nicht auch mal die Haare so nach hinten?
So. Okay, ich habe euch natürlich gleich Eclipse mitgebracht.
Also Blu-ray wird tatsächlich überhaupt nicht mehr verwendet. Okay,
es gibt Eclipse, wer hat schon mal Eclipse verwendet?
Einmal Handtuch? Oh, toll. Aber man kann
immer noch was Neues lernen. Also ich benutze Eclipse auch
schon seit über zehn Jahren und jedes Mal,
wenn ich jemandem zuschaue, denke ich so, huch,
das kannte ich ja noch gar nicht,
was er
da gemacht hat
Okay, wie fangen wir an? Ich brauche immer so
zu Beginn eines Semesters so eine kleine Aufwärmübung.
Ich wollte euch einfach mal zeigen, was habe ich eigentlich so gemacht?
Während ihr vielleicht in der Sonne gelegen habt oder so.
Und zwar, es gab ja eine Klausurauufgabe, da ging es um bulischer Ausdrücke.
Und die Aufgabe war in der Klausur, schreibt doch mal eine Funktion,
die kriegt irgendwie ein A und ein B und ihr sollt genau dann True zurückgeben.
Wenn eine dieser beiden Variablen True ist,
und ich hatte da ganz interessante Lösungen gesehen,
also eine Lösung sah zum Beispiel so aus, Ich prüfe,
ob Artrue ist und B nicht true ist oder alternativ erlaube ich auch den Fall andersrum.
Ist meine, ist das mit dem Mikro so okay?
Das klingt ja so ein bisschen, ja, okay.
Und dann sehe ich das so und denke, oh Gott,
ist das jetzt korrekt? Meine Musterlösung sieht ja ganz anders
aus. Was mache ich denn jetzt? Muss ich mir
da irgendwelche Wahrheitstafeln aufstellen oder so? Nee, nee,
was macht ein Informatiker? Er schreibt ein Programm,
was diese Formeln entgegennimmt und das dann vereinfacht.
Und bulische Ausdrücke kamen ja auch in SE1 dran,
das passt nochmal ganz gut als Wiederholung.
Hat jemand eine Idee, wie man das vereinfachen kann,
bevor ich jetzt einfach auf Enter drücke
Könnte man das leichter sagen. Das ist genau eine der Variablen.
AXOB, richtig. Den X-Orperator kennen die meisten nicht.
Hat jemand noch einen anderen Vorschlag? Einen bulischer Ausdruck,
der sagt, genau eine Variable ist true. Ah,
ungleich b. Mal gucken, was mein Programm sagt. So,
und was ich voller Schock festgestellt habe, ist diese Tüte,
in der ich seit Monaten nicht reingeguckt habe,
da sind noch zwei Snickers drin.
Ja, also ein Snickers, ich hoffe,
da sind Haltbarkeitsdaten drauf, oder?
Für den Herrn mit A. Ungleich b. Sehr schön,
kannst du dir nach der Vorlesung abholen
Ja, also das fand ich super. Der andere Vorschlag
war A, X OB, das war das hier.
Das läuft also auf dasselbe hinaus,
zu sagen, genau einer von beiden muss Tu sein,
ist dasselbe wie, sie müssen verschieden sein.
Ist irgendwie logisch, oder? Toll, damit kann man
rumspielen. Okay, nachdem meine Stimme jetzt aufgewärmt ist,
können wir was anderes machen. Das waren also jetzt hier
bulische Grundlagen. Ich wollte mal mit euch einen Stack bauen.
Dazu legen wir uns mal ein neues Java-Projekt an.
Wie wollen wir das nennen? Stack, mir fällt nichts
, nichts Schöneres ein. Das ist egal,
nimm mal den Default und mach mal Finish
Jetzt haben wir also ein wunderbares neues Java-Projekt.
Vielleicht wollt ihr das ja auch mal irgendwann machen,
könnt ihr dann auf dem Video nachgucken, wie man das macht.
Und ihr seht hier einen sogenannten Source-Folder.
Da werden die ganzen, eure ganzen Quelltexte dann abgelegt.
Ich kann jetzt immer mit der rechten Maustaste raufklicken und sagen,
new, Interface. Ich will ein Interface haben für Stacks
. Und jetzt gibt es verschiedene Varianten von Stacks.
Vielleicht sollte ich da nochmal ganz kurz mein Grafikprogramm aufmachen,
dass euch das klar ist. Ich bin ja immer dafür,
dass man sich einmal kurz verantwortet, worum geht es überhaupt,
bevor man in die Implementierung reinspringt.
Ja, da sind wir
Machen wir mal kurz eine neue Landwand. Was sind Zahlen
, die Informatiker lieben? Zum Beispiel sowas. Okay,
das ist meine Leinwand-Layers, brauche ich eigentlich nicht,
das schiebe ich mal zur Seite.
Und man kann sich jetzt vorstellen, man hat einen Stack.
Also ich habe vielleicht einen Stack. Da liegen jetzt vielleicht irgendwelche Zahlen drauf,
vielleicht liegt hier die vier und da drüber liegt vielleicht die zwei oder so.
Ja, so ähnlich sah das auf Guidos Folien da auch aus.
Und jetzt kann man sich die Frage stellen,
wenn ich jetzt diese Operation Push aufrufe,
was passiert dann eigentlich
Da gibt es jetzt zwei Möglichkeiten, wie man das interpretieren kann.
Die erste Möglichkeit ist zu sagen, ich tue es halt hier obendrauf,
der Stack, der eben noch zwei Elemente hatte,
der soll jetzt eben drei Elemente haben.
Das wäre die Variante, wo man sagen würde,
ich verändere einen Stack. Ja, also ich habe einen Stack,
momentan hat er zwei Elemente und wenn ich irgendwie einen Operationen Push-Aufruf wird,
dann hat er anschließend drei Elemente.
Es ist aber immer noch derselbe Stack, der Stack,
den ich hier gedanklich in meiner Hand halte.
Ja, das ist die Variante,
die man meistens sieht und die ihr möglicherweise auch in Woche 14,
wenn ihr so weit gekommen seid, selber implementiert habt.
Aber es gibt noch eine andere Variante,
dass man sagt, ich habe irgendwie diesen Gedanken,
dass es diesen Stack gibt mit der 4 und der 2
und ich habe den Gedanken,
dass es einen anderen Stack gibt
Wo die vier, die zwei und zum Beispiel die sieben drauf ist.
Und wenn ich von diesem Stack zu diesem Stack kommen will,
dann rufe ich die Operation Push auf.
Ich schreibe das jetzt nicht hierhin, das dauert so lange.
Also um von hier nach dazu kommen, muss ich Push 7 aufrufen.
Das kommt euch jetzt vielleicht erstmal ein bisschen komisch vor.
Aber das sind eben zwei mögliche Varianten. Beide sind gültig
und ich wollte einfach mal beide mit euch programmieren.
Nö, das glaube ich ist nicht so wertvoll,
was ich hier gemalt habe.
Okay, fangen wir mal an mit dem zweiten Modell.
Also dieses Modell, der Stack ist eine Idee,
ein unveränderlicher Stack und ich kann daraus
andere Stacks generieren
Ich nenne den mal so, der wird gerne in anderen Programmiersprachen
so bezeichnet, die viel Wert auf dieses zweite Modell legen.
Und dann überlegen wir uns mal, was da so alles rein soll.
Also wir brauchen, ich mache jetzt erstmal ein bisschen Pseudo-Code,
wir brauchen irgendwie Push,
wir brauchen irgendwie Pop und wir wollen vielleicht auch mal schauen,
was ist denn obendrauf?
Das reicht mir, glaube ich, schon für den Anfang.
Okay, jetzt müssen wir uns überlegen,
was sind denn da sinnvolle Signaturen?
Also ich habe einen Stack und ich will jetzt dieses Push aufrufen.
Was muss ich denn dann da reinstecken?
Als Parameter, ja
Den Wert. Und vielleicht nehmen wir mal Zahlen.
Das ist vielleicht das Einfachste. Ich glaube,
wir werden heute nicht so weit kommen, dass wir noch
so einen Ausdrucksauswerter schreiben. Aber wir nehmen mal Double-Zahlen,
Double bekommen nicht genug Liebe, ich nehme heute mal Double-Zahlen.
Also, so und jetzt ist die Frage, was ist der Rückgabetyp?
Also wenn es jetzt dieser veränderliche Stack wäre,
würde ich einfach Void sagen. Ich würde sagen,
okay, vorher war der Stack so,
ich tue ein X drauf und dann hat der Stack sich an sich verändert,
aber liefert mir keine Informationen zurück.
Ich will jetzt aber einen anderen Stack zurückliefern. Das würde man
dann so schreiben. Okay? Ich habe den Stack,
rufe Push auf und bekomme einen neuen Stack,
wo dieses X obendrauf ist.
Und vielleicht schreiben wir das auch mal ruhig hier als Kommentar.
Gott, wir klipsen mit seiner ganzen Magie
Könnte man doch zum Beispiel sagen, Returns,
Fresh Stack with X on top.
Fresh klings, als wenn der neu wäre. Another,
sagen wir mal, Another Stack with X on top.
Okay. Gut. Wenn wir schauen wollen,
was obendrauf ist, muss ich dann irgendwelche Parameter übergeben?
Ich habe den Stack, ich sage dem Stack,
hey, ich will wissen, was obendrauf ist.
Braucht er noch irgendwelche zusätzlichen Operationen für diese Anfrage?
Und wenn ja, welche? Keiner meldet sich,
das heißt, wir brauchen keine Informationen.
Richtig. Gut, was liefert denn das Deck mir zurück?
Also ich habe irgendwie diese Zahlen 4-2-7
und ich will wissen, was ist obendrauf,
was ist der Rückgabetyp der Operation top
Ja. Double, genau. Sehr schön. Dann haben
wir nur noch eine Operation. Ach, jetzt habe ich
meine Grafik schon zugemacht, das ist ja blöd.
Vielleicht hätte ich sie in den Hintergrund schieben sollen.
Also, das Push war die eine Richtung. Ich habe
diesen kleinen Stack und durch das Push kriege ich einen größeren Stack zurück.
Und das Pop ist jetzt genau das Gegenteil.
Ich habe diesen größeren Stack, will das oberste Element entfernen
und bekomme da wieder einen kleineren Stack.
Okay. Da muss ich also nichts reinstecken und bekomme einen
Stack zurück. So. Okay, vielleicht sagen wir auch nochmal
kurz Returns
The Element on top of the Style. Ich muss sagen,
wir hier, Returns, The Stack, Below, The Top Elland,
Element. So. Machen wir das mal ein bisschen größer,
dass alle alles sehen. Okay. Auch das Public,
hier brauchen wir noch gar nicht,
dass man vor Interface so einen Klassen auch Public schreiben kann,
das wissen wir ja noch gar nicht.
Das kommt erst in ein paar Wochen. Ja,
das ist also unser Stack Interface. Das könnte ich jetzt
irgendwie an die Wand kleben und alle Leute,
die diesen Stack benutzen wollen, wissen schon mal genau,
wie die Umgangsfonds mit diesem Stack ist.
Ich kann was auftun, ich kann mir gucken,
was oben drauf ist. Ich kann was runternehmen.
Wie implementiert man sowas jetzt? Da kann man sich einfach
mal angucken, wie wird das in anderen Programmiersprachen implementiert,
wo sowas in der Standardbibliothek drin ist.
Und das ist ganz lustig. Ich glaube, ich starte
Gimd doch nochmal ganz kurz. Wieso war es normalerweise implementiert
ist? Ich versuche jetzt UML mit Gimd zu malen.
Das wird lustig. Also ich deute das natürlich jetzt alles nur so an.
Also ich habe hier oben mein Interface-Stack. Das denkt ihr
euch jetzt bitte, dass das das Interface sein soll?
Okay. Und dann Haben wir zwei Implementationen dieses Interfaces?
Wir sagen also, es gibt zwei grundsätzlich verschiedene Klassen von Stacks.
Ich schreibe das vielleicht mal dahin. Das hier nennen wir
mal Empty. Also ich schreibe eine eigene Klasse für den
Fall, dass der Stack leer ist.
Das ist so das Standardverfahren, wie man sowas in anderen Programmiersprachen macht.
Und man kann sich vielleicht vorstellen, welcher Fall das ist,
das ist der Fall, dass der Stack nicht leer ist.
Okay. Wir müssen jetzt also zwei Klassen schreiben für dieses Interface,
was wir gerade definiert haben.
So, mit welchem fangen wir mal an?
Ich fange mal mit dem Nichtlehren an. Das ist,
glaube ich, einfacher. Ich mache vielleicht nochmal eine
kleine Zeichnung
Dass wir uns mal die dynamische Struktur eines solchen Stacks vorstellen.
Das haben wir bis jetzt ja gar nicht gemacht.
Dieses Klassendiagramm, was nur aus drei Kästen bestand,
das zeigt ja nur die statische Struktur.
Wie ist die dynamische Struktur eines solchen Stacks?
Also das muss ich jetzt hier mit runden Ecken machen,
Objekte haben in OML, also runde Ecken.
Ein Stack oder machen wir das mal nach unten?
Mein Stack wächst ja vielleicht so in die Richtung.
Also, ein Stack fängt immer so an,
dass ich mit dem leeren Stack anfange.
Das wird der leere Stack. Ich schreibe mir einfach mal
E, ja, das ist der leere Stack.
Und ich kann jetzt auf diesen leeren Stack ein Element rauftun.
Wenn ich das tue, wenn ich hier ein Element drauf
tue, Zum Beispiel die zwei.
Ja, dann muss ich sicherlich irgendwie die Informationen,
dass sie sich um die zwei handelt, in diesem Objekt abspeichern.
Und ich muss auch sicherlich irgendwie dafür sorgen, dass sie so eine Verkettung stattfindet.
Diese Verkettung kennt ihr vom Thema Linklist. Und wenn ich
jetzt noch ein Element rauftue, geht das hier so fröhlich weiter.
Ich will vielleicht die vier noch rauftun. Und der Knoten
kennt dann den etwas älteren Knoten und das Spiel kann ich beliebig weiterspielen.
Aber die Erzeugungsreihenfolge fängt immer unten an. Ich fange mit
dem leeren Stack an und dann baue ich mir ein Stack,
wo die zwei drauf ist,
dann baue ich mir ein Stack,
wo auch noch die vier drauf ist,
dann baue ich mir ein Stack,
wo auch noch die sieben zusätzlich drauf ist und so weiter
Gut. Was würdet ihr denn vermuten,
was man dann für Exemplarvariablen braucht, in der Klasse,
die für nicht leere Stext verantwortlich ist?
Okay, du hast schon sofort eine Idee.
Ich stelle die Frage mal kurz in den Raum.
Ihr müsst euch also irgendwie diese sieben irgendwie merken und
ihr müsst euch irgendwie diesen Pfeil merken.
Wie würde man das in Java programmieren, eine Zahl und
ein Pfeil? Wer hatte heute noch nichts gesagt?
Hatte sich nicht noch eben irgendjemand anders gemeldet?
Da. Ich glaube, es war richtig. Kannst du
mal ein bisschen lauter sagen? Wir brauchen einen Stack und
einen Double,
sehr schön
Dann mache ich doch jetzt mal folgendes. Wir machen uns eine neue Klasse.
Diese neue Klasse soll jetzt Stacks beschreiben, die nicht leer sind.
Und klassisch heißt diese Klasse immer so. Okay,
ich mache das jetzt nur, damit die Recherche für euch
einfach ist, wenn ihr das Thema interessant findet.
Recherchiert mal, dann werdet ihr genau auf diese Begriffe stoßen.
Okay. Wie kann ich denn jetzt sagen,
dass diese Klasse das Interface Persistant Stack implementiert?
Die Frage ist, glaube ich, einfach, oder?
Das ist so das Niveau vom Programmierdeklar, was euch demnächst erwartet.
Diese Klasse, die ich jetzt hier vor mir habe,
soll das Interface per Sistant
Stack implementieren
Jetzt nicht. Okay, du bist schon ein Schritt weiter,
was wir dann tatsächlich programmieren müssen. Aber wie kann ich überhaupt
dem Typsystem sagen, diese Klasse implementiert das Interface, ja?
Genau. Gibt es hier eigentlich auch so eine Autovervollständigung?
Steuerung, Lehrtaste? Ah, gibt es toll.
So, und jetzt beschwert sich Eclipse sofort. Ja,
und das ist viel angenehmer später,
als jetzt zum Beispiel in BlueJay,
wo ihr noch gar nicht merken würdet, dass es ein Problem gibt.
Er beschwert sich jetzt sofort und sagt, hier ist ein Problem.
Ich gehe einfach mal mit der Maus hier drüber und ihr
sagt mir ganz viele verschiedene interessante Dinge
The type cons must implement the enherited abstract method persistence stack
pop, push, top. Ja, klar,
ich habe ja hier versprochen oder ich, ja,
das ist erstmal nur das Versprechen, dieses Interface zu implementieren,
aber ich habe es nicht gemacht.
Und der Compiler findet das nicht so lustig. Gut.
Jetzt haben wir in Bluejay das immer von Hand geschrieben,
aber es geht viel einfacher. Ich kann immer,
wenn in einer Zeile so ein Problem ist,
kann ich einfach sagen, Steuerung eins und dann kommen hilfreiche Vorschläge.
Er sagt, du könntest entweder den Typ abstrakt machen,
das kennt ihr noch gar nicht, das kommt erst später.
Oder Add-un-Implemented Methods. Also füge doch mal alle Methoden hinzu,
die bis jetzt noch fehlen. Und er sagt mir
sogar hier links, welche das sind. Hier,
diese drei wurde er hinzufügen, das ist doch toll,
das machen wir mal.
Seht ihr
Jetzt beschwert sich das Typsystem nicht mehr.
Natürlich sind die Implementationen hier nicht besonders sinnvoll. Also immer,
wenn ihr ein Referenztyp zurückliefert, dann wird hier Nyle zurückgeliefert.
Für Doubles wird null zurückgeliefert. Also das ist noch nicht
wirklich das, was wir wollen.
Aber ich muss das nicht mehr alles von Hand tippen.
Das ist doch schon mal ganz nett. So,
jetzt hatte ja der eine Herr schon gesagt,
wir brauchen einen Double und die Referenz auf den Stack unter uns.
Programmiere ich das nochmal. Also klassisch nennt man das Element
immer gerne. Head und man nennt den Stack unter einem,
nennt man gerne, Tale. Weil man sich diese Stacks
auch oft gerne so waagerecht vorstellt und dann ist es wie so ein,
Ja, wie so ein Monster oder sowas aus dem Kopf und einem Rest besteht.
Ich glaube, so toll ist die Analogie doch nicht,
weil der eigentliche Körper ist dann hier gar nicht dabei.
Vergesst, dass ich das gesagt habe. Okay,
was auch noch interessant ist, ich kann diese Dinge ruhig unveränderlich machen.
Und dann beschwert sich der Compiler nochmal. Er beschwert sich
jetzt mit folgender Meldung. Gut, einmal beschwert er sich,
dass wir das gar nicht benutzen,
was wir da programmiert haben und er beschwert sich,
dass wir das vergessen haben, zu initialisieren.
Wie initialisiere ich denn Exemplarvariablen? Was brauche ich dafür,
ja? Ja, und wo macht man das normalerweise,
diese Wertzuweisung
Ja. Im Konstruktor? Toll. Schreiben wir mal einen Konstruktor
. Wollen wir den wirklich selber schreiben? Mal sehen,
ob nicht Eclipse für uns den Konstruktor schreiben kann.
Gucke ich mal. Generate Constructor Using Fields, das will ich.
Also ich will, dass der Konstruktor diese beiden Exemplarware,
ihr habt dann initialisiert, ich gucke mal einfach,
was dabei rauskommt.
Das ist schon fast das, was ich haben will.
Was ist denn jetzt noch nicht so schön?
Das könnt ihr noch gar nicht verstehen. Das lösche ich
mal. Was ist in der Zeite nicht
so schön?
Genau, die Benennung ist nicht so schön, ne?
Jetzt würde ich normalerweise, ich mache es einmal von Hand,
ich kann jetzt hier diesen Unterstrich löschen,
dann beschwert er sich hier, dass er diese Variable gar nicht kennt,
dann muss ich ihn hier auch löschen.
Okay. Aber was auch in den Clips geht,
ich kann an eine beliebige Stelle gehen,
wo ein Bezeichner verwendet wird und kann sagen, als Shift Air.
Und dann achtet man darauf,
wenn ich jetzt hier was verändere, was dann hier passiert,
ich lösche mal den Unterstrich.
Ihr müsst also nicht mehr euch selber überlegen, hm,
hier wird die Variable definiert oder wir nennen es auch deklariert in Java.
Wo wird die denn jetzt überall benutzt,
wenn ich sie jetzt hier anders nenne?
Da muss ich ja an alle Stellen gehen,
wo sie benutzt wird und von Hand dieselbe Änderung vornehmen.
Da wird man ja verrückt in größeren Quelltexten. Das geht
ja einfach automatisch. Altshift Air, benennt es um,
Enter, überall ist es dann konsistent mit umbenannt.
Und dann brauche ich auch diese komische Wisspunkt nicht mehr,
weil jetzt ja die Parameter anders heißen als die Felder.
Ja, was glaubt ihr, warum man sich jetzt noch beschwert?
Also das ist jetzt nur noch gelb und nicht mehr rot,
hat jemand eine Idee, was dieses Gelbe bedeuten könnte.
Hier sind ja viele erfahrene Eclipse-Experten.
Was heißt das?
Richtig, wir verwenden sie nicht. Der Compiler merkt also,
du hast hier irgendwie Speicher reserviert für einen Double und eine Referenz,
du stoppfst da Werte rein, aber du guckst dir niemals an.
Das ist wahrscheinlich nicht so sinnvoll. Gut. Dann gehen
wir doch mal vielleicht als erstes zu dieser Operation.
Also wir haben diesen Stack und ich will wissen,
was obendrauf ist. Vielleicht mache ich ja einmal Vollbild,
dass hier mal so ein bisschen mehr Quelltext seht.
Was glaubt ihr, was man hier sinnvollerweise zurückliefern sollte statt null?
Was ist denn oben auf dem Stack drauf?
Ja. Genau, Head ist obendrauf
So, und ich sehe auch immer, dass viele Leute mehrere Sekunden brauchen,
um eine Zeile zu löschen, da werde ich immer ganz wahnsinnig,
drücke einfach Steuerung D, dann wird die aktuelle Zeile gelöscht.
Und wenn ihr das aus Versehen macht, dann drückt
ihr Steuerung Z, dann wird das wieder rückgängig gemacht.
Okay. Gut, welcher Stack liegt denn unterhalb des obersten Elements?
Können wir da irgendwas Sinnvolles zurückgeben? Je nachdem,
warum du dir den Stack anguckst,
aber wir haben ihn ja von unten nach oben befüllt und ich will jetzt wissen,
okay, ich weiß, was oben ist,
das kann ich mir mit Top angucken.
Ich will wissen, welcher Stack ist da drunter.
Tale, genau
So. Okay, jetzt kommt eine etwas spannendere Frage.
Also ich habe ein Stack, da sind ein paar Elemente
drauf und ich will jetzt einen neuen Stack generieren,
wo dieses X noch zusätzlich obendrauf ist.
Ja, du weißt es, vielleicht nochmal kurz gucken,
ob irgendjemand anders oder zumindest, dass ihr die Chance habt, darüber nachzudenken.
Du hast noch nichts gesagt. Ja, du willst
einen neuen Stack zurückgeben, das schreibe ich mal kurz.
Also New Cons, ja.
Genau, ich will ja ein Stack zurückliefern, unter dem ich selbst bin.
Okay. So, toll. Warum wirst du du nicht mehr?
So. Und das ist eigentlich auch schon die ganze Implementation für diesen Fall.
Ich lasse das mal kurz stehen und frage mal kurz, ob es irgendwelche Fragen bisher gibt.
Das ist ja alles zwar in irgendeiner Form mal dran gewesen in SE1,
also so ein paar primitive Typen, Double,
ist uns klar, das ist irgendwie eine Kommazahl,
wir wissen, was dieses Final bedeutet,
Private, aber vielleicht ist das alles so lange her,
dass sie doch eine oder andere Frage habt ihr jetzt nochmal
kurz geklärt haben wollt,
bevor es weitergeht
Nee, alles, alles trivial.
Okay. Ja. Ignoriert das
den Kontext der
Nee, er versteht tatsächlich den Kontext. Also er versteht,
dass das eine Variablendeklaration ist. Und wenn du hier eine
Variable Fuba hast und hier eine andere Variable Fuba und willst
dieses Fuba umbenennen, dann wird das Unteren nicht umbenannt.
Wenn es eine andere Variable ist. Also Eklips versteht wirklich
die Semantik, dieses Java-Programms. Das ist ziemlich cool.
Okay. Ja, wunderbar, dann machen wir doch mal
gleich weiter. Wir haben eigentlich schon das Schwierigste geschafft,
diesen leeren Stack zu implementieren, das ist eigentlich ziemlich trivial.
Also ich will eine Klasse haben,
die heißt immer gerne Nil,
wie gesagt,
wenn ihr da
mal forschen wollt
Das Public, brauchen wir. Habe ich das Public hier
auch gelöscht? Habe ich gemacht und hier auch? Ja.
Gut. Dann sage ich wieder, das implementiertes Interface.
Per Assistant Stack. Dann beschwert er sich wieder, dann sage ich wieder,
hey, bitte implementieren wir doch mal hier das alles.
Und dann überlegen wir mal, was da sinnvoll ist.
Vielleicht gucken wir erst mal ganz kurz, brauchen wir irgendeinen Zustand?
Also dieses E habe ich jetzt ja nur reingemalt,
damit euch klar ist, das handelt sich um den leeren Stack.
Also müssen wir hier irgendwelche Zahlen reinspeichern oder müssen wir
irgendwelche Referenzen da reinspeichern in den leeren Stack
Dich als zu wählen, aber unsere Methoden müssen keines übergeben.
Ja, genau, aber wir brauchen keine Zustandsfelder, ne?
Das ist doch schon mal ganz gut. Okay,
das heißt, ich muss hier oben nichts mehr reinschreiben.
Gut, was ist mit dem Push? Macht es einen Unterschied,
ob ich auf einen Leons Deck zum ersten Mal
was rauf tue oder ob ich ein Steck habe,
wo schon was drauf ist und ich will dann noch mehr rauftun?
Macht keinen Unterschied, ne? Jetzt mache ich was Böses,
weil wir noch keine Vererbung kennen und kopiere mir
den Quelltext jetzt einfach mal
Das ist toll. Wir werden dieses Projekt in den
nächsten Wochen immer wieder anfassen können und sagen, ha,
jetzt haben wir was Neues dazugelernt.
Jetzt brauchen wir diese Code-Dublizierung nicht mehr. Gut. Was ist
auf dem leeren Stack für eine Zahl gespeichert? Ähm,
Nall ist ja kein, nichts,
was ich in einem, also wie soll ich sagen,
der Datentyp Double enthält nicht Nall.
Ja. Oh, das könnte man
tatsächlich nehmen,
Not a number ist eine Zahl, die keine Zahl ist.
Ja, vielleicht machen wir Folgendes. Wir werden ja noch über Fehlerbehandlung reden.
Und dann werden wir uns diesen Quelltext nochmal angucken und uns überlegen,
kann man hier nicht was Sinnvolleres tun, als eine Quatschzahl zurückzugeben?
Momentan können wir das noch nicht.
Aber wenn wir so ein bisschen über Acceptions geredet haben,
dann werden wir hier nochmal zurückkommen und da was Besseres reinschreiben.
Und hier unten, ja,
dann nehme ich mal das To-Do, kopiere ich mir mal,
da müssen wir sicherlich auch irgendwann mal was Sinnvolleres tun.
Und hier kann man Hier gibt es jetzt im Prinzip zwei Varianten,
die man machen würde. Die erste steht da schon.
Man gibt einfach Niles zurück. Ja, finde ich nicht
schön, aber ich glaube, was Besseres geht nicht.
Ist hier noch irgendwo ein anderer Stack, den man zurückgeben könnte?
Man könnte sich selber zurückgeben. Ich weiß nicht, ob
das schöner ist. Okay, wir lassen das erst mal so.
Ja, toll, dann mache ich noch ein bisschen Kosmetik.
Die Lehrzahler brauchen wir nicht. Okay. Jetzt müsste man
doch schon irgendwas damit machen können.
Machen wir uns doch mal hier so eine kleine Main-Klasse.
Das müssen wir irgendwie einmal
zumindest benutzt haben
So, jetzt will ich eine Main-Methode schreiben.
Wie ist denn die Signatur der Main-Methode?
Da gab es ja vier Punkte in der SE1-Klausur.
Weiß das noch jemand? Genau, Fablic, Static Volt Main.
Und wie geht's weiter? Ja. Genau. So,
das kann sich ja kein Schwein merken, oder?
Ich kommentiere das mal ganz kurz aus. Es geht einfacher.
Main. Eclipse. Wie geht denn nochmal die Main-Methode?
Steuerung Lehrtaste? Enter. Fertig. Ja,
also ihr müsst das nicht auswendig wissen,
außer in der Klausur
Gut. Okay, was wollen wir jetzt noch tun?
Wir können schon mal so ein paar Stacks erzeugen.
Also sage ich doch mal,
mache ich mir doch mal so einen neuen, leeren Stack.
So, das ist ja jetzt kein wohlgeformtes Java.
Ich habe jetzt hier einfach nur einen Ausdruck hingeschrieben.
Ich will mir so ein Objekt erzeugen.
Ich muss das jetzt ja einer lokalen Variable irgendwie zuweisen.
Sonst würde das sofort wieder verschwinden und es wäre irgendwie nicht sinnvoll.
Mache ich das doch mal. Steuerung eins.
As science, Statement to New Local variable.
Toll, wie wollte ich es nennen? A. Okay.
Gut. Jetzt will ich mal was darauf tun.
Also A.Push.
A science statement to know local verible nennen wir das mal B. Okay.
Und dann sagen wir nochmal B.push 2, das nenne ich mal 10.
So, und jetzt könnten wir mal gucken,
was ist denn da jeweils drauf? Also, A,
frage ich mal lieber nicht, was obendrauf ist,
aber ich könnte zum Beispiel mal fragen, was ist denn Whip,
nee, B, A, wollte ich doch gerade nicht.
Was habe ich denn jetzt hier gemacht?
So, ne? Ich habe eine Klammer vergessen und dann,
aber jetzt geht es, glaube ich, oder?
Ja. Okay, und dann gucken wir nochmal,
was oben auf 10 drauf ist
So, wie starte ich das denn jetzt?
Ich gehe mal mit der rechten Mostas drauf. Java Application.
Ah ja, toll. Also ihr seht auf dem,
also ich habe den B-Stack dadurch erhalten oder wurde dadurch in die Welt gesetzt,
dass ich auf den leeren Stack eine 4 raufgetan habe.
Und wenn ich irgendwann später mal B fragen werde,
was ist denn oben auf dir drauf,
dann wird da immer die Antwort 4 kommen.
Und dann habe ich gesagt, okay,
dieser Stack mit der 4 ist zwar ganz nett,
aber ich will jetzt einen neuen Stack haben,
wo nicht nur die 4 drauf ist,
sondern auch noch die zwei da drüber.
Und deswegen ist hier die 2 erschienen. Aber ich habe
keinen dieser Stacks verändert. Also A ist immer noch
der leere Stack. B ist immer noch der Stack,
wo nur die 4 drauf ist und C ist immer noch
der Stack, wo die 4 und da drüber die 2
drauf ist
Toll, nicht schlecht. Jetzt wollte ich mal zu der
anderen Variante kommen. Ich hatte ja schon gesagt,
okay, das ist jetzt dieses mathematische Modell.
Hier ist ein Stack mit bestimmten Elementen. Und wenn ich Push-Aufrufe,
bekomme ich einen völlig anderen Stack, wo das Element obendrauf ist.
Jetzt möchte ich mal den Stack mit euch bauen,
wo ich sage, ich habe dieses Objekt,
ein veränderliches Stack-Objekt und ich kann da einen wachsenden und schrumpfenden,
ja, also ich kann einfach wachsen und schrumpfende Operationen darauf aufrufen.
Ja, ich brauche nicht ständig eine neue Variable anzulegen.
Gut, mache ich davon meine eigene Klasse.
Nenne ich die mal. Mutable Stack vielleicht. Das ist
ein veränderbarer Stack
So. Und man will jetzt ja nicht ganz viel Code
irgendwie neu schreiben, der so ähnlich ist wie der,
der schon vorher da war.
Hat jemand eine Idee, wie ich diesen veränderlichen Stack,
basierend auf dem Persistance Stack implementieren könnte?
Also ich habe bereits dieses mathematische Modell implementiert.
Ich warte nochmal ein bisschen, dass ihr euch
Gedanken machen könnt
Und was wäre dann das A? Genau, der Typ davon
wäre persossions sac und wo würde ich das A hier definieren?
Genau, toll. Also, machen wir uns hier eine Variable,
Persistent Stack, nennen wir sie mal Current vielleicht,
mir fällt gerade nichts Besseres ein,
hat nichts mit Strom zu tun, sondern mit Aktualität.
Okay. Was ist denn ein sinnvoller Startwert für diese Variable
, Paron? Wie soll so ein veränderlicher Stack in
die Welt gesetzt werden? Da warte ich jetzt nochmal,
dass sich ein paar andere Leute melden,
wie soll er anfangen,
sein Leben
Ja. Mit einem leeren Stack, das wäre doch sinnvoll, ne?
So. Gut. Okay. Jetzt sieht die Push-Operation natürlich ein
bisschen anders aus und deswegen implementiert diese Klasse auch nicht das Interface-Stack,
aber wir schauen uns nochmal ganz kurz das Interface an.
Hier war das Push ja so definiert. Ich stecke das Element rein,
was ich oben rauf tun will und dann kommt ein anderer Stack zurück.
Das will ich jetzt nicht. Aber ich kopiere mir
das mal trotzdem, dass ich nicht so viel tippen muss
Also ich brauche wie eine Push-Operation. Was wäre denn jetzt ein sinnvoller Rückgabit,
überinnert sich noch jemand an die Folien, ja?
Void. Das heißt also, lieber veränderbarer Stack,
ich gebe dir ein Element X und du sorgst intern dafür,
dass es auf dich selbst draufkommt.
Und ich will überhaupt nichts wissen davon,
dass es möglicherweise andere Stacks sind oder so.
So, das machen wir wait public. So,
und wie implementiere ich das jetzt? Also ich habe hier
diese Referenz, diese Referenz kennt einen unveränderlichen Stack,
das ist quasi mein aktueller Zustand.
Und ich will jetzt, dass da was draufkommt und dass
mein eigener Zustand sich dadurch ändert
Ja. Toll. Das ist Wahnsinn. Sehr gut. Okay,
dann wollen wir vielleicht mal gucken, was oben drauf ist.
Wie kann ich feststellen, was oben drauf ist?
Das ist doch einfach, oder?
Du hast lange nichts gesagt.
Ich habe akustisch nichts verstanden
Genau, und ich leite diese Anfrage einfach weiter.
Delegation nennt man das auch gerne. Das habt ihr auch
ganz offen in SE1 gesehen. Das ist eine tolle Stelle,
wo man sich jetzt darüber auslassen könnte, ist eine Klasse,
ein Klient oder ein Dienstleister und hier ist sie irgendwie beides.
Also ich biete meinen Klienten biete ich an.
Ich habe eine Dienstleistung top. Du kannst mich also fragen
, was obendrauf ist. Ich sorge dafür,
dass du diese Antwort irgendwann mal erhalten wirst.
Ich selber mache aber gar nichts, ja,
ich bin faul und leite diese Anfrage einfach weiter an einen anderen Dienstleister.
Gut. Was fehlt noch? Pop. Ich weiß
noch nicht genau, was der Rückgabetyp sein soll
Ups. Hier ist er verwirrt, weil er das hier nicht...
Was ist ein sinnvoller Rückgabetyp für Pop? Da gibt es jetzt verschiedene Möglichkeiten.
Plat Dharma, eine Möglichkeit. Man könnte Voice zurückgeben,
so wie man das bei Push auch gemacht hat.
Könnte man machen. Pragmatisch machen es die meisten Bibliotheken anders.
Richtig. Also was heißt richtig?
Das ist eine komische Operation. Diese Operation sorgt dafür,
dass der Stack schrumpft und liefert euch das Element zurück,
was weggenommen wurde. Das ist, glaube ich,
nicht ganz so trivial zu implementieren, oder?
Ich kann jetzt hier nicht einfach schreiben, Return,
ich kann das einfach mal schreiben, dass wir darüber diskutieren.
Das wird zum Beispiel überhaupt nicht funktionieren, ja.
Das ist natürlich ein Typ-Fehler, weil hier kommt ja
ein Stack zurück. Das funktioniert überhaupt nicht. Ja,
hat jemand einen Vorschlag, wie ich das erreichen kann?
Du hast sofort eine Idee. Du hattest
lange nichts gesagt?
Ja, schaue mir also an, was ist momentan obendrauf,
ja? Genau. Schön. Ja, das gefällt mir
noch ganz gut. Frage? Kann man ja
wirklich zurücksetzen
Stimmt. Ich weiß nicht, ob das eine Optimierung in welchem,
aber du hast recht, man kann die einfach top schreiben.
Ja, dann ruft er quasi mich hier selber auf.
Macht keinen Unterschied. Ja, aber du kannst dir gerne nachher
einen Snickers nehmen, falls es niemand anders haben will.
Gut. Zumindest liegen die hier nicht in der Sonne.
Das wäre noch schlimmer, okay. Ja, ach,
das ist doch nicht schlecht. Jetzt haben wir also schon
einen unveränderlichen Stack about und einen veränderlichen Stack.
Und jetzt kommen wir langsam zu dem,
was ich eigentlich erreichen will mit euch. Also,
das ist jetzt eine wunderbare Datenstruktur, die haben wir gebaut,
aber es wäre doch auch nett,
wenn es einen schönen Anwendungsfall dafür geben würde.
Flatsch starte ich mal ein anderes Programm.
Habe ich irgendwelche Tabellenkalkulationen drauf?
Keine Sorge, wir sind hier nicht in der Wirtschaftsinformatikvorlesung.
Erinnert sich jemand von euch noch an Woche 14,
als wir über diese Postfix-Notation geredet hatten, dass man,
als ich also nicht sage, eins plus zwei,
sondern dass ich sage eins, zwei plus,
das war auf dem letzten Blatt Flat,
hat sich das keiner angeguckt.
Also man kann sich vorstellen, es gibt irgendwelche Formen,
da schreibe ich irgendwie eins, zwei, drei, mal plus,
zumal, ups, das findet ihr nicht so lustig,
dass ich ihr ein Pluszeichen haben will.
Okay, stell dich vor, es ist einfach ein Pluszeichen.
Was bedeutet dieser Ausdruck? Ja, was kommt denn daraus
für ein Ergebnis? Eins, zwei,
dreimal plus in dieser merkwürdigen Notation,
wo ich erst die Operanten hinschreibe und dann den Operator
Was musst du denn da miteinander multipliziert werden?
Worauf bezieht sich denn dieses Mal? Ja. Es kommt
sieben raus, ne? Genau. Das heißt,
dieses Mal bezieht sich auf diese beiden Zahlen. Da kommt dann
also gedanklich sechs raus. Da steht jetzt also quasi eins,
sechs plus und dann wird eben die 1 und die sechs addiert.
Und das wäre doch toll, wenn man dafür ein Programm
schreiben könnte, was diese Rechnung vornimmt.
Und das ist eigentlich super einfach. Man braucht einen Stack
, okay? Das hier oben hat noch nichts,
das ist kein Stack, das ist einfach nur eine lineare Abfolge von Operanten und Operatoren.
Und wir brauchen jetzt einen Stack, um diese Zwischenergebnisse auszurechnen.
Und ich zeige euch mal an diesem Beispiel, wie das funktioniert.
Also man schaut sich das allererste Element an,
was in dieser Sequenz einfach drin vorkommt.
Eine 1-1 ist eine Zahl,
die tue ich mal auf meinen Stack drauf.
Ja, ich mache das jetzt mal wirklich,
das ist so von oben nach unten oder von unten nach oben wächst.
Das ist ja mein Stack. So, dann die nächste 2
ist auch eine Zahl, kommt auf meinen Stack drauf.
So. Drei ist auch eine Zahl, kommt auf mein Stack
drauf. Okay. Und jetzt steht hier dieses Mal,
das ist ja ein Operator und kein Operant,
den tue ich jetzt nicht auf den Stack drauf, sondern was mache ich jetzt?
Ich schaue mir die obersten beiden Elemente an,
entferne sie vom Stack und tue dann deren Produkt drauf.
Nur zweimal, drei ist ja sechs. Okay. Jetzt
habe ich also quasi das Zwischenergebnis schon mal ausgerechnet.
Dann schaue ich mir das nächste an,
das ist auch keine Zahl,
sondern Operator
Die ist die Semantik ähnlich. Ich schaue mir die obersten beiden Elemente an,
entferne sie und ersetzte das dann durch das, durch die Summe.
Und dann habe ich es ausgerechnet und das funktioniert für
beliebig komplizierte Ausdrücke, egal wie lang sie sind.
Ja? Genau, dafür kann man eben ein Programm schreiben.
Das können wir nochmal tun. Das werden wir
jetzt wahrscheinlich in fünf Minuten nicht mehr schaffen,
aber ich bin ja nächste Woche wieder da.
Dann machen wir einfach da weiter, wo wir heute aufgehört haben.
Gut. Also, machen wir uns doch mal eine
neue Klasse, nenne ich die mal.
Wir haben sie in der Übung genannt, die hieß,
glaube ich, sowas wie Postwix,
Parser oder so
So. Und diese Klasse braucht so einen veränderlichen Stack,
weil sie ja immer, wenn sie eine Zahl findet,
was auf den Stack rauftun muss.
Und wenn sie einen Operator findet, muss sie mit
den Zahlen rechnen, die auf dem Stack drauf sind.
Also, wir brauchen einen Mutable Stack, den nenne ich
mal Operanten. Oder ich nenne mal jetzt alles Englisch.
Ich will da jetzt hier keinen Mischmasch machen.
Operance. Okay. Dann sagen wir mal, dass so
ein neuer, veränderlicher Stack sein. So. Okay,
da haben wir so schon mal so einen schönen Parser,
der so ein Stack hat, mit dem er arbeiten kann.
Und dann machen wir doch mal
eine Operation
Die liefert einen Double zurück und die nenne ich mal vielleicht Evaluate oder so, ja.
Evaluate. Und dann kriegt sie einen String rein,
wo dann zum Beispiel drinsteht, eins, zwei,
dreimal plus, wie wollen wir diesen String nennen, vielleicht Formular.
Das ist nicht ganz besprechend, ich nenne es mal lieber,
Post-Fix-Formular. Ja. Und was ich immer gerne mache,
ist, ein Kommentar zu schreiben für öffentliche Methoden,
sonst hat der Klient ja überhaupt keine Ahnung, was hier passiert.
Also, sagen wir mal zum Beispiel, eveluates,
given, formula, in post-fixe Notation.
Und was ich immer sehr gerne mache, ist Beispiele.
Also, for example, eveluate
1, 2, 3 mal Plus.
Returns 7. Kann man sich vielleicht schon was drunter vorstellen.
Okay. Jetzt müssen wir erstmal diesen String uns angucken.
Und es gibt tolle Möglichkeiten in Java und auch anderen Programmiersprachen,
so einen String zu nehmen und den irgendwie zu zerhacken.
Irgendwie zu sagen, trennen den doch mal zum Beispiel an Leertasten.
Das ist, glaube ich, die einfachste Möglichkeit.
Also wenn wir vom Klienten verlangen,
du musst immer Leertasten zwischen die Zahlen schreiben,
das ist eigentlich relativ natürlich, wenn ich hier keine Leertaste habe,
sieht es ja aus wie die Zahl 23.
Aber du musst zum Beispiel auch zwischen den Operatoren Leertasten haben.
Ja, das würde der also nicht verstehen.
Das ist, glaube ich, jetzt die einfachste Möglichkeit,
um mit Blick auf die Uhr,
mache ich mal die einfachste Möglichkeit.
Ich sage also folgendes
Ich nehme jetzt diese Post-Fix-Form, oder? Und sage Split, Split.
Und da kann ich zum Beispiel sagen, an Leertasten.
Also ich habe einen String, sage Split und bekomme jetzt zurück,
ich weiß gar nicht so genau, was da der Typ ist.
Ich sage einfach mal bei Clipsweise, dass du meine Variablen zu,
dann sehe ich ja. Ah, es ist ein RA
. Okay, dann nenne ich das mal vielleicht Atoms.
Das sind jetzt die Atome, aus denen dieser String zusammengesetzt ist.
Jetzt habe ich ein RA und ich will mir jetzt alle Einträge dieses RAS angucken.
Also ich will also einmal hiermit was machen,
dann will ich damit was machen,
dann will ich damit was machen, dann damit und dann damit.
Kennt ihr eine Möglichkeit, wie ich über alle Elemente eines
RAS rübergehen kann und mit jedem Element einmal etwas zu tun
Warum sind es immer dieselben Hände durch? Ah. For each,
sehr schön. Wie geht denn nochmal die For each-Schleife?
Vielleicht weiß Eclipse das ja auch. Ah, for each,
Iterate over and Array or iterable, das mache ich doch mal.
Er hat alles für mich hingeschrieben, ich musste gar nichts machen.
Also, Eclipse hat festgestellt,
es gibt nur eine einzige Sammlung innerhalb dieses Sichtbarkeitsbereichs,
ja, das ist dieses String Array.
Es gibt nichts anderes, worüber du iterieren könntest,
also schreibe ich es mal für dich hin.
Toll, oder? Also, der Typ ist richtig,
ja, und Philanatia ist hier nicht String,
sondern Atom, gefällt mir besser.
Okay? Ist das nicht unglaublich
Ah, E-Clips ist immer wieder toll. Gut. Jetzt hatte ich
ja eben schon an dem Beispiel gesagt, wir müssen einmal gucken,
ist es eine Zahl oder ist das ein Operator?
Vielleicht prüfen wir erstmal, ob es ein Iterator ist.
Kann man ja nicht einfach rüberswitchen. Ich switche mal über
das Atom und schaue einfach mal, ist es denn zum Beispiel ein Plus?
Dann will ich vielleicht irgendwas tun. Vielleicht würde ich sagen Ad
. Und wenn es ein, stattdessen ein Sternchen ist,
wups, dann will ich vielleicht sagen Multiply, okay.
Und wenn es was anderes ist, ich mache mal wieder Vollbild,
sonst seht ihr immer fast gar nichts,
wenn es was anderes ist
Dann ist es hoffentlich eine Zahl. Dann sagen wir mal,
was müssen wir denn tun, wenn es eine Zahl ist?
Wie wollen wir das mal nennen? Hat jemand
eine gute Idee von Methoden haben, der aussah,
ich will die Zahl auf den Stack drauf tun?
Surf? Ach, Insert, ja, das,
ja, nennen wir uns doch mal Insert, okay.
Ach, die Formatierung gefällt mir überhaupt nicht, kann ich
das nicht automatisch machen lassen? Ah, Steuerungsschiff F. Der
Steuerungsschiff I ist in Carol und Blue Jay. Gut,
jetzt muss ich nur noch diese drei Operationen bauen,
das kriegen wir, glaube ich, gerade noch hin.
Wir haben ja ein bisschen Umbaupause gehabt,
Ja, die Ad-Operation gibt's doch gar nicht, ne?
Die könnte ich jetzt von Hand schreiben, aber ha,
das ist ja Eclipse, ich sag ja, Clips mit Steuerung 1,
bau sie doch mal bitte für mich, ja?
Wo ist sie jetzt? Hier. Und er hat
auch verstanden, dass er sie wahrscheinlich private machen soll,
das ist wahrscheinlich eine Hilfsmethode sein soll.
Okay. Gut. Hm? Oh, ja, dankeschön.
Danke. Das können wir eigentlich hierfür auch mal kurz machen,
dann sind mal diese roten Dinger endlich weg, so.
Wie addiere ich denn jetzt die obersten beiden Elemente?
Ich hol mir erstmal das, oh, das Oberste runter,
das ist, das, was, nee, Pop,
ne, ich will es ja runterholen.
Und so. Okay, jetzt habe ich also mir
die obersten Beine runtergeholt, was fehlt jetzt noch?
Ich will ja addieren, ja. Ja. Ja,
die Reihenfolge bei Plus ist ja egal, genau, sehr schön.
Jetzt mache ich mal hier ein bisschen Copy-Paste,
ihr seid schon ganz unruhig, bitte gebt mir noch diese paar Minuten.
Das ist einfach toll, wenn es dann funktioniert.
Dann brauchen wir, ups, nee,
das war die falsche Methode, hier wollte ich rein.
Hier sollen wir dann multiplizieren und hier sehe ich gerade,
müssen wir noch einen String übergeben,
der weiß ja sonst überhaupt nicht,
welche Zahl er
da reintun soll
Und dann müssen wir die einmal parsen. Ich will daraus ja
ein Int machen. Das ist dann also quasi meine Zauber.
Ups, was habe ich denn hier gemacht? Double.
Und die tun wir dann mal auf unseren Stack rauf.
So. Und wenn wir das mit allen Elementen gemacht haben,
wo steht denn dann mein Ergebnis?
Ich habe den Stack aufgebaut, 1, 2,
3, dann bin ich multipliziert und addiert.
Wo steht denn dann das Ergebnis, was ich haben will?
Wo steht denn dann die Sieben? Ja,
hast du dich gemeldet?
Nee. Ja
Genau, auf dem Stack drauf, ne? Also es
macht jetzt keinen Unterschied, ich sage Top oder Pop.
Ich sage jetzt einfach mal Pop. So. Und jetzt gehe ich
nochmal zuletzt in meine Main-Klasse und mache hier mal einen super kleinen Test,
dass ich einfach nur sage, mach mir doch mal einen neuen,
wie habe ich ihn genannt, Post-Fix-Paser,
tue ihn mal in eine Variable, nenne ich mal Pause.
Und dann sagen wir mal, lieber Paser,
evaluiere doch mal zum Beispiel diesen Beispielstring 1, 2,
3 mal plus.
Und das wollen wir auf die Konsole schreiben.
Das ist jetzt also hier quasi unser Testfall.
Und wir würden einen Luftsprung machen, wenn da jetzt
sieben Ball rauskommt.
Ich bin mal gespannt
Juhu. Okay, dann würde ich sagen,
sehen wir uns nächste Woche.
Viel Spaß im Labor