Schwierigkeiten dabei haben und auf jeden Fall in irgendeinen Termin rein müssen,
der voll ist, weil sonst ihr ganzer Stundenplan schon belegt ist,
dann schreiben Sie eine E-Mail an SE Orga und ich schaue,
was ich möglich machen kann.
Aber ich brauche dann natürlich gute Begründungen,
dann brauche ich auf jeden Fall von Ihnen den Nachweis hier,
dann ist diese Vorlesung, dann ist diese andere Veranstaltung,
ich kann zu keinem anderen Termin.
Nur irgendwie einen Grund, ich will aber nicht am Freitagvormittag
früh aufstehen, den werde ich nicht gelten lassen.
Gut, ja, das waren auch schon meine Folien.
Ich übergebe dann jetzt an, Jetzt, jetzt,
jetzt, jetzt. So, das wäre los.
So, schönen guten Tag auch nochmal von meiner Seite
Als ich Christian sei jetzt weg, ja.
Also ich Christian gerade zugehört habe, da dachte ich,
Mann, bin ich froh, dass ich nicht da sitze?
Sie müssen anwesend sein. Sie müssen präsentieren. Sie müssen müssen,
müssen, müssen. Sie dürfen hier sein. Ich freue mich,
wenn Sie jeden Mittwoch in die voll leere Vorlesung kommen.
Und wir die Zeit hier gemeinsam verbringen.
Insofern darf ich Ihnen versichern, dass herzlich willkommen.
Da unten rechts kommt von Herzen und ich freue mich darauf,
Ihnen jetzt so in circa 7 oder 8 Vorlesungen, was Sinnvolles beizubringen.
Zusammen mit meinen bewährten Kollegen Fred Winkler,
der immer so gegen Viertel vor 2, Viertel vor 3,
hier auftauchen wird, unter Verwendung von Folien,
die Axel Schmolitzky und Heinz Züllighofen in den Vorjahren auch hergestellt haben.
So, ich muss sie wie immer darauf hinweisen,
dass diese Vorlesungen videografiert wird.
Nicht sie werden aufgenommen, es werden nur die Vortragenden aufgenommen.
Wir werden ihre Privatsphäre schützen. Niemand soll wissen,
dass sie hier waren
Auch wenn es das, gut, Punkt. Außer den zwei Stunden Vorlesung
erwarten wir von ihnen. Das hat Christian Späh gesagt,
dass sie drei Stunden körperlich und geistig bei den Übungen anwesend sind und wir gehen davon aus,
dass der durchschnittliche Vor- und Nachbereitungsaufwand für Vorlesung und Übungen auch so ungefähr drei Stunden beträgt.
Das macht in der Summe acht Stunden sind ein Tag,
den sie für SE2 einplanen sollten. Und ich sehe mich jetzt schon wieder in der 14. Vorlesung,
wenn ich also vortrage, was sie angegeben haben,
wie viel Zeit sich für die Veranstaltung investiert haben,
im Mittel fünf bis sechs Stunden,
dann kriegen sie wieder einen Smiley mit einem runtergezogenen Mundwinkel.
Nun ja, also nur um das nochmal explizit zu machen,
wir glauben, wir haben das alles so konzipiert,
dass wir glauben, acht Stunden müssten ausreichen,
um diese Lehrveranstaltung zu bestehen.
Die Inhalte, die wir vermitteln, mitzubekommen. So,
jetzt habe ich noch ungefähr eine halbe Stunde,
die ich
was erzählen kann
Über das, was wir in SE1 gemacht haben. Ich verspreche ihnen,
ich zeige nur Folien,
die ich auch in SE1 im Programm hatte,
also nicht notwendigerweise alle gezeigt, weil sie wissen,
dass ja auch aus dem letzten Semester manche Folien blende ich aus,
aber ich habe keine neuen Folien gemacht.
Ich werde jetzt mal nochmal so ungefähr so die knappe halbe Stunde
nochmal so durchgehen, was sie eigentlich alles schon wissen.
Und dann werden sie denken, hui,
das ist ja toll, das ist viel mehr als
letztes Jahr um diese Zeit
Und es geht ganz harmlos los. Diese Zeichen entsprechen nicht
der UML-Notation, das ist so eine Freistil-Notation.
Was sind die grundlegenden Kontrollstrukturen der imperativen Programmierung? Sequenz,
Falleunterscheidung und Wiederholung. Das ist so mit diesem geraden deutschen Satz,
könnte man eigentlich sagen, viel mehr braucht es eigentlich auch nicht,
um große Programme zu schreiben,
weil letztendlich lässt sich alles auf diese drei Kontrollstrukturen zurückführen.
Und sie könnten dann auch den Rechner dass ihres Berufslebens,
also damit schon verbringen, wie sie wissen, ist,
dass zwar die Wahrheit, aber nicht die ganze Wahrheit,
zur ganzen Wahrheit gehören noch ein paar andere Dinge,
zum Beispiel Variablen.
Diese Folie haben sie auch ganz am Anfang des letzten Semesters
gesehen, Variablen als Abstraktion physischen Speicherplatzes.
Wir haben also viel mit elementaren Datentypen gearbeitet,
also hier sowas wie den Intager werden kurz,
oder auch auf Deutsch, der Typ Zahl.
Und das ist so ein Beispiel, das sie da sehen,
die Zahl der Wert, 42, denen diese variable Antwort hier haben kann.
Also dürfte ihnen die Zahl zahlen, 40 ist ihnen auch mehrfach schon begegnet.
Und als ich diese Folie heute zur Vorbereitung auf diese Folien auf diese Vorlesung nochmal angeschaut habe,
habe ich mich also an diesem, an dem Beispiel rechts,
dachte ich, ja, gut, das verstehe ich.
Also die variable Antwort ist eine Abstraktion über einem Speicherplatz und die variable Antwort
ist vom Typ Zahl und ein Element der Wertemenge Zahl ist der der Wert 42,
soweit so gut, dann schweifte mein Auge auf dieses Beispiel und Gott sei Dank habe ich diese Erläuterung gefunden,
der Typ Pfeffer, okay,
ich kaufe das jetzt erstmal und die Variable heißt dann wohl Gewürz.
Okay, also eine Variable, Gewürz vom Typ Pfeffer,
kann mir jemand verraten,
welche Elemente die Wertemenge des Typs Pfeffer hat
Mit dieser Frage habe ich dann diese Folie bei sich bewenden lassen.
Ich sagte, also das werde ich mal besser in,
soll ich das jetzt noch rausstreichen, weil ich darauf keine Antwort habe.
Aber falls Ihnen was Sinnvolles einfällt,
lassen Sie mich das im Laufe des Semesters wissen.
Mir fällt da jetzt gerade nichts zu ein.
Nur damit Sie nicht denken,
also ich versuche Ihnen gegenüber den Eindruck der Unfehlbarkeit und der Allwissenheit zu erwecken,
dieser Eindruck täuscht,
falls irgendjemand
das denken sollte von Ihnen
So, zurück zu den Dingen, die ich dann verstehe.
Wir haben uns über den Typbegriff Gedanken gemacht.
Wir haben also diese Definition, die Sie da sehen,
haben wir als erste Definition für den Typbegriff kennengelernt.
Die wesentlichen Elemente dieser Definition habe ich schon genannt.
Also der Datentyp ist definiert, als die Zusammenfassung von Wertebereichen und Operationen zu einer Einheit. Das sind die zwei wesentlichen Elemente,
also Wertebereiche und Operationen auf diesen auf diesen Werten und das haben wir wirklich,
also jetzt gerade an den elementaren Datentypen,
haben wir das rauf und runter kennengelernt,
der da in Tybulien ist hier als Beispiel nochmal genannt,
welche Werte hatte er, das ist also sehr aufzählbar,
True and Falls und was kann man mit diesen Werten machen?
Ja, man kann sie verneinen, man kann sie verbunden,
man kann sie verodern und das sind so diese,
gerade auf der Ebene der Basisdatentypen, ist das von der Programmiersprache festgelegt,
die sind ja in der Programmiersprache eingebaut, in Anführungsstrichen,
da seht ihr dann bei den Typen,
die wir definieren,
bei den selbstdefinierten Typen wird das dann ein bisschen anders
aussehen und dazu komme ich dann etwas später
Die, das ist jetzt nicht nur so dahergesagt,
das haben sie auch kennengelernt, das wird ihnen,
also kein Java-Compiler durchgehen lassen, wenn sie in ein Java-Programm,
wenn sie da solche Zeilen wie hier unten hinschreiben,
weil die Operation plus, die ist also nicht definiert,
für ihr Operanten vom Typ Intager und Bulien in diesem Fall,
das wird ihnen der Compiler dann so sagen,
der wird da keinen ausführbaren Code erzeugen,
Das ist so eine Eigenschaft dieser Sprache, Sprachen wie Java,
den sogenannten statisch-typisierten Sprachen, bestimmte Fehler können schon zur Kompilezeit,
also Fehler, die wir beim Programmieren machen können,
schon zur Kompilezeit entdeckt werden, würde es also ausgeschlossen ist,
dass er es zur Laufzeit des Programms,
wenn dieser Code so durchlaufen wird, das Laufzeitsystem,
auf die, also ich sollte nicht sagen,
auf die Idee kommt,
aber er ist erst im Laufzeitsystem auffällt,
dass diese Operation sinnlos ist und dann dem Benutzer gegebenenfalls sagt es da ein Programmierfehler,
existiert.
Das sind Situationen, die man vermeiden will.
Und das ist eben in statisch-typisierten Sprachen im Gegensatz zu dem,
was sie da auf der rechten Seite sehen, in dynamisch-typisierten Programmiersprachen,
kann der Compiler solche Fehler feststellen. Es gibt,
also sie werden das jetzt schon mal so als Aus,
das hier ist jetzt der Rückblick auf SE1,
kurzen Ausblick auf ihr weiteres Studium,
wenn sie sich mit dem Thema Programmiersprachen weiter beschäftigen werden,
werden sie also so eine ganze Vielzahl von unterschiedlichen Konzepten auch kennenlernen,
wie so Programmiersprachen, designt werden.
Also da ist die Unterscheidung zwischen statisch-stüpisierten und dynamisch-typisierten Programmiersprachen ist
nur eine von verschiedenen Unterscheidungen, die man treffen kann.
Also sie werden auch noch sogenannte funktionale Programmiersprachen, logische Programmiersprachen werden sie kennenlernen.
Also Programmiersprachen, die nach ganz anderen sogenannten Programmierparadigmen entworfen worden sind.
Das ist ein extrem spannendes Feld und sie werden dann insbesondere
auch Ich will jetzt Ihren Erfahrungen nicht vorgreifen,
aber Sie werden so die Vielfältigkeit von Ideen kennenlernen und dass
unterschiedliche Programmiersprachen für unterschiedliche Zwecke gut geeignet sind.
Also es gibt da kein Bullshit, wahr oder falsch,
gut oder schlecht, sondern es geht schlichtweg um die Geeignetheit
von bestimmten Entwurfsentscheidungen und so für die Arten von Programmen,
mit denen wir uns hier insbesondere in SE1 und 2 beschäftigen,
mit dem, was wir Ihnen beibringen wollen.
Es ist eine stark getypte,
statisch typisierte Programmiersprache,
das Mittel der Wahl
Aber die Welt ist da, wie gesagt, also bunt und vielfältig.
Und sie werden die bei Interesse auch noch kennenlernen. So,
und dann, nachdem wir uns also so mit diesen eingebauten Typen beschäftigt haben,
wird dann so ein bisschen weitergegangen und haben also auch angefangen, objektorientiert zu programmieren.
Und Fred, als du noch nicht da warst,
hat also Christian schon angekündigt, dass ein neues methodisches Mittel
in der Ausbildung eingesetzt werden wird von uns, das sogenannte Programmierdiktat.
Ich will dir jetzt in keiner Weise vorgreifen für die zweite
Hälfte der Vorlesung. Aber das, was da steht,
Das kann ich ja mal versuchen, so vorzulesen.
Schreiben Sie doch mal eine Klasse Girokonto.
Und diese Klasse Girokonto möge eine private Exemplarvariable haben.
Sie möge eine öffentliche Methode deklarieren. Und die soll heißen,
einzahlen. Und diese Methode hat einen Parameter vom Typ Intager
und der Name dieses Parameters sei Betrag. Das war jetzt
so ein halbwegs korrekter deutscher Satz oder vielleicht waren es auch zwei.
Und das ist die Aufgabe in den Programmierdiktat,
wird dann darin bestehen, dass sie diesen Satz hören,
arbeiten, hier hier vielleicht hier und dann schreiben sie das in korrekter Java-Syntax hin.
Das ist eine Leistung. Das kann man üben. Das
ist kein Wunder, das da passiert, das ist so ein bisschen Erfahrung.
Man muss so halbwegs sicher sein, sollte ich nicht sagen muss,
es ist hilfreich. Also wenn man schon mal so das
ein oder andere Java-Programm geschrieben hat oder versuchen sie das einfach
mal beim Abendessen, das ist vielleicht keine gute Idee.
Nach dem Abendessen, also sich selber solche Aufgaben zu stellen,
also jetzt nicht sich selber, sondern ihrem Gegenüber,
Weil dann, das übt sich einfach ganz gut.
Und so wie ich das jetzt so schon gesagt habe,
so was kann man jetzt hier noch sagen, ja,
es gab so eine frühe Kritik an objektorientierter Programmierung,
Bestand darin, dass das so eine ziemliche Vielfalt von Begriffen für,
also dasselbe Konzept, also da existiert.
Und ich habe ja jetzt gerade,
als ich gesprochen habe, über Variablen,
habe ich über Variablen gesprochen und die Variablen,
die heißen jetzt hier auf einmal Zustandsfelder
Und das hier ist also das Saldo. Man könnte das
als Variable bezeichnen, aber ein Synonym dafür ist das Zustandsfeld.
Zum Zustandsfeld kann man kurz auch sagen, Feld.
Und wenn dieses Feld an dieser Stelle einer Klassendefinition auftritt,
dann kann man dieses Feld auch Exemplarvariable nennen.
Das soll sie jetzt nicht verwirren. Das soll ihnen einfach nur zeigen,
auch was die Begrifflichkeiten anbetrifft. Wir sind nicht darauf aus,
hier ein Mehrbegriff Begriffe zu verwenden als unbedingt notwendig.
Aber es gibt unterschiedliche Begrifflichkeiten und sie sollten die beherrschen,
um das dahinter liegende Konzept besser verstehen zu können.
So, warum heißt die hier Exemplarvariable? Nun ja,
die ist also im gesamten Code dieser Klasse sichtbar.
Das wäre jetzt also im Gegensatz zu einer Variablen,
zu einem Feld, das also innerhalb einer Methode definiert ist.
Das ist nur, das ist ein Sichtbarkeit,
ist ja dann beschränkt auf diese Methode und nicht so
wie bei einer Deklaration auf Klassenebene für die ganze Klasse sichtbar
So, dann haben wir Klassen geschrieben und jetzt könnte man wieder denken,
wie nicht zum ersten Mal und dann hat man schon den Verdacht,
wahrscheinlich auch nicht zum letzten Mal, war es das jetzt endlich?
Nee, das war es noch nicht. Jetzt gucken wir uns diesen Klassentext,
den haben sie jetzt noch vor ihrem geistigen Auge,
gucken wir uns den nochmal an.
Worauf wir sie jetzt, worauf das da hinausläuft,
ist, wir bereiten sie jetzt auf Arbeitsteilung vor.
Arbeitsteilung in der Art, also sie dürfen, sollen,
können, müssen ja in den Übungen auch schon in Paaren programmieren.
Das, was in ihrer beruflichen Praxis später vermutlich häufiger
der Fall ist,
dass sie in Teams arbeiten
Teams von 5, 7, zwölf Leuten. Manchmal kommt
auch eine ganze Busladung von ihnen irgendwo an und dann wird gesagt,
so, da stehen die Rechner wohl an.
Nächste Woche soll es fertig sein. Und dann werden sie
Formen der Arbeitsorganisation noch kennenlernen. So ein bisschen was davon wird hier sichtbar.
Das ist jetzt so als die Doppelrolle einer Klasse,
haben wir das benannt. Es gibt eine äußere Sicht auf
eine Klasse. Das ist das, was die sogenannten Klienten interessiert.
Und es gibt eine Innenansicht. Wenn Sie die Außenansicht,
die die für den Klienten der Klasse entscheidend ist,
wenn sie die, wenn wir die jetzt mal in den Vordergrund stellen,
dann können sie sich so organisieren, dass sie sagen,
gut, wir definieren jetzt erstmal das,
was von einer Klasse nach außen hin sichtbar ist.
Und das ist eine Art von Versprechen, das wir mal geben.
Und dieses Versprechen muss durch die Implementation der Klasse eingehalten werden.
Dieses Versprechen muss noch nichtmals eingelöst sein in dem Moment,
wo man dieses Versprechen gibt.
Man sollte nur sicher sein, dass der Zeitpunkt kommen wird,
an dem man diese Implementation auch mal liefern wird.
Weil sonst hat man
halt gelogen
Das wird der Compiler feststellen. Der ist da nicht nachtragend,
aber der wird das Programm nicht übersetzen. Das,
was also von außen von einer Klasse sichtbar ist,
das, was für den Klienten relevant ist,
sind also so Dinge wie, welche Operationen sind öffentlich,
also Public, als Public definiert.
Was bei diesen Operationen interessant ist,
ist, hat diese Operation Parameter,
hat diese Operation möglicherweise
einen Rückgabewert
Und dann gibt es Kommentare oder Hinweise für die Benutzung. Das ist etwas,
was Sie nach außen hin zur Verfügung stellen und nach innen,
das kann dann eben ganz andere Menschen sein,
die diese Klasse implementieren, wie wird dieses Versprechen,
will heißen, die nach außen hin sichtbaren Operationen,
wie werden diese in Methoden rümpfen, implementiert.
Welche Exemplarvariablenden Felder braucht es dafür, um diese Methoden zu implementieren?
Gibt es private Hilfsmethoden, also Hilfsmethoden, die nach außen hin
nicht sichtbar sind, deren Existenz vor den Klienten verborgen wird?
Und dann hat man das Kann man das,
also so diese Art von Programmierung lässt sich,
also auch schon ohne dieses Hilfsmittel-Interface oder sagen wir lieber dieses Sprachmittel-Interface durchführen,
aber es hat sich so erwiesen, wenn man,
also es gibt noch gute andere Gründe, werden wir gleich kennenlernen.
Also wenn man ein Explizit, das ist ja gute Gründe,
dass man ein explizites Sprachmittel namens Interfaces im Fall von Java
in anderen Sprachen heißt das anders,
aber das Konzept ist eigentlich immer dasselbe.
Träne,
Spezifikation von Implementation
Spezifikation macht eine Aussage darüber, was implementiert werden soll.
Die Implementation sagt dann, wie es tatsächlich implementiert wird.
Und in Java gibt es jetzt ein eigenes Sprachmittel, um Spezifikationen auszudrücken.
Und das sind die sogenannten Interfaces und das ist nichts anderes als das,
was sie in den Klassendefinitionen bisher als Methodenköpfe kennengelernt haben.
Also sprich, die Angabe von, wie heißt diese Methode?
Hat sie einen Rückgabewert? Welche Parameter hat sie? Das wird also in den Methodenköpfen,
in einer Sammlung von Methodenköpfen unter einem Namen in einem Interface zusammengefasst.
Und sonst nicht. Also keine Methoden Rümpfe, keine Felder,
Exemplarvariablen, nichts von der, also von dem,
was es braucht, um ein solches Interface,
Deutsch könnte man sagen, ein solches Versprechen zu implementieren.
Wovon werden diese Interfaces dann implementiert?
Von Klassen, was anderes gibt es nicht.
In objektorientierten Programmiersprachen. Und so schaut es dann aus
Werden sie also, um in unserer beliebten Kunde Kontowelt zu bleiben,
jemanden spezifiziert, ein Interface konnte und sagt,
dieses Konto, falls es mal jemanden geben soll,
der dieses Konto implementiert,
dann möge er doch bitte die in dem Interface spezifizierten Operationen seien,
die mal diese hier implementieren.
Und dass ich, der Implementator von Kontoimpel dieser Klasse,
bereit bin, dieses Interface zu implementieren,
mache ich durch dieses Schlüsselwort klar.
Das sagt nichts anderes aus
als ab jetzt
Kann ich gegenüber der Außenwelt als einen Implementator von Konto verwendet werden. Das kann man auch,
kann man sich auch noch mal grafisch klar machen,
Christian Spey hat auch schon das Stichwort UML genannt,
also die Unified Modeling Language, diese Sammlung von Diagrammen,
die sich durchgesetzt haben,
um bestimmte Zusammenhänge in objektorientierten bei der Entwicklung objektorientierter Programme zu verdeutlichen,
was sie hier sehen, ist das UML-Klassendiagramm, das diesen Zusammenhang,
den ich gerade dargestellt habe, am Beispiel Konto,
dass diesen Zusammenhang einmal so mit den dazu zugehörigen,
abstrakten Begriffen versucht klarzumachen.
Also zunächst mal, wir haben jetzt über Interfaces gesprochen und Interfaces,
also spezifizieren, eine Schnittstelle für den Klienten ist,
also derjenige, der mal eine Klasse benutzen will,
für den ist das völlig intransparent, welcher Anbieter dahinter steckt.
Und der sieht nur bis zu dieser Schnittstelle und das ist eben jetzt,
kann ich das Beispiel, das ich vorhin verwendet habe,
so zur Arbeitsteilung, noch ein bisschen erweitern,
so die Sinnhaftigkeit dieser Trennung.
Heute ist es eben, also die klasse Anbieterklasse,
die diese Anbieter-Schnittstelle implementiert, morgen kann das eine völlig neue Implementation sein.
Das ist für die Klientenklasse, ist es nicht sichtbar,
weil diese Klientenklasse benutzt, sieht in ihrem eigenen Programmtext nur dieses Interface.
Und das ist eine Form von Trennung zwischen Implementation und Verwendung
Die sich insgesamt als ziemlich sinnvoll erwiesen hat. Man kann also,
es gibt so diesen Spruch, es gibt eigentlich kein softwaretechnisches Problem,
das sich nicht durch Einführung einer Indirektion lösen lässt.
Und das ist jetzt so ein Beispiel für eine Indirektion.
Und es gibt kein Effizienzproblem, das sich nicht
durch Wegnehmen einer Indirektion lösen lässt. Das sind so,
und diese Art von Ausbalancieren von verschiedenen Anliegen bei der Programmentwicklung
und der Programmausführung, Effizienz ist ja ein Ausführungskriterium,
also damit werden sie lernen zu jonglieren
Sie werden jetzt hier erst mal diese ganzen Konzepte kennenlernen und
dann werden sie auch noch kennenlernen, wie man die also möglicherweise,
nach welchen Kriterien man die gegeneinander abwägen kann.
So, also das ist jetzt so das Zusammenspiel von Klassen und Interfaces.
Ja, jetzt kommen wir wieder zurück zu unseren beliebten Typen.
Wir müssen uns jetzt, müssen natürlich nicht,
aber bis jetzt ist der Zeitpunkt gekommen,
um sich nochmal den Zusammenhang zwischen Klassen und Typen klarzumachen.
Das war für die Standardtypen war das,
also konnten wir da einen Haken dran machen
Und jetzt müssen wir uns im Gedanken darüber machen,
in welchem Zusammenhang Klassen und Typen stehen.
Nun, Klassen definieren in Java einen Typ erstens durch
ihre Schnittstelle und zweitens durch die Menge ihrer Exemplare.
Das sind also die Werte, die ein Typ annehmen kann,
also die von einer Klasse zu erzeugten Exemplare sind die Wertemenge eines Typs.
Bei Interfaces ist es genauso, also analog sollte ich lieber sagen.
Also wir haben ja hier in der Klasse haben wir
eine Schnittstelle also das, was öffentlich sichtbar ist.
Und beim Interface, naja, das ist eine Schnittstelle.
Und diese Schnittstelle definiert ebenfalls einen Typ. Bei den Exemplaren
ist es jetzt ein bisschen komplizierter, weil ja verschiedene Klassen, diese Schnittstelle implementieren können.
Also hier ist es ja nur die eine Klasse.
Und deswegen ist also die Wertemenge, die hierdurch definiert wird,
durch ein Interface, ist die Menge der Exemplare aller Klassen,
die dieses Interface implementieren. Es kann ja auch mehrere Klassen geben,
also die, um wieder auf das Beispiel zurückzukommen,
die die Schnittstelle Konto-Impel, Entschuldigung, die Schnittstelle Konto implementieren,
dann gibt es eben Konto-Impel 1, 2, 3,
4 und einen lustigen Wettstreit darüber, welche die bessere Implementation sind.
So, insofern haben wir jetzt also einen erweiterten Objekt orientierten Typbegriff,
den will ich jetzt nur noch mal kurz hier aufzeigen,
Durchschnitt, der Typ, der objektorientierte Typbegriff,
definiert das Verhalten von Objekten durch eine Schnittstelle,
ohne die Implementation und ohne den inneren Zustand.
Das ist jetzt so diese Einschränkung, ist halt wichtig,
oder die wird hier nochmal betont, um klar zu machen,
das Außen und das Innenverhältnis sind zwei voneinander,
zu trennende Eigenschaften einer Klasse. Man hat es zwar,
also denkt das gerne zusammen, aber für den Alltag,
für die Beherrschbarkeit von großen Programmen ist es ganz entscheidend,
also diese beiden Aspekte, diese Doppelrolle einer Klasse auseinanderzuhalten.
So, der letzte Punkt,
so ein Typbegriff ist und das ist etwas, wovon wir,
wo wir immer wieder feststellen, dass das doch einige Zeit braucht,
um also den statischen und den dynamischen Typen auseinanderzuhalten.
Deswegen nimmt er jetzt auch nochmal einen Teil hier in dieser,
in diesem Rap-Up ein. Über diesen Unterschied müssen wir uns Gedanken machen,
weil alles, was wir in objektorientierten Programmen selbst an Klassen
schreiben und an Typen definieren, durch sogenannte Referenzvariablen realisiert wird.
Diesen Zusammenhang, also versuche ich zunächst mal wiederum an einem Beispiel klarzumachen.
Wenn wir also sowas wie diese Deklaration hier sehen, wenn ich Ihnen sage,
deklarieren Sie mal statisch eine Variable vom statischen Typ Konto,
dann können Sie das in Ihrem Programmierdiktat,
also in Ihrem inneren Programmierdiktat, dass Sie jetzt gerade schreiben,
schreiben Sie das so hin.
Du merkst mal, also eine Klasse oder ein Interface Konto
geben und der Name, der Variable, der soll K. sein.
Okay, das, was sie da jetzt hingeschrieben haben,
ist interpretierbar als Konto ist der statische Typ von K.
Der ist deswegen mit deswegen statisch genannt und das schreiben sie da jetzt einfach hin.
Und das kann ich also zur Compile-Zeit oder zur Editierzeit,
können Sie das schon sehen,
was also dieser Typ von K ist und das ändert sich nie.
Das verspreche ich Ihnen hiermit. Der statische Typ der Variablen
K ist Konto und er wird auch immer Konto bleiben
Punkt. Und dann sagt es daraus, also ist ableitbar. Typ, weil immer,
aha, ein Moment, das waren Operationen und Wertemengen,
also in diesem jetzt fokussieren wir mal kurz auf Operationen.
Durch diesen statischen Typ kann festgehalten werden oder kann er überprüft werden.
Ob das, was sie hier hinschreiben,
ob das eine legitime Aufruf an einer Variablen mit dem Namen K vom Typ Konto ist, vom statischen Typ Konto ist.
Da kann der Compiler nämlich nachschauen, sagen wir mal,
Konto ist eine Klasse, ob es bei der Klasse Konto,
ob es bei dem Typ Konto, ob es da eine öffentliche Operation,
eine öffentliche Methode namens Einzahlen gibt, die als Parameter einen Intager-Wert erwartet.
Und dann ist es, also wenn das der Fall ist,
dann ist es erstmal so für den Compiler, ist die Sache damit erledigt. Jetzt wird das Ding,
aber das Programm wird es ausgeführt,
und das kommt also Dynamik ins Spiel, Ausführungszeit,
Dynamik, da könnte man ja denken, na gut,
wenn der Compiler also schon feststellt, es gibt diese Operation einzahlen,
dann könnte er diesen Code ja auch gleich,
also so an der Stelle des Programms, jetzt mal hinschreiben,
dann braucht er also nicht mehr zur Ausführungszeit,
also irgendwas kompliziertes mit dem Laufzeitdeck machen,
daran erinnern sie sich vielleicht auch.
Das geht leider nicht. Das ist jetzt aber nicht
schlimm, keine Bange. Der kann nämlich,
jetzt kommt der Trick mit dem dynamischen Typ einer Variablen.
Jetzt gucken wir uns mal dazu, dieses Coach-Schnipsel an,
wenn jetzt also an die Variable Car ein Objekt Von der Klasse vom Typ Konto simpel gebunden wird,
dann ist klar, also welche Operation jetzt aufgerufen werden soll.
Das ist aber erst zur Laufzeit klar, weil er ist
zur Laufzeit wird ja ein Objekt der Klasse Konto simpel erzeugt.
Und das kann sich leider Gottes also zur Laufzeit auch ändern.
Und jetzt sind wir bei den dynamischen Typen,
der dynamische Typ von K. kann sich also ändern,
je nachdem, von welcher Klasse,
von welchem Typ das Objekt ist,
das gerade an diesen Bezeichner gebunden ist
Hier ist es der ein Objekt vom Typ Kontosimpel.
Und dann brach dieser Zuweisung, das ist ja eine absolut legale Zuweisung,
solange Konto anders auch, also dieses Interface implementiert, Konto.
Dann ist der dynamische Typ von K-Konto anders.
Und das bedeutet erst zur Laufzeit kann dann auch entschieden werden,
welche Operation ausgeführt wird,
wenn jetzt an der Referenzvariable K die Operation einzahlen aufgerufen wird,
weil das ist dann Oder auch nicht.
Weiß man jetzt nicht. Wir wissen, wir kennen
die Implementationen vom Konto simpel und Konto anders ja nicht.
Das können andere Implementationen sein. Und dieser Gedanke,
die Unterscheidung zwischen dem statischen und dynamischen und dem dynamischen Typen eines Objektes,
die wird im folgenden, die wird uns im Laufe der nächsten paar Wochen,
wird die uns noch ein bisschen beschäftigen.
Weil dann kommen so, wir werden in diesem Semester ja
so erweiterte Konzepte der Programmierung kennenlernen. Also insbesondere werden wir
uns mit Fragen beschäftigen, so Begriffen wie Vererbung und Polymorphie.
Und da wird dieser Grundgedanke statischer versus dynamischer Typ, auch nochmal eine Rolle spielen. So,
Umgang mit einer Liste, also das sind so die Themen jetzt,
sagen wir mal jetzt so,
das war so von der programmiersprachlichen Seite her,
habe ich das mit den Konzepten über statische und dynamischer Typ von Variablen,
das Semester war dann so auf programmiersprachlicher Seite eigentlich beendet.
So, im Rest des Semesters haben wir uns,
also nur mit Anwendungen dieses Konzeptes beschäftigt,
unter anderem haben wir uns eben auch mit so ganz unterschiedlichen Behältern aus
Und der einfachste Behälter, also das sollte man nicht sagen,
das tut ihm auch nicht, das hört er auch nicht gerne.
Also einer der fundamentalen Behälter ist also die Liste.
Die Liste, die beliebig viele Elemente haben kann,
manchmal kann man da auf beliebige Positionen in der Liste zugreifen.
Wir haben Listen kennengelernt, die sich da ein bisschen anders verhalten haben,
also wenn man nicht beliebig auf die Positionen zugreifen kann.
Und wir haben uns auch mit so Operationen wie Test
auf Enthaltensein
Das ist so ein Beispiel ist für die Anwendung dieser Programmiersprachlichen Konzepte,
sieht man jetzt auch an dieser Zusammenfassung, weil diese generische Liste,
die ist halt definiert, spezifiziert als ein Interface.
Wir wissen nicht, wie dieses Interface von jemandem implementiert wird,
aber für unterschiedliche Verwendungszwecke gibt es eben unterschiedliche Implementationen.
Wenn die Liste, die sie jetzt in ihrem Programm brauchen,
häufig, also häufig beschrieben wird, im Gegensatz zu,
es wird eigentlich fast nur aus der Liste etwas gelesen,
dann wird es einen Einfluss darauf haben, welche Implementationen sie sich möglicherweise...
Welche Implementationen sie auswählen, das macht eben an der Stelle,
denke ich, auch nochmal, klar, so wie sinnvoll das ist,
Interfaces, sprich also die Schnittstelle einer Klasse und die Implementation,
konzeptionell auch voneinander zu trennen. Wir haben uns beschäftigt,
und hier sehen Sie jetzt noch gleich das Beispiel dazu,
so dieses Listeninterface, das, was für einen Klienten interessant ist,
das kann implementiert werden, wahlweise durch eine verkettete Liste oder eine Liste,
die so Array-artig organisiert, Schrägstrich, Implement, implementiert worden ist.
So, jetzt noch kurz, also der Stack,
der jetzt so eine Datenstruktur neben den Cues,
also den Schlangen, den Bäumen, die wir besprochen haben,
wenn sie das hier sehen, wissen sie auch,
also wie der Stack organisiert ist,
also das ist das sogenannte Last-in-First-Out-Prinzip Lifo, im Gegensatz zur Schlange
FIFO First in First-Out Diese Datenstrukturen sind also in verschiedenen Stellen werden,
die in Anwendungsprogrammen sind die sinnvoll. Und es war uns ein Anliegen,
ihnen diese Datenstrukturen auch schon im ersten Semester beizubringen,
sodass die jetzt zu ihrem, zum Kanon ihres Wissens gehören.
So, ich bin jetzt mit meinem Teil so gut wie am Ende,
dass hier ist so der vorläufige Plan für diese Lehrveranstaltung und aus ökologischen Gründen bitte ich Sie,
überlegen Sie sich das zweimal, ob Sie die Folien dieser Veranstaltung ausdrucken wollen.
Aber das, was Sie ja mal tun können,
ist so einmal pro Woche schauen Sie da drauf.
Und also Stand heute erwartet kein Mensch,
also auf dieser Seite des Pultes von Ihnen,
dass Sie mit einem Begriff wie Vertragsmodell schon etwas anfangen können,
geschweige denn, also eine softwaretechnische Interpretation des Begriffs Polymorphie besetzen,
also für diejenigen von Ihnen,
in der Schule mal vielleicht was von Psychoanalyse gehört haben.
Also die können vielleicht haben eine Interpretation, Begriffspolymorphie.
Alle anderen gucken da drauf und denken, was ist das denn wohl? So,
und jede Woche werden wir ihnen, also so neue Begrifflichkeiten,
ganz getreu dem Motto von SE1,
das ist ja auch in SE2 verfolgen,
werden wir ihnen nahe bringen, von uns erfahren sie Dinge,
von denen sie gar nicht wussten, dass sie sie nicht wissen wollen.
Und damit verabschiede ich mich ins Wochenende.
Ich wünsche Ihnen ein schönes und wir sehen uns nächste
Woche wieder
Ich habe das hier bekommen
Kann man mich hören? Ja? Sehr ungewohntes Gefühl.
Ich glaube, aber ich bin jetzt zu nah dran.
Ich glaube, für meine Frisur ist es nicht das geeignete Mikrofon.
Frisur. Okay. Ja, ich starte einfach mal Eclipse.
Okay, ich habe extra mal alles so bereinigt,
dass es so aussieht, wie es aussehen wird,
wenn ihr Eclipse das erste Mal startet
Wenn ihr Eclipse das erste Mal startet,
wedelt ihr gefragt, wo euer sogenannter Workspace liegen sollt.
Das ist einfach nur so ein Verzeichnis, wo alle eure Projekte
abgelegt werden. Und auf dem Aufgabenblatt sagen wir euch,
wenn ihr das unter Windows startet,
schreibt da doch mal sowas hin wie Z-Doppelpunkt, SE2, Workspace oder so.
Das wird bei mir jetzt natürlich nicht funktionieren,
aber für Linux gibt es natürlich keinen Lauf weg Z.
Das ist einfach nur schön, wenn das bei euch auf
dem Netzlaufwerk liegt, dann ist es schön unabhängig davon,
auf welchem Rechner ihr gerade arbeitet.
Also bitte beachtet die Hinweise auf dem Aufgabenblatt,
VA Clips das erste Mal einrichtet.
Dann ist das auch ganz nett, ich will das nicht
jedes Mal gefragt werden. Und jetzt bootet der Bootbildschirm,
ah,
da ist er
Und jetzt mutet Eclipse. Das ist also bei euch hoffentlich
ein bisschen effizienter als bei mir.
Der hat ja schon ein paar Jahre auf dem Buckel.
Ja, das ist normal, leider. Ich habe es gerade
dreimal getestet und es hat jedes Mal so lange gedauert.
Ah ja. Und dann seht ihr diesen Bildschirm,
da könnt ihr eigentlich direkt hier oben raufklicken auf Workbench.
Ich habe noch nie auf irgendwas anderes geklickt.
Also möglicherweise werdet ihr hier besser in Eclipse eingeführt,
als ich euch das heute zeigen kann.
Mal schauen. Ihr klickt auf Workbench und das ist so
euer erster Eindruck von Eclipse. Und was ich immer als erstes mache,
ist diese Tasklist zuzumachen, weil die immer so viel Platz wegnimmt,
aber ihr habt möglicherweise mehr Platz.
Ja, man sieht irgendwie nicht so wahnsinnig viel, ne?
Keine Klassendiagramme, keine, die man sonst bei Blue Jay sehen würde.
Wir können ja vielleicht erst mal ein neues Projekt anlegen.
Wie macht man das denn? Also File New. Oh.
Okay. Das heißt, der Beamer ist ein 16 zu 9 Beamer.
Das ist ja interessant. Ich habe auch einen 16 zu
9 Laptop, den habe ich extra nicht mitgebracht,
weil Lecture to go 4 zu 3 benötigt.
Das heißt wahrscheinlich, wenn ihr es dann zu Hause anguckt,
seht ihr alles, was ich jetzt hier mache.
Ja, das ist ja toll
Ja, ich glaube, spontan fällt mir da jetzt keine Lösung ein.
Ich werde immer versuchen, dass der Quelltext sichtbar ist.
Ihr müsst mir jetzt einfach glauben,
dass da oben ein Menü ist, wo ich jetzt sage,
File New Java Project, es tut mir leid,
notfalls müsst ihr es einfach nochmal nachgucken.
Dann dauert es wieder ein bisschen, kann man jetzt was sehen.
Ach guck mal, das Wichtige ist da.
Jetzt können wir dem irgendeinen Namen geben, sagen wir mal,
Flat Hello World. Ja, und da sind auch noch
ganz viele andere Optionen, die sind eigentlich alle egal.
Und was ihr jetzt nicht sehen könnt, ist der Finish-Bappen hier unten.
Da klicke ich jetzt drauf, glaubt es mir einfach.
Kann man das jetzt sehen? Ja. Das ist also
unser Projekt, das klappe ich einfach mal auf
Und man sieht also hier, dass es ein Java-Projekt ist.
Also ich will auf die Standardbibliothek von Java zugreifen können.
Und dann gibt es hier diesen sogenannten Source-Ordner. Da gehören
eure ganzen Java-Dateien rein, ja. Sämtlicher Quelltext, den
ihr schreibt. Und wenn ihr was da hinzufügen wollt,
klickt ihr mit der rechten Maustaste und auch ein wahnsinnig riesiges Menü,
dann kann man das sehen, dass hier ein New steht.
Nee, kann man schon wieder nicht sehen.
Man kann das nur erahnen. Und dann sage ich,
ich will eine Klasse hinzufügen. Das kann man zumindest sehen.
Gut, dann nenne ich die Klasse doch mal Start-up.
Bei uns heißen immer Gärten, das hat nichts damit zu tun,
dass ich irgendwie eine eigene Firma gründen will.
Sondern wir starten das Projekt in dieser Klasse.
Und auch alles andere kann man ignorieren.
Ich klicke jetzt auf den unsichtbaren Finish-Button
hier unten
Ach, ist das schön. Okay. Und da sieht
man jetzt hier, meine erste eigene Klasse in Eclipse.
Gut. Wie starte ich das denn jetzt? Ja,
in Bluejoy hätte man jetzt wahrscheinlich gesagt,
ich klicke mit der rechten Maus-Taste auf die Klasse und dann
kann ich irgendwelche Exemplare davon erzeugen, interaktiv und so.
Das geht alles in den Clips nicht. Kennt ihr eine andere Möglichkeit,
wie man ein Java-Programm startet, wenn es keinen Start,
also wenn es kein, ja, interaktiv Objekte erzeugen?
Kommandozeile, nee, das meinte ich nicht, ja.
Wir brauchen auf jeden Fall eine Klassenmethode und weißt du
noch,
wie die heißt
Sehr gut, ich wollte als nächstes nämlich noch der Signatur fragen.
Public Static Void Maine. Weiß jemand noch, was ich
an die Main-Methode übergeben muss? Ein String Array namens Arcs
. Genau. Oh, das ist aber irgendwie nicht
so schön formatiert, oder was machen wir denn jetzt?
Ich drücke mal Steuerung, Shift F. Das ist schon besser
. Könnt ihr den Code überhaupt sehen? Ja, sehr
gut. Und dann schreiben wir was auf die Konsole,
sagen wir mal, System, Outprintler, hallo?
Okay. System Outprintler in Halloween
Ihr seht, da kommen immer unglaublich hilfreiche Hinweise von Eclipse.
Einfach Escape drücken, dann verschwinden die. So. Ja,
und wenn ihr das jetzt starten wollt,
dann könnt ihr hier oben auf den Startknopf drücken.
Mal gucken, ob das funktioniert. Ja, dann seht ihr natürlich
jetzt nicht. Ich scrolle das mal ein bisschen hoch.
Hier unten seht ihr dann die Ausgabe des Programms.
Das hat das also gerade auf die Konsole geschrieben.
Ich kann auch alternativ mit der rechten Maus,
dass die hier raufklicken und sagen, run ass,
das könnt ihr gerade noch sehen, Java Application.
Ja, geht auch. Oder für die Leute,
die Shortcuts mögen, Altshift mögen X und dann J. Ja
Okay, jetzt ist es so,
es gibt ja immer diese Glaubenskriege in der Informatik.
Wo gehört eigentlich diese öffnende geschweifte Klammer hin?
Soll die in die Zeile, wo sie gerade ist,
oder soll sie in die nächste Zeile?
Ich mache jetzt keine Abstimmung, weil wir haben euch ja
schon indoktriniert, dass die immer in eigene Zeilen gehören.
Das Blöde ist aber, wenn ich Steuerung Shift F drücke,
dann, tja, wird das wieder so formatiert.
Also auch eine der vielen Sachen,
die ihr im ersten Übungsstermin lernt, ist einzustellen,
wie das nach euren Präferenzen formatiert wird oder nach unseren Präferenzen.
Wir geben das ja vor. Man kann hier oben,
das finde ich ganz toll, kann man das sehen?
Nee, schon wieder nicht. Schaut euch bitte
das Video einfach an, wie ihr da genau hinkommt.
Es gibt also dieses Menü in Eclipse, wo ich konfigurieren kann,
wie Quelltext formatiert werden soll, sehr hilfreich.
Und man kann hier so eine Einstellung quasi importieren,
das sieht man wieder, das ist doch schön.
Und ich habe auf dem Schreibtisch extra mal was abgelegt.
Diese Datei, die findet ihr im Kommensee,
die könnt ihr euch einfach runterladen.
Das sind also unsere Weltanschauungen, wie Java Quelltext formatiert werden sollte sozusagen.
Habe ich jetzt einfach mal importiert. Dann sage ich, okay.
Und wenn ich jetzt das nächste Mal Steuerungsschiff 11 drücke,
dann sieht es so aus,
wie wir es gerne sehen
Gut, das ist irgendwie ganz nett, wenn alle ihren Quelltext
gleich formatieren, dann sieht er nicht ständig anders aus.
Gut. Mir persönlich ist es übrigens völlig egal,
wo diese geschweiften Klammern stehen. Mir ist es wichtig,
dass es konsistent gemacht wird. Und bei uns heißt es,
alle 400 Studenten tun es in eine neue Zeile,
die öffnen in eine geschweifte Klammer.
Bitte keine Glaubenskriege deswegen anfangen. Es gibt kein wahr und
kein falsch. Es gibt nur Konventionen. Gut. Ja,
jetzt ist es natürlich selten so,
dass man ein neues Projekt in Eclipse ständig anlegt als Programmierer.
Wenn ihr montags ins Büro geht, werdet ihr wahrscheinlich kein neues Projekt anlegen,
sondern möglicherweise an Projekten arbeiten, die schon da sind.
Wie macht man das denn in Eclipse? Tja,
jetzt müsst ihr mir einfach wieder glauben,
dass ihr euch oben auf dieses Pfeil-Menü klicke.
Und dann sage Import
Genau, zumindest das sieht man. Ich will ein Projekt importieren.
Okay. Dann gehe ich als nächstes hier rauf und dann
hier rauf. Das steht alles auf dem Aufgabenblatt drauf,
aber viele Studenten lesen das einfach nicht.
Vielleicht seid ihr mehr so diese visuellen Lerner,
die es einfach mal vorgelebt bekommen müssen.
Also Existing Projects into Workspace, das Projekt gibt es schon,
ich will es in meinen Workspace haben.
Das will ich machen. Und jetzt haben wir die Projekte
immer als Zip im Kommen. Deswegen sage ich mal Select Archive-File.
Archive heißt ja nur sowas wie Zip oder Ja oder sowas.
Ich browser das mal, das müsste wieder auf meinem Schreibtisch sein.
Genau. Mediathekvorlage Blatt 1 bis 3. Zip. Das findet
ihr im Komsi. Das ist also quasi das Projekt,
mit dem wir uns die ersten drei Wochen beschäftigen oder
zumindest in dieser Version
Okay. Ich klicke auch auf okay,
das müsst ihr mir glauben und dann klicke ich auf Finish.
Das müsst ihr mir auch einfach glauben.
Gut. Jetzt habe ich also hier ein weiteres Projekt.
Ihr seht jetzt also schon zwei Projekte in meinem Workspace.
Ich mache das mal wieder so ein bisschen kleiner,
das interessiert uns jetzt nicht mehr so.
Wir fokussieren uns jetzt mal auf dieses Projekt.
Das wird euch also mitgeliefert. Ihr seht auch hier wieder,
ah, das benutzt die Java-Standard-Bibliothek, alles klar.
Oh, offenbar wird auch Jair Unit benutzt.
Das ist ja zum Testen, falls sich noch jemand erinnert,
größere Softwareprojekte ohne Testklassen. Da ist man immer sehr,
ah, hoffentlich mache ich nichts kaputt, wenn ich hier was ändere.
Gut, also Testklassen haben wir offenbar auch. Und hier
ist so ein kleiner Datenbestand, werdet ihr gleich sehen.
Warum? Okay, jetzt würde ich euch als nächstes zeigen,
warum wir nicht mehr mit Bluejay arbeiten
Ich öffne jetzt einfach mal hier diesen Quelltext-Ordner und dann dieses
sogenannte Default-Package und wir gucken mal, oh ja,
das sind ja doch mehr als die zwei oder drei Klassen,
die wir sonst immer in Blu-Jay-Projekten hatten.
Jetzt stell dir doch mal vor,
ihr öffnet Blu-Jay und habt da irgendwie 40 Klassen,
inklusive aller Beziehungen zwischen diesen Klassen.
Das ist sehr übersichtlich, glaubt es mir.
Also da würde man nichts mit anfangen können.
Gut. Wie geht man jetzt an so ein Projekt ran?
Wir könnten uns mal die Startklasse angucken. Wo ist denn hier
die Startklasse? Da ist die Startup-Mediathek. Da wird jetzt
ein bisschen was drinstehen, was ihr noch nicht so verstehen werdet.
Aber was eben wichtig ist, ist, es gibt
diese Main-Methode
Ja, in größeren Projekten und in größeren Quelltexten ist es eigentlich auch mal ganz nett,
wenn man nicht von Hand hier so durch den Quelltext durchgeht,
ah, wo war denn nochmal die Main-Methode?
Bin ich schon drüber weggescrollt oder war sie irgendwo anders?
Man sieht also hier im sogenannten Outline-View so eine Art Zusammenfassung dieser Klasse.
Ja, es ist so ein bisschen wie eine Schnittstelle,
allerdings sieht man hier auch Implementationsdetails,
aber man sieht keinen Code in dem Sinne.
Also ja, man kann also hier sich angucken, ah,
es gibt hier irgendwelche statischen Klassenkonstanten, diese beiden zum Beispiel,
okay, das ist ja alles Static,
das ist vielleicht gerade ein bisschen ein blödes Beispiel.
Dann sieht man hier zum Beispiel
die Main-Methode
Was jetzt genau in der Main-Methode passiert,
ist jetzt vielleicht noch nicht so spannend oder ihr könnt es
auch noch nicht verstehen, aber wir können sie mal starten.
Nur wir haben ja schon gelernt, ich kann hier mit der
rechten Maustaste raufklicken und sagen, Run as Java Application.
Dann rattert die Maschine wieder ein bisschen, bei euch geht
das schneller. Ja, so sieht das System aus.
Jetzt seht ihr wieder ganz viel nicht. Ja,
ihr seht eine Überschrift nicht, die ist nicht so schlimm,
aber die eigentlichen grafischen Komponenten, die wichtig sind, seht ihr.
Man kann also hier, man sieht diverse Kunden,
also die Kunden an unserem Bestand.
Ihr seht eine wahnsinnig hilfreiche Beschreibung dieses Kunden hier oben.
Das wird noch schöner von euch gemacht werden im Verlaufe des Projekts.
Und man sieht hier irgendwelche Medien, die man ausleihen kann oder nicht.
Also wenn ihr steht ausleihbar, dann sollte dieser Button
Ja, blau sein. Und wenn es nicht ausleihbar ist,
sollte er ausgegraut sein. Mal gucken, ob ich jetzt
mal Glück habe, ah, jetzt zum Beispiel, ja.
Das System scheint noch nicht so richtig zu funktionieren.
Einer eurer Aufgabe wird sein, herauszufinden, woran liegt denn das?
Also irgendwie scheint es ja gar keinen Zusammenhang zu geben zwischen,
ist es Auslaber oder nicht, und diesen Button?
Tja, das wird eine eurer Aufgaben sein. Gut.
Okay, soll ich euch noch was zu dem Outline-Video sagen?
Ich glaube, ja, gehe ich doch noch mal kurz
in die Klasse CD.
Das ist so eine ganz normale Standard-Java-Klasse
Kann man jetzt einigermaßen was sehen, ja.
Was sehen wir denn da? Klaas CD,
Implements Medium. Ich garantiere euch. Jeder Betreuer,
der euch über die Schulter guckt und diese Zeile ist,
ihr würdet euch fragen, was heißt denn das?
Eine Klasse implementiert ein Interface. Erklär mir doch nochmal,
in einer Minute, was so ein SE1 alles über Klassen
und Interfaces gelernt hast, über den Zusammenhang zwischen diesen beiden Dingen.
Vielleicht würde man dazu gerne mal sich die Klasse,
Entschuldigung, das Interface-Medium angucken, den Quelltext vom Medium.
Wie macht ein Programmieranfänger das, oder geht man hier aus
diesem sogenannten Vollbit-Modus raus, dann, wo ist denn hier Medium?
Ach, das scheint ja alphabetisch sortiert zu sein.
Das ist MSR Hinter C, dann stromt man sich hier
irgendwie durch die Gegend.
Das muss man aber
gar nicht machen
Man kann einfach, wenn man mit dem Cursor auf diesem Medium ist,
wenn der Körper blinkt, ich drücke einfach die F3-Taste.
Und dann öffnet sich das Interface-Medium. Ja, man kann also
unheimlich viel Zeit sparen, wenn man so eine Handvoll Shortcuts kennt.
Okay, ich will wieder zurückkommen, wo ich eben war,
halte die Alttaste gedrückt und drückt Cursor links.
Da könnt ihr durch die Navigationshistorie so ein bisschen durchgehen.
Das ist auch sehr nett. Und wenn ihr alt rechts
macht, dann kommt ihr wieder zu dem Medium zurück.
So ein bisschen wie Andu und Redo,
aber nicht für Änderung am Quelltext, sondern für Navigationspunkte.
Gut. Genau, wir hatten ja schon gesehen,
CD implementiert Medium. Vielleicht gibt es da noch andere Medien.
Wie könnte man den jetzt rausfinden, welche Medien es sonst
noch so gibt
Naja, der Programmieranfänger würde einfach sagen, na gut,
ich kann ja im Prinzip jeden Quelltext hier öffnen.
Ich fange mal ganz oben an. Gucken wir doch mal,
ob Appstract, ob Servible Service, das Interface Medium implementiert.
Nö, tut's nicht, dann mache ich die Klasse wieder zu.
Dann gucke ich mir mal die nächste an. Nö,
tut's auch nicht, dann mache ich sie wieder zu.
Könnt ihr euch schon vorstellen, es würde ziemlich lange dauern
, oder? Was man stattdessen macht, ist,
man drückt einfach F4. F4 ist also nicht mehr Turn Ride,
sondern zeigt euch jetzt an, welche Klassen implementiert dieses Interface.
Das finde ich extrem sinnvoll, das zu wissen,
weil sonst sucht ihr euch zu Tode.
Glaube, eine Sache wollte ich noch zeigen,
die auch damit zu tun hatte,
die auch für die Übung relevant sein wird.
Wo ist mein Verleihservice? Hier ist er. Genau,
Verleihservice ist also ein Interface und dazu gibt es mehrere Implementationen.
Es wird mindestens eine geben, sonst wäre so ein Interface ja sinnlos.
Ein Interface hat immer mindestens eine Klasse, die es implementiert,
sonst würde man sich fragen, was soll das Ganze?
Okay, und es gibt in diesem Fall tatsächlich zwei Stück.
Dieser Dummy-Verleihservice hat so ein bisschen mit diesem erattischen Verhalten der Oberfläche zu tun.
Wir können uns ja mal vielleicht ganz kurz angucken.
Eine meiner Lieblingsmethoden in diesem Dummy-Verleihservice,
der einfach nur fragt, ob ein Medium ausgeliehen ist,
wo ist das?
Ah ja, hier
Ich übergebe, also an diesem Dummy-Forleih-Service ein Medium
und frage ihn, ist dieses Medium verliehen oder nicht?
Und dann guckt er in seiner Datenbank nach und gibt irgendeinen
Bulien zurück. Tja, das ist die Erklärung dafür,
dass das Programm sich eben so komisch verhalten hat.
Wir können ja mal gucken, wo wird denn so ein
Dummy-Forleih-Service erzeugt? Also wir haben ja hier den Konstruktor,
ja, und ich würde jetzt gerne das System fragen,
wo in meinem System steht New Dummy Forleih-Service.
Ich könnte das jetzt wieder mit Textsuche machen oder alles von Hand
, da wird man ja wahnsinnig.
Ich kann einfach mit der rechten Maustaste raufblicken und sagen,
References, das hat also nichts mit einer Java-Referenz zu tun,
sondern das heißt so viel wie,
wo wird es benutzt oder wo wird es genannt, dieser Konstruktor.
Und jetzt könnt ihr auch noch gucken,
in meinem ganzen Workspace oder nur in dem Projekt,
in dem ich gerade bin,
das wird für euch wahrscheinlich nicht großen Unterschied machen.
Ich sage einfach mal Project, nur innerhalb dieser Mediathek interessiert mich das.
Gut. Ja. Das wird bei euch weniger unübersichtlich aussehen,
mit größeren Bildschirmauflösungen. Das System hat also eine Stelle gefunden,
da kann ich jetzt einfach doppelt draufklicken,
wo dieser Konstruktor aufgerufen wird.
Also hier, er hat es mir sogar markiert, den Konstruktoraufruf.
Aber ich glaube, die Markierung ist nicht
so schön lesbar,
das geht eigentlich
Okay. Also was wird hier gemacht? Wir erstellen ein Exemplar
der Klasse Dummy-Verleih-Service und weisen es zu an eine Variable, Namensverleih-Service.
Und wir können uns mal angucken, wie die deklariert ist.
Ich gehe da einfach mal hin mit F3. Da ist sie.
Und ihr seht hier, und lasst euch bitte nicht von dem Static verwirren,
das hat hier eine andere, eine andere Bedeutung.
Der statische Typ dieser Variablen ist Verleih-Service,
weil das bei der Deklaration da so steht, da steht Verleihsung,
dass man da jetzt irgendwie stehen würde, Object,
dann wäre es Object, aber wenn da stringen würde,
stehen würde, wär string.
Der statische Typ dieser Variablen ist Verleih-Service, okay.
Und hier unten, als ich das Objekt erzeugt habe,
Der Typ dieses Ausdrucks ist ja jetzt Dummy-Verleiher-Service.
Und eine eurer Aufgaben wird es sein,
nochmal euer SE1-Wissen rauszuholen, sich zu überlegen, Moment mal,
der Typ dieser Variablen und der Typ dieses Ausdrucks,
das sind ja verschiedene Typen, wieso geht denn das überhaupt?
Wieso kann ich einen Dummy-Verleiher-Service zuweisen an eine Variable vom Typ Verleih-Service?
Das sind ja eigentlich verschiedene Typen. Ich verrate euch jetzt nicht die Antwort,
das müsst ihr euch für die Übung einfach mal überlegen.
Okay, ihr seht also,
es geht zum einen auf diesem Aufgabenblatt darum,
diese neue Entwicklungsumgebung kennenzulernen und zum anderen darum,
das Wissen aus SE1 nochmal
so ein bisschen aus euch rauszurollen
Gut. Ja, ich denke mal,
viel mehr werde ich jetzt nicht machen zum ersten Aufgabenbad,
man will ja nicht alles vorwegnehmen.
Dann wollte ich jetzt mal mit euch über das Programmierdiktat reden.
Ja. Das ist also ein Beispiel eines Programmierdiktats.
Ich kann ja vielleicht mal einen Editor darüber legen,
dass wir nicht immer zu viel auf einmal sehen, dass uns verwirrt.
Kann ich ja sagen, Editor und dann kommt der Editor.
Da ist er. Okay. Gut. Das ganze Ding
heißt Programmierdiktat, weil wir es tatsächlich mal diktiert haben,
so wie Guido das vorgemacht hat, ja.
Ein Vimi steht vorne und liest euch was vor und ihr müsst genau zuhören.
Und wenn jemand hustet, versteht ihr die Hälfte nicht.
Wir haben uns irgendwann dazu entschieden zu sagen,
pass auf, wir geben das den Studenten ausgedruckt,
dann haben sie ihre Ruhe und das könnte es in ihrem eigenen Tempo erledigen.
Gut, was macht man als erstes, wenn man so
ein Blatt sieht? Man guckt sich erstmal die Überschrift an,
wo Dinge fett geschrieben sind und rot markiert.
Das schaffen so ungefähr 50 Prozent der Studierenden erfahrungsgemäß. Okay,
ich zeige euch jetzt einmal, dass ich das verstanden habe.
Schreibe auf das ausgeteilte Blatt oben rechts folgende Informationen, okay,
den Labortermin. Mina, das ist jetzt ein Fantasietermin,
den gibt es ja eigentlich gar nicht.
Mittwochnachmittags heißt das
Ihr schreibt mal natürlich euren eigenen Termin hin. Sein Nachname,
mein Nachname ist Mustermann und mein Vorname ist Max.
Okay, meine Matrikelnummer ist so. Und das Ganze bitte mit nach oben rechts. So,
ich will einfach, dass ihr das visuell gesehen habt,
dann werdet ihr euch hups, nächste Woche erinnern, ah ja,
das muss ja nach oben rechts und untereinander und nicht irgendwie anders.
So sieht also euer Blatt dann aus.
Gut. Ja, dann geht's weiter im Text.
Schreibe den Kopf einer Klasse namens Parser. Ihr müsst jetzt
unheimlich gut darin werden, nicht zu viel Interpret,
nicht zu viel Bedeutung diesen Wörtern zuzumessen.
Wenn ihr noch nie gehört habt,
was ein Parser ist,
ist das nicht schlimm
Es ist ja einfach nur ein Java-Identifier, der da steht.
Da könnte auch stehen, Nudelsalat oder Mülleimer,
das wäre völlig egal. Okay. Ja, diejenigen,
die was zu schreiben dabei haben,
können sich jetzt einfach mal zehn Sekunden überlegen,
was sie da aufschreiben würden und das dann aufschreiben und die anderen beschränken sich auf das Überlegen.
Ich glaube, das ist so trivial,
dass ich das jetzt einfach mal mache.
Klaas, Pause. Das müsst ihr hinschreiben. Hier ist also
die deutsche Variante und hier ist es in Java übersetzt.
Gut, haben wir gemacht. Wie geht es denn bei
Ups? Ich wollte eigentlich noch runterscrollen. Was sollen wir
als nächstes machen? Öffnen den Rumpf der Klasse.
Wie geht das denn? Kann sich mal jemand melden,
um mir das sagen
Wurde gesagt. So. Okay, wir haben
den Rumpf geöffnet. Gut, geht's weiter im Text?
Oh. Deklariere eine private Klassenkonstante namens Attems vom Typ Pattern.
Und auch hier, lasst euch nicht verwirren von diesem Namen.
Es ist völlig egal. Es sind nur Namen. Ja,
also wenn ihr sagt, ich habe noch nie was
von Atomen oder Mustern gehört, das ist nicht schlimm.
Okay, ja, wie macht man das denn?
Eine private Klassenkonstante namens Attems von Typ Pattern.
Irgendjemand eine Idee, wie man das schreibt.
Private Static Final bis hierhin klang es gut
Atoms? Ah nee, warte mal, Petern war ja richtig, Entschuldigung.
Ja, nee, ist richtig. Der Typ kommt ja zuerst.
Ich habe zu viele andere Programmiersprachen in letzter Zeit benutzt.
Private Static, Final Pattern, Atoms.
Irgendwelche Einwände. Nö, sieht gut aus, oder?
Doch, Einwand. Danke, dass mir Kulon fehlt.
Muss man in Jabba hinschreiben, auch in Jabba 8.
Und auch in Jabba 9. Gut. Initialisiere sie mit
dem Ergebnis des Aufrufs der Klassenmethode Compile der Klasse Pattern.
Okay, wie rufe ich denn eine Klassenmethode auf?
Ich weiß den Namen der Klassenmethode. Ich weiß,
wie die Klasse heißt
Wie rufe ich auf einer Klasse eine Klassenmethode auf?
Habt ihr das schon mal gemacht? Man muss den Klassennamen
zuerst hinschreiben. Erst den Empfänger der Nachricht und dann wird
die Nachricht heiß, um mal alte, objektorientierte Würfe rauszuholen.
Okay. Und da müssen jetzt wahrscheinlich noch Parameter rein,
oder? Oder wir nennen sie ja aktuelle Parameter.
Ach guck mal, da steht das Wort ja schon.
Übergib als aktuellen Parameter an Kompile, das Stringliteral sowieso.
Oh Gott, hoffentlich vertippe ich mich da jetzt nicht.
0 bis 9, plus Strich,
oh Gott
Ja. Ihr könnt mir glauben,
wenn ihr das handschriftlich nicht hinbekommt, ist nicht schlimm.
Darum soll es in diesem Programmierdiktat nicht gehen. Uns ist wichtig,
dass ihr versteht, hier wird an einer Klasse
eine Klassenmethode aufgerufen und es wird ein aktueller Parameter übergeben.
Ja. Also hier steht ja, hier steht,
wir sollen an der Klasse pattern, die Compile-Methode aufrufen.
An Attems wirst du hier noch gar nichts aufrufen dürfen,
weil Attems ja hier noch gar nicht initialisiert ist.
Attems ist ja quasi erst hier initialisiert.
Das würde also keinen Sinn machen. Ich verspreche euch,
das ist die komplizierteste Deklaration,
die ich gefunden habe in den Programmierdiktaten vom letzten Jahr
Man will ja immer nicht zu viel versprechen, das Punkt.
Also die meisten Deklarationen sind nicht so kompliziert, okay?
Gut. So, dann mache ich euch jetzt
mal Flights so und gehe ich hier wieder rein.
Was sollen wir denn als nächstes machen?
So, jetzt wird es wieder ein bisschen normal.
Man soll irgendwelche Methoden schreiben. Schreibe den Kopf einer
privaten Hilfsmethode namens Evel mit Erkenntnistyp Double.
Oh, habe ich das vergessen? Tatsache, guck mal
, ich bin auch in dieser Überschrift ignorierend Modus.
Okay, deklariere ein privates Feld namens Metscher vom Typ Metscher
. Das ist so der Standardschwierigkeitsgrad so ungefähr, ja.
Wie mache ich das in Java? Wie deklariere ich ein privates Feld,
wenn ich weiß, wie es heißt sollten,
von welchem Typ es sein soll?
Hat irgendjemand eine Idee. Es ist zu schwer.
Vielleicht das erste Wort, das erste Token.
Private, das ist auch schon mal gut, ne?
Felder müssen ja immer Private sein. Okay. Und jetzt
? Wir haben ja nur noch zwei Zutaten,
den Namen und den Typ.
Was kommt immer zuerst in Java
, ja
Ich habe es akustisch einfach nicht verstanden.
Richtig. Er ist der Typ und dann der Name,
also Matcher, ups, habe ich mich vertippt.
Matcher. Das ist das in Java-Übersetz.
Dieser deutsche Satz in Java übersetzt sieht so aus.
Ich hoffe, das habt ihr schon mal gesehen.
Erst der Zukunftsmodifikator, dann ein Typ und dann ein Name.
Okay. So, jetzt kommt endlich mal eine Methode.
Schreibe den Kopf einer privaten Hilfsmethode namens Evil mit Ergebnistyp Double.
Wie macht man das in Java? Ich will
eine Methode schreiben, ja.
Oh, danke
Ich habe Public verstanden. Evel, ne? Okay.
Und jetzt steht hier, sie hat zwei formale Parameter vom
Typ Dabel, nämlich Top und Below.
Wie sage ich das in Java? Zwei formale Parameter,
beide haben denselben Typ, aber verschiedenen Namen.
Immer dieselben, das ist ja ein bisschen schade eigentlich,
oder? Ja. Tabel. Double, ich habe es
akustisch nicht verstanden.
So? Irgendwelche Einwände
Genau, das ist also nicht Turbo, Pascal,
da würde das so gehen,
sondern man muss jedes Mal den Typ davor schreiben,
auch wenn es derselbe ist.
Okay. Gut, das haben wir gemacht. Wunderbar. Richtig,
deswegen steht er als nächstes, öffne den Rumpf der Methode.
Das ist die nächste Anweisung. Zack, haben wir sie geöffnet.
So, okay, was sollen wir als nächstes machen?
Prüfe, ob die Parameter lose Methode Feind auf dem Feld
matcher den Wert Falls liefert
Wie prüft man denn etwas in Java?
Erinnert euch noch an die drei grundlegenden Kontrollstrukturen der imperativen Programmierung.
Soll ich jetzt eine Wirels-Schleife nehmen? Ja. Eine IF-Anweisung,
ja. Und was soll ich da als Bedingung reinschreiben?
Ja. Okay, kann man machen. Du willst sagen
, Feind. Und jetzt steht er ja noch,
es soll auf dem Feld Metcher aufgerufen werden.
So. Ist das alles? Klammer auf, Klammer zu,
ne? Ihr müsst ja in Java immer,
wenn ihr in Java eine Operation aufruft,
müssen dahinter runde Klammern kommen mit aktuellen Parametern.
Und wenn ihr keine aktuellen Parameter übergibt,
dann sind die eben leer, die Klammern.
Aber ihr könnt sie nicht weglassen. In anderen Sprachen kann man
das manchmal in Java eben nicht. Okay, ja,
also wie rum ihr diesen Vergleich macht, ist völlig egal.
Ich glaube, man nennt das Yoda Conditions,
wenn man das Fouls zuerst macht.
Google das mal, das hat tatsächlich einen etablierten Begriff dafür.
Okay. So. Ja, was sollen wir denn
dann machen
Kann man das noch lesen? Ja,
in diesem Fall soll der Wert des formalen Parameters top
mittels Return-Anweisungen an den Klienten geliefert werden.
Vielleicht mal jemand, der noch nichts gesagt hat.
Ja. Tja, ne? Haben wir das gemacht?
Wird das format manchmal das top? Mittels Return, genau
. Sehr schön. Ja, dann mache ich das hier
wieder zu, das ÖF. Jetzt fragen sich natürlich die
Studenten, brauche ich diese Klammern?
Hätte ich das nicht
auch direkt dahinschreiben können
Also wenn wir nicht explizit von euch fordern,
geschweifte Klammern hinzuschreiben, dann ist euch das selber überlassen,
ob ihr die geschweiften Klammern hinschreiben wollt oder nicht.
Wir sind also keine Grammer-Nazis, sagt man,
glaube ich, mal dazu. Keine Java-Grammer-Nazis. Okay.
Deklariere eine lokale Variable namens Atom vom Typ Strength.
Wie deklariert man denn eine lokale Variable?
Ich zeige euch mal, was ich da schon gesehen habe.
Die Claire New Atom String oder so, ja.
Das ist definitiv falsch. Ja, es gibt also keinen
Declaire in Java und für eine lokale Variable verwendet man auch
kein New.
Das ist ja für Objekterzeugung
Also es ist teilweise amüsant, was man da sieht.
Okay, wie mache ich das? Eine lokale Variable deklarieren in Java
? Ich weiß, welchen Namen sie hier haben soll.
Ich weiß, welchen Typ sie haben soll. Wie sage ich
das im Java? Ja. Genau. Sehr schön.
Ja, ich glaube, ihr habt das Prinzip verstanden,
oder? Ich kann ja einfach nochmal hier das Diktat so
ein bisschen auflegen. Ja, ist hier noch irgendwas,
was wir noch nicht hatten
Aufruf einer Methode hatten wir. Hier habt ihr so ein
bisschen Freiheit. Das ist eigentlich eher ungewöhnlich für die Programmierdiktator.
Ich habe extra dieses genommen, das wird also nicht nochmal drankommen,
das lohnt sich nicht, das auswendig zu lernen.
Wir haben also hier den Leuten die Wahl gelassen,
wollt ihr in IFLs nehmen oder wollt ihr in Switch nehmen?
Ich finde das nicht schlimm, aber ich glaube,
sowas ist in den anderen Programmierdiktaten nicht drin.
Und je nachdem, welche Werte eine bestimmte Variable hatte,
sollte man dann dies machen oder das.
Das werde ich jetzt nicht alles mit euch durchdeklinieren,
das wird auch in fünf Minuten nicht möglich sein.
Ich gucke nochmal ganz kurz, ob ihr sonst noch irgendwas
ist.
Klassenkonstanten hatten wir schon
Okay, also wie geht man denn jetzt daran, um sich darauf vorzuwarten?
Ihr habt ja noch ungefähr eine Woche Zeit. Ich würde euch empfehlen,
lest euch doch noch mal die Einleitungstexte der SE1-Aufgabenblätter durch.
Ich zeige euch noch mal ganz kurz, wie so ein
Einleitungstext aufsieht, falls ihr euch nicht mehr erinnern könnt,
wie die SE1-Aufgabenblätter so strukturiert waren.
Und ich bitte noch mal ein bisschen in Ruhe,
wir haben noch sieben Minuten. Bitte noch nicht unruhig werden.
Dann werde ich nämlich auch mal so unruhig. So,
ich muss jetzt hier einmal ins SE2 kommen, sie.
Und dann werde ich dann wechseln ins SE1, kommen sie.
Wenn das Komsi mich lässt, also Raum wechseln,
Und das dauert ein bisschen, die Räume zu laden,
in denen ich schon so bin.
Wahrscheinlich sind das zu viele. So, SE1 kommen sie.
Und dann kann ich mir ja mal irgendein beliebiges Blatt rausgreifen.
Schauen wir mal hier in die Materialien rein.
So, nehmen wir mal, keine Ahnung, Blatt 11.
Völlig beliebig gewinnt. Und hoffen wir halt, dass er das,
wenn er jetzt runterlädt, ich das auch öffnen kann.
So, erinnert sich noch jemand an die Aufgabenblätter?
Es gibt hier diesen Begriff oder diese Überschrift Kernbegriffe.
Wird gerne komplett ignoriert von Studenten. Die gucken gleich,
wo ist denn die erste Aufgabe? Ach, Lernziele interessiert
mich nicht. Ah, hier geht's los.
Also, lest euch bitte nochmal diese Kernbegriffe durch.
Und jedes Wort, was so kursiv gedruckt ist,
Solltet ihr definieren können, ohne die Definition hier nachzulesen.
Und wenn ihr das könnt, dann habt ihr,
glaube ich, keine Probleme aus Deutsch, Java zu machen.
Denn das ist ja alles, was das Programmierdiktat macht.
Es wird also in einem Programmierdiktat niemals stehen, implementiere Quicksort.
Ja, es wird ja jede Zahl,
da wird ja wirklich einzeln vorgegeben, du musst eine Variable deklarieren,
du musst ein Objekt erzeugen, du musst eine Faustschleife schreiben.
Ihr müsst also nichts, ihr müsst keine eigenen Probleme lösen
oder so. Okay. So, okay,
dann wollt ihr euch noch eine Sache zeigen.
Bitte bleibt ruhig. Sonst müsst ihr länger bleiben,
wenn ihr jetzt nicht ruhig werdet
Ja, ja. Also, wir haben auch den Rechnern
im Labor, ein UML-Diagramm-Editor. Das ist einfach nett,
weil ihr sollt auf den Aufgaben auch immer UML-Diagramme zeichnen.
Und das ist irgendwie, naja,
man kann die zwar mit Kugelschreiber und Bleistift und so zeichnen,
aber meistens sehen die nicht so hübsch aus.
Deswegen gibt es also dieses Tool und ihr werdet eigentlich
so gut wie immer Klassendiagramme zeichnen wollen.
Wo man also sieht, welche Klassen und Interfaces gibt es
in meinem System, wie hängen die zusammen und so.
Ihr kennt eure Objektdiagramme aus SE1, aber die sind,
glaube ich, jetzt nicht so spannend.
Also, ich klicke auf Glasdiagramm. Kann man das
denn überhaupt sehen, was ich hier euch erzähle?
Ja, da ist es
Okay, und dann seht ihr rechts,
seht ihr so ein paar interessante Tools, zum Beispiel Klaas.
Ich klicke da einmal auf. Und wenn ich jetzt hier
in diesen freien Textbereich oder weißen Bereich reinklicke, dann ist hier meine Klasse.
Sieht noch nicht wirklich aus wie eine Klasse.
Wir klicken mal doppelt drauf. Und da könnt ihr sagen,
wie die Klasse heißt. Zum Beispiel, keine Ahnung, Fällerlei-Service. So,
jetzt könnt ihr hier auch die Zustandsfelder reinschreiben und die Methoden,
wenn ihr das wollt und wenn es für den konkreten Zweck zweckdienlich ist.
Und wenn auf dem Aufgaben dort steht, dass ihr das machen sollt.
Oft steht auf dem Aufgabenblatt, schreibt nur die Namen der Klassen dahin.
Keine Operationen, keine Zustandsfelder. Was passiert? 50 Prozent
der Studenten lesen die Aufgabe nicht,
geben uns dann so eine Lösung ab,
wo überall Methoden stehen und man steigt durch nichts mehr durch.
Also in der konkreten Aufgabe, auf Aufgabe Platz 1
sollt ihr nur die Namen hinschreiben.
Keine Zustandsfelder, keine Methoden. Sonst werdet ihr nie fertig
in den drei Stunden. Könnt ihr euch vielleicht vorstellen,
bei so vielen Klassen und wie viel Methoden die jeweils haben.
Okay, dann machen wir vielleicht auch noch eine weitere Klasse.
Ich denke mir jetzt irgendwas aus. Also bitte übernehmt das
nicht und gebt es als Lösung ab,
was der Vergleich auf es benutzt vielleicht, keine Ahnung,
was sehe ich da da draußen,
meine Wand zum Beispiel.
Das ist definitiv falsch.
Und jetzt kann ich Beziehungen zwischen diesen Klassen herstellen.
Ich kann also zum Beispiel sagen, dass der Verleihservice die Wand benutzt.
Wenn er irgendwie guckt, wie es denn diese Wandklasse implementiert,
vielleicht gibt es irgendwie eine Klasse, keine Ahnung,
Ziegel, und dann gibt es vielleicht noch eine Klasse,
ein bisschen weiter rechts, vielleicht gibt es ja noch eine Klasse Mörtel,
ich weiß es nicht.
Ja, ihr müsst also wirklich einfach aktiv durch diese Klassen
durchgehen und mal schauen, welche Typen werden denn da so benutzt?
Und dann macht ihr da wieder Dependency-Pfeile dran und so weiter.
Und vielleicht hier nochmal als kleinen Tipp, es macht nicht wirklich Spaß,
Wenn wir uns den Verleih-Service mal angucken, davon Hand durchzugucken,
naja, welche Typen tauchen denn hier so auf?
Denn in einem UML-Klassendiagramm bedeuten die Pfeile,
die von Verleih-Service ausgehen, bedeuten ja, der Typ,
zu dem der Fall hingeht, taucht hier irgendwo drin auf.
Also in meinem konkreten Beispiel, im Quelltext der Klasse Verleih-Service-Impel
heißt sie ja eigentlich, eine Entschuldigung. Ich glaube,
ich war gerade in der Impel-Klasse, ist aber auch egal.
Wenn da irgendwo der Typ Wand auftaucht, dann zeichne ich
diese Box und male diesen Fall. Oder andersrum,
wenn ein Programmierer dieses Diagramm sieht, weiß er, ah,
alles klar, im Verleih-Service-Impel wird der Typ Wand benutzt.
Der taucht da einfach textuell irgendwo auf den Quelltext
Okay. Und wie gesagt, man könnte hier jetzt einfach so durchgehen.
Es ist ja doch das Interface. Okay, egal.
Und man könnte jetzt gucken, welche Typen tauchen hier auf?
Bitte tut keine Klasse String in euer OML-Diakum rein. Die kennt jeder Java-Programmierer,
das würde nichts beitragen, um das System zu verstehen.
Gut. Und auch die klasse Liste müsst ihr da nicht unbedingt reinnehmen.
Das würde keinen Mehrwert haben. Gut. Was ich für diese Aufgabe immer schön finde,
ist zu sagen, drückt doch einfach mal Steuerung, oh,
dann sehst du hier so ein Inline-Overview und dann schaut ihr einfach mal,
welche Typen tauchen denn hier so auf, ah, Kunde,
Medium, Datum, Kunde, das ist immer dasselbe,
das ist immer dasselbe.
Und dann taucht hier noch irgendwo so eine Verleihkarte auf.
Also ich will mich jetzt nicht zu weit aus dem Fenster lehnen,
aber ich glaube, diese vier Typen sind es.
Die würdet ihr dann in das Diagramm übernehmen. Und von
diesen vier Typen aus würdet ihr dann rekursiv wieder gucken,
welche Typen werden denn da benutzt.
Nur um diese Aufgabe nochmal zu klären,
dass ihr da nicht euch zu viel Arbeit macht.
Okay, ja, ich würde sagen,
das als erster Einblick in Eclipse und in das erste Aufgabenbad.
Vielen Dank