Bevor ich inhaltlich werde,
wollte ich kurz ein paar Worte zu mir selbst sagen,
weil ihr ja möglicherweise mich jetzt hier eine Weile ertragen müsst und dann vielleicht wissen wollt,
wer das ist, der da vorne so viel erzählt.
Also ich habe selbst Informatik studiert in Bremen,
an der Uni Bremen,
habe 1993 meinen Diplom gemacht,
bin dann nach einem halben Jahr bei einem Startup in Bremen
doch wieder an die Uni gegangen,
nach Ulm
Also auch mal rumgekommen mit Deutschland. Habe da sechs Jahre
als Limi gearbeitet und habe dann 1999 da promoviert über das Design von Objektnotierten Programmiersprachen.
Und dann hatte ich ein Stipendium bekommen vom DARD.
Die haben ja ein Jahr Forschungsaufenthalt in Australien bezahlt.
Und da war ich dann an der Monage University in Melbourne.
Da habe ich unter anderem auch im Bluejay-Team mitgearbeitet.
Also da ist Bluejay das erste Mal eingesetzt worden und entwickelt worden.
Und ich bin dann, als ich zurückkam nach Deutschland,
habe ich dann Bluejay hier quasi in Deutschland auch mit installiert
Zumindest hier in Hamburg. Ja,
dann war ich noch mal wieder kurz in Ulm nach meiner Australien-Zeit,
bin aber dann Anfang 2001 nach Hamburg gekommen,
habe hier bei einer Firma angefangen zu arbeiten,
die meinem Kollegen Heinz Zülichhöfen gehört.
In dieser Firma habe ich zwei Jahre gearbeitet,
auf einer halben Stelle und auf der anderen halben Stelle war ich ein wissenschaftlicher Assistent,
habe also so halb halb gearbeitet, das war ganz schön heftig,
neue Stadt, neues Umfeld, zwei neue Jobs.
Und habe dann 2003 entschieden, dass ich mich ganz auf
die Uni konzentriere und bin seitdem eigentlich nur noch,
ja, sagen wir, freundschaftlich verbunden mit der C1BPS.
Das heißt, die Firma inzwischen die immer noch so als Aninstitut hier in der Informatik existiert.
Ich bin seit 2009 auf einer Dauerstelle in der Informatik
hier als akademischer Rat und mache jetzt seit 2005 SE1. Also das ist schon ziemlich lange.
Ja, meine Forschungsinteressen, klar, durch meine Promotion,
Design, Objekte und Tierter Programmiersprachen,
das klingt auch hier ab und zu mal an,
zumindest auch in SE2, wenn ich das eine oder andere dazu sagen,
dann habe ich hier in Hamburg sehr viel Kontakt gekriegt mit agilen Entwicklungsmethoden.
Also Methoden, wie man Software anders entwickeln kann,
als das bis dahin
überwiegend üblich war
Dann das Thema Softwarearchitektur, das ist bei uns im Lehrstuhl relativ stark vertreten.
Da kümmere ich mich vor allen Dingen darum, ja,
wie kriegt man denn Leute dazu, Softwarearchitekten zu werden?
Und ich interessiere mich auch sehr stark für neue Lehrkonzepte.
Das seht ihr unter anderem auch hier in SE1 und in SC2.
Objects first, das Buch habe ich übersetzt.
Der betreute Laborbetrieb ist unter anderem auch auf meinem Mist gewachsen,
aber nicht auf meinem Allein. Ich habe ein Unterrichtskonzept entwickelt,
Teachlits und jahrelang hier auch ausprobiert,
das ziemlich spannend ist, um Softwareentwürfe zur Diskussion
zu stellen
Live-Code. Und ja, mich interessiert auch,
wie man Objektsysteme so zerschneiden kann und in ihrer Komplexität einstufen kann,
um dann eine gute Programmierausbildung zu machen.
Gut, das ist mehr oder weniger das zu mir.
Gibt es Fragen zu meiner Person? Möchte da noch jemand
irgendwas sonst noch wissen? Ich vermute mal eher nicht.
Prima. Gut, ihr erinnert euch. Letzte Woche habe
ich das Student Response System hier eingeführt. Das läuft jetzt
auch wieder und ich würde gerne eben hier was ausprobieren.
Also zum Beispiel habe ich jetzt hier wieder die eine Umfrage,
die ich letzte Woche schon gemacht habe.
Ich würde jetzt einfach noch mal euch bitten,
wenn ihr noch keinen Klicker habt, hier vorne sind noch Klicker,
da oben ist auch noch, glaube ich, ein Kassen,
wenn er nicht leer ist, ich weiß es nicht.
Also jeder, der kein Smartphone hat, kann sich doch
so einen Klicker holen, um an diesen Abstimmungen teilzunehmen.
Heute wird es erstmalig auch so weit kommen,
dass ich nicht hier nur immer Umfragen mache,
sondern dass ich auch Multiple-Choice-Fragen stelle,
wie wir sie auch in unseren Klausuren bevorzugt stellen.
Und dann gibt es eine richtige Antwort.
Und dann werden wir auch mal ein bisschen gucken,
wie denn so die Antwortverteilung ist bei den Fragen,
die ich hier stelle
Das werde ich heute erstmal nur ausprobieren,
aber wir werden da sicherlich nochmal an Stellen drauf zurückkommen,
wo es auch ein bisschen interessanter ist, wo ich mehr fragen kann.
Ich habe bisher so wenig erzählt,
dass es relativ wenig Möglichkeiten gibt, da das Feedback einzuholen.
Jetzt kommt hier die super Unruhe auf. Ich würde euch
das nächste Mal bitten, gleich am Anfang, euch einen Clicker zu holen.
Wir werden die dann auch da oben hinstellen an die beiden Eingänge,
damit wir relativ schnell starten können. Für diejenigen,
die jetzt mit einem Smartphone hier sitzen,
ich kann nochmal diesen Barcode zeigen,
die sich ihren Link nicht gemerkt haben,
die meisten von euch haben hoffentlich einen Bookmarkt gesetzt mit ihrem Smartphone.
Aber hier kann man jetzt nochmal mit dem Smartphone diesen Barcode lesen.
So, wer kann jetzt nicht an einer Abstimmung teilnehmen,
weil er weder Klicker noch Smartphone noch Laptop hat mit dem richtigen Link.
Okay, das sind vereinzelte Leute, die da jetzt mittendrin
sitzen und wahrscheinlich nicht die ganze Unruhe erzeugen wollen.
Ihr könnt, wie gesagt, euch diesen Link auch irgendwann
zu Hause mal angucken und dann gehen auch Bookmarken.
Das heißt also, es müsst ihr nicht immer jeweils hier machen.
Okay, dann starte ich jetzt mal diese Umfrage hier einfach,
um nochmal so ein bisschen zu erfassen,
wie viele Leute hier sind,
wie viele Leute teilnehmen.
Also jetzt einfach mal klicken hier
Jetzt geht es hier wieder los mit den Stimmen.
Also ich nehme an dieser Abstimmung teil mit einem Android-Smartphone.
Das ist Option A, B, iPhone, C mit einem Clicker.
D, Laptop, Notebook, Netbook, Ultrabook und so weiter.
Und eh ein sonstiges Smartphone. Ja, das sieht gut aus
. Also wir haben wieder locker über 300 Teilnehmer hier.
330. Das ist prima. Sehr schön. Übrigens,
nur damit ihr es wisst, das wird ja jetzt auch live gestreamt.
Also es gibt möglicherweise Leute, die gucken das
Irgendwo am Rechner im Büro. Hallo. Auch die Zuschauer
da ganz draußen möchte ich begrüßen.
Ja, okay, dann stoppe ich das mal hier.
Wunderbar. 360 stimmten. Das ist prima.
Gut, gut, gut. Es ist sogar möglich,
dass man, wenn man jetzt den Livestream guckt,
dass man dann auch an dieser Umfrage teilnehmt,
man muss ja nur diesen Link kennen.
Also man muss hier gar nicht körperlich anwesend sein,
auch mit teilnehmen zu können an den Abstimmungen.
So, dann schauen wir doch mal, wie das hier sich ausgestaltet.
Oh ja, Android, 40 Prozent. Boah, das
ist schon beachtlich. Also Ja, das sind richtig viele.
Sehr schön. iPhone gibt es auch ein paar,
ungefähr 20 Prozent, ungefähr 30 Prozent Klicker.
Ja, auch sehr schön. Also hier irgendwie 100 Klicker
, 140 Androids und ähnliches. Das ist prima,
das ist ganz prima, das ist ganz prima.
Jetzt überlege ich, habe ich erst nochmal die andere Abstimmung mache.
Ja, vielleicht können wir das nochmal eben machen.
Nee, ich mache erstmal die andere Ansage. Also,
Wolf, der das System gebaut hat,
hat auch ein paar Informationen zu Sturesi ins Komsi gelegt.
Also wenn ihr da nochmal was nachlesen wollt,
also ob das hier anonym ist und wie das funktioniert,
da könnt ihr nochmal ein bisschen was nachlesen.
Da ist auch der Link nochmal angegeben. Außerdem möchte ich
eine Ansage dran machen für eine weitere Bachelorarbeit, die irgendwo gerade bearbeitet.
Der baut nämlich eine App für die Android-Benutzer unter euch.
Die Idee ist, dass man dann etwas komfortabler an diesen
Abstimmungen teilnehmen kann. Momentan ist es ja nur der Webbrowser,
was wir uns davon versprechen, ist,
dass man eine einfache Handhabung hat, vielleicht eine bessere Anzeige,
Fragenantworten, irgendwie auch pro Veranstaltung speichern kann.
Das Scannen wird wahrscheinlich dann schon integriert sein und weiteres
Für eine Studie dazu. Wäre es jetzt cool, wenn wir Pilotanwender bekommen könnten?
Also wenn diejenigen unter euch, die ein Android-Smartphone haben,
das müssten ungefähr 140 Leute sein nach der Abstimmung gerade,
wenn die Lust hätten, da so ein bisschen sich zu beteiligen als Pilotanwender.
Also wir bräuchten so 10 bis 20 Leute,
die wirklich kontinuierlich jetzt so, dass durch das Semester an dieser Studie teilnehmen.
Der Zeitaufwand ist relativ gering. Also alle zwei Wochen wird
da irgendwie mal eine E-Mail angefordert werden von Irmo.
Und am Ende wird es vielleicht ein leckereres Interview geben.
Aber ihm geht es erstmal darum, möglichst unterschiedlicher Android-Geräte und Versionen da zu beteiligen.
Das heißt, wenn ihr ein Gerät habt und Lust habt,
sowas zu unterstützen, dann könnt ihr die Software von ihm bekommen.
Ihr müsst ihm einfach nur eine E-Mail schicken, die E-Mail Adresse ist hier,
neun Timmern, at Informatik und Hamburg.de und dann einfach so,
ihr habt Interesse an der Android-Studie in Sturesi und so weiter.
Genau, also das einfach, wenn ihr wollt,
das könnt ihr gerne machen,
dann habe ich jetzt hier nochmal die nächste Frage,
um das einfach mal auszuprobieren, welcher der folgenden Begriffe hat,
nichts oder nur sehr wenig mit objektorientierter Programmierung zu tun.
Ich starte die Umfrage und dann könnt ihr euch jetzt überlegen,
ob es A, die Klasse ist, B,
die Methode, ziehe die Klausel oder D,
das Exemplar
So, ihr seht, das ist relativ einfach.
Ist aber tatsächlich, ihr werdet es kaum glauben.
Eine Originalfrage aus unserer Klausur. Und ihr werdet
noch mehr lachen. Ihr werdet noch mehr lachen.
Es gibt Leute, die das falsch beantworten.
So, wir haben wieder ungefähr 350 Stimmen.
390, yeah. 4011. Wahnsinn, 417. Jetzt ist die
Beteiligung viel höher.
Das ist ja sensationell
Toll. Ich stoppe das jetzt mal eben. Doch,
doch. Doch, ich muss das jetzt einfach beenden.
So, jetzt kann man sich hier anzeigen lassen,
wie die Verteilung der Antworten ist.
Danke, danke, danke, danke. Der Tumult ist
wirklich sehr ermutigend. Also das sind hier 33 Prozent Scherzkekse
an Bord. Und 63 Prozent liegen möglicherweise richtig,
aber man sieht hier jetzt die richtige Antwort noch nicht erkennbar.
Jetzt kann ich tatsächlich mit einem weiteren Button-Click hier oben
die richtige Antwort enthüllen. Und dann sieht man hier,
juhu, die richtige Antwort wäre Klausel gewesen. So,
das ist, wie gesagt, eine ganz einfache Frage.
Wir haben dann aber durchaus auch noch andere Kaliber in unseren Klausuren.
Und da komme ich dann nochmal später drauf zurück.
Ich habe noch so ein paar Fragen,
aber die mache ich erst am Ende dieser Veranstaltung heute.
Gut. Dann Worum geht's heute? Heute geht's um Objekte
und jede Grundlage. Wir sind auf Level 1, die
ersten vier Wochen. Letzte Woche habe ich ein bisschen einführend,
was erzählt, was wir unter Objektorientierung verstehen,
insbesondere unter Objekten unter der Programmierung, im Gegensatz zur Modellierung.
Ihr habt auch schon in der Übung gesessen,
ihr habt weitgehend schon die Übungen gemacht.
Heute will ich noch mal so ein bisschen,
oh oh Grundlagenbegriffe einführen und in den nächsten zwei Wochen gibt es dann eher imperative Grundlagen.
Also wir haben heute auch noch mal so ein bisschen die Überleitung machen,
wo denn die imperativen Anweisungen in so einem Objekt notierten System
Und am Ende gehe ich noch mal darauf ein,
wie denn so eine Klassendefinition aufgebaut ist.
Also wir gehen heute mal in den Quelltext einer Klasse.
So, ja, das habe ich letztes Mal schon gezeigt.
Da sage ich auch eigentlich immer wieder gerne,
das ist ein ganz fundamentales Verhältnis bei Software.
Sowohl die ganze Software wird von irgendjemandem in Anspruch genommen,
von einem Menschen, der die Software benutzt,
aber auch innerhalb der Software hat man immer Teile.
Und da kann man immer sagen, der eine Teil benutzt den anderen Teil.
Diese Benutzbeziehung ist sehr, sehr zentral. In der Objektorientierung
sind das Objekte üblicherweise. Also da benutzt ein Klientobjekt,
einen Dienstleister gibt, aber das müssen keine Objekte sein.
Das ist bei jeder Art von Software so,
dass es irgendwo diese Beziehung gibt von Benutzung
Ähm... Wenn ihr euch noch erinnert, dann hatten wir ja
auch mal hier in den Übungen ein bisschen Blue Jay gemacht.
Das ist jetzt hier mehr oder weniger das Projekt,
was ihr in der ersten Woche in den Fingern hattet.
Erweitert um eine weitere Klasse. Was ihr aber schon kennt,
ist, dass ich jetzt hier von so einem Kreis ein Exemplar erzeugen kann.
Und dann hier tatsächlich irgendwie Dinge aufrufen kann, wie sichtbar machen.
Und dann wird hier irgendwo diese Leinwand eingeblendet und ich habe
hier meine Möglichkeiten, weiterhin über die Schnittstelle hier
mein Objekt zu manipulieren
Das heißt, wir können sagen, dieses Objekt,
was da unten auf der Objektleiste liegt,
das bietet Dienstleistungen als Methoden an, also mehrere Methoden.
Und diese Sammlung von Methoden nennen wir halt die Schnittstelle.
Das haben wir in der Übung jetzt auch mit euch ein bisschen durchgekaut.
Diese Dienstleistungen werden von anderen Objekten von den Klienten benutzt.
Wir waren jetzt hier gerade interaktiver Klient oder ich bin hier
ein interaktiver Klient. Das ist eine Spezialsituation in Blue Jay,
das kann nur Blue Jay. Ansonsten ist es eigentlich so,
dass man irgendwie eigentlich Code in einer anderen Klasse stehen hat,
der dann dieses Objekt benutzt
Was wir uns auch schon so ein bisschen hier angucken können,
ist, dass der Anbieter, der eine Dienstleistung anbietet,
ja selber auch wieder seine Teile seiner Dienstleistung einholen kann.
Also wenn zum Beispiel in diesem Beispiel hier,
ich jetzt dem Kreis gesagt habe, mach dich mal sichtbar.
Jetzt sage ich hier irgendwie nach rechts bewegen,
dann bewegt er sich so ein bisschen nach rechts.
Dann macht der Kreis das, indem er sich selbst auf einer Leinwand zeichnet.
Das heißt, ich sage zu dem Kreis einfach,
zeichne dich und mir ist eigentlich egal,
wie du es machst und der Kreis weiß dann,
wie er es machen muss. Da sieht man also auch,
so ein Dienstleister hat eine Schnittstelle, man sieht das auch,
wenn ich hier mal so einen Doppelklick mache,
das haben wir bisher auch nicht in den Übungen groß gemacht,
haben das vielleicht schon gemacht.
Dann sieht man hier, oben angezeigt, die Dokumentation dieser Klasse.
Das ist eine spezielle Sicht auf eine Klasse,
in der man nur das sieht, was für einen Klienten der Klasse interessant ist.
Also was ich als interaktiver Klient wissen will,
was ich da so machen kann, dann stehe ich eben halt,
hier sind die Methoden alle aufgeführt, mit Kommentaren,
was denn da passiert.
Wunderbar. Aber hier steht nichts von der Leinwand.
Ich sehe hier nichts von der Leinwand. Das interessiert mich
auch nicht. Also ich sage nur, sichtbar machen,
bewegen und so weiter. Dass dann eine Leinwand dahinter steckt,
das ist wieder ein Detail von diesem Kreis.
Die Klasse hat da irgendwie einen anderen Dienstleister,
eben halt die Leinwand, die das dann macht.
Das heißt, wir haben genau schon diese Situation,
einen Dienstleister nimmt, um eine Dienstleistung anbieten zu können,
einen weiteren Dienstleister in Anspruch.
Sehr zentral in der Objektorientierung
Okay. Und wie gesagt, diese ganzen Dienstleistungen, Methoden,
nennen wir auch Schnittstelle. Jetzt ist es ja so,
und das habt ihr ja auch schon mitbekommen,
dass solche Objekte auch einen Zustand haben können.
Also das Verhalten, dass so ein Objekt zeigt,
das steckt in den Methoden drin. Die Methoden definieren
das Verhalten eines Objektes. Wie das intern umgesetzt ist,
ist es üblicherweise nicht sichtbar, hinter der Schnittstelle verborgen.
Und Objekte können auch einen Zustand haben. Hier ist mal
so ein Beispiel in schon einer Notation,
die ihr erst noch ein bisschen später kennenlernen werdet,
das ist hier so ein so ein Diagramm von einem Objekt, ein Objektdiagramm.
Man sieht hier irgendwie, es ist ein Objekt einer Klasse Girokonto.
Und wir stellen uns vor,
man bei einem Girokonto kann ich irgendwie auszahlen, aufrufen,
kann einen Betrag angeben, der ausgezahlt werden soll.
Und ich kann auch irgendwie erst mal fragen,
ob Auszahlen überhaupt möglich ist für einen bestimmten Betrag.
Also ob das gedeckt ist. Gibt es hier irgendwie
Informationen über den Dispo und den Saldo?
Und das ist irgendwie hier so, das ist der Zustand.
So jedes Konto hat Jan Saldo und vielleicht auch ein Dispo.
Und das ist üblicherweise gekapselt. Und dieser Zustand kann sich ändern,
ich kann was einzahlen,
dann hat das Konto irgendwie mehr Geld drauf oder ich kann was auszahlen,
dann ist weniger Geld drauf.
Und je nach Zustand des Kontos ändert sich eben halt
auch die Reaktion
Wenn wir uns das jetzt nochmal so, sagen wir,
logisch veranschaulichen, dann ist es so,
dass wir hier uns Objekte so vorstellen können, wie so Böbbel, so runde Dinger.
Und die Methoden sind die Schnittstelle, das,
was nach außen gegeben wird, also drumherum sind die Klienten.
Und da innen drin ist so ein interner Zustand,
der hier so ein bisschen gekapselt ist, also die Methoden verstecken sozusagen diesen Zustand.
Also Verhalten ist in den Methoden definiert,
der Zustand in den Zustandsfeldern, das habt ihr euch schon gesehen,
wenn ihr diesen Objektinspektor aufgemacht habt in BlueJ,
wenn ich jetzt hier einen Doppelklick drauf mache,
dann sehe ich halt hier den Objektzustand,
die Felder des Objektes,
die Belegung der Felder und diese Belegung definieren den Zustand.
Hier sieht man jetzt aber nicht diese schöne Darstellung,
dass da jetzt noch so die Methoden drumherum sind.
Ich kann ja hier nichts machen. Ich kann jetzt hier nicht
irgendwie was manipulieren oder was. Ich komme da nicht ran.
Blue Jay ist sowieso schon ziemlich speziell, dass es das ermöglicht.
Normalerweise kann man in Objekten nicht so ohne weiteres reingucken.
Und wenn ich was machen will, muss ich immer über die Schnittstelle gehen.
Das ist die Idee, ein Klient muss eigentlich immer die Schnittstellen,
die Methoden benutzen, um irgendwas an dem Zustand zu ändern.
Wenn jetzt so ein Methodenaufruf kommt, von außen irgendwie Kontrollfluss. Ihr erinnert euch,
der Kontrollfluss, der so durch die Objekte fließt,
dann kann man sich das hier so vorstellen,
dass in der Methode jetzt sequenziell Anweisungen stehen, im Rumpf dieser Methode.
Die werden dann einfach ausgeführt und am Ende wird wieder zurückgesprungen zu dem Aufrufer.
Das ist mehr oder weniger das, was hier passiert.
Und das ist die sequenzielle Ausführung von Anweisungen,
die wir uns dann auch noch ein bisschen intensiver ansehen werden.
Das ist, da kommt wirklich die imperative Programmierung ins Spiel. Das heißt,
wenn ihr so ein ganzes System habt von Objekten,
dann gucken wir uns Zoom hier ein Objekt an,
dann sehen wir jetzt, aha,
so ein Objekt bietet Dienstleistungen an,
hat einen Zustand und in den Methoden stehen jetzt Anweisungen,
die dann sequenziell ausgeführt werden
Und diese Sequenziell ausgeführten Anweisungen folgen der emperativen Programmierung,
man könnte auch sagen, da werden Algorithmen programmiert.
Das werden wir uns auch noch ein bisschen genauer ansehen.
Hier ein Beispiel ist ja der Zeichner. Das ist jetzt eine Klasse,
die ihr auch in dieser Woche ein bisschen bearbeiten werdet.
Das ist jetzt, die macht jetzt genau das,
was ihr in der ersten Woche interaktiv gemacht habt.
Das heißt, ihr habt ja von diesen Klassenexemplare erzeugt,
dann irgendwie ein Bild gemalt. Das macht der jetzt hier
auch. Das ist also hier die Klasse, Klaas Zeichner.
Und jetzt sind wir das erste Mal drin im Quelltext einer Klasse.
Wir sehen also tatsächlich wie so eine Klassendefinition aussieht
Und wir sehen hier, es gibt nur eine Methode und die heißt Zeichner.
Also hier, klasse Zeichner, dann sieht man hier,
das ist so ein bisschen grün hervorgehoben. Ich hoffe,
das kann man einigermaßen sehen, dass hier das so ganz runtergeht.
Und hier ist die schließende Klammer für den Rumpf der Klasse.
Ja, und dann haben wir hier eine Methode,
nur eine einzige Methode, also zeichne und die macht halt irgendwas.
Die erzeugt hier mehrere lokale Variablen. Gucken wir uns gleich
noch mal ein bisschen genauer an. Ich kann ja hier
mal zeigen, wie man jetzt da so einen Haltepunkt reinsetzt.
Das ist übrigens ganz schön im Blue Jay, ganz einfach.
Ich kann einen Haltepunkt reinsetzen und sage jetzt bitte Zeichner,
ich mache jetzt mal hier so ein Exemplar von einem Zeichner
, zack
Und sage dem Zeichner, zeichne doch mal was.
Los, Zeichner, leg los. So,
und wenn der das jetzt macht, dann haben wir genau die Situation,
jetzt kommt hier der sogenannte Debugger von Blue J. Also ein Werkzeug,
mit dem ich so schrittweise durch die Anweisungen durchsteppen kann.
Und wenn ich jetzt hier an dieser Stelle bin,
dann ist das hier gelb markiert.
Das heißt, diese Zeile ist noch nicht ausgeführt.
Diese Anweisung ist noch nicht ausgeführt. Also hier wird ein Quadrat
erzeugt und dann wird das irgendwo hier in der Variablen zugewiesen.
Also gibt es irgendwie eine Variable, lokale Variable Wand,
kommt alles noch ein bisschen ausführlicher
Und dann wird dieser lokalen Variablen hier etwas zugewiesen,
nämlich hier so eine Referenz auf so ein Quadrat.
Da wird also ein Quadrat erzeugt. Und dann wird
in der nächsten Zeile wird hier gesagt, sichtbar machen.
Wenn ich jetzt also hier sage, Schritt,
dann hat er jetzt diese eine Zeile ausgeführt.
Das Quadrat ist erzeugt worden. Und jetzt rufe ich auf
sichtbar machen. Und jetzt kommt tatsächlich hier diese Leinwand.
Da müsste die Leinwand irgendwo sein, da ist die Leinwand.
So, und da ist tatsächlich jetzt,
weil ich diesen blöden Kreis da schon hingelegt habe,
müsste ich nochmal eben hier vielleicht in Blue Jay rein.
Moment, wo ist Blue Jay? Machen wir den mal
eben unsichtbar
Das geht nicht. Okay, interaktiv gerade nicht. Also,
ich kann jetzt hier weiter, jetzt habe ich diesen blöden Kreis da zu sehen.
Leider ist das ein bisschen, ne, ist nicht so schlimm.
So, dann sage ich jetzt hier wieder einen Schritt ausführen
und dann wird dieses Ding hier vertikal bewegt.
Die Farbe ist geändert worden, gelb, genau,
jetzt wird das Ding vertikal bewegt, also 80 nach unten, vertikal.
Und da wird noch die Größe geändert. So,
und dann ist das Ding hier auch noch ein bisschen größer.
Das Gleiche passiert jetzt hier, ja,
also sichtbar machen des Quadrates, da ist das nächste Quadrat,
dann wird das Blau gefärbt, dann wird das horizontal bewegt,
vertikal bewegt und schon, das ist ein Fenster.
Und dann hier das Gleiche mit einem Dreieck, zack,
traumhaft, habe einen neuen Kreis erzeugt.
Das ist dann die Sonne, die wird dann rot gemacht.
Und dann wird die hier noch horizontal bewegt. Ganz großartig
. Das ist eine tolle Zeichnung. Wirklich sagenhaft. Und
wenn ich jetzt hier einmal durch die ganze Methode durchgesteppt bin,
also schrittweise diese Anweisungen ausgeführt habe, bin ich jetzt hier am Ende,
wenn ich hier einen weiteren Schritt mache,
ist die Ausführung auch beendet.
Und ich kann das dann auch hier beenden und dann wird
tatsächlich hier auch das Fenster geschlossen und alle Objekte weggeräumt.
Das ist also die Möglichkeit, dann wirklich schrittweise hier Anweisungen
zu bearbeiten. Ihr werdet in dieser Woche in den Übungen
genau an diesem, an dieser Methode
ein bisschen weiterschrauben
Was ich einfach nochmal hier so zeigen will, ist,
dass diese Klasse hier, wir haben gerade jetzt gesagt,
Objekte können Zustand haben.
Diese Klasse hat zum Beispiel überhaupt keinen Zustand.
Also die Exemplare dieser Klasse, es gibt hier keine Exemplarvariablen.
Kommen wir gleich drauf, was das ist. Sie sind
einfach nicht hier. Das heißt, eigentlich sieht das Objektieren
ein bisschen anders aus. Das sieht eigentlich so aus.
Es hat irgendwie nur eine einzige Methode, die heißt Zeichner.
Die ist jetzt sozusagen Teil der Schnittstelle nach außen.
Es gibt keine Felder, keinen Zustand. Und dann ist
es tatsächlich so der Klient, ruft Zeichner auf.
Also wird dann hier wandgleich New Quadrat und so weiter.
Und dann wird hier das ausgeführt. Und das haben wir
gerade sozusagen live gesehen. Das ist dann die sequenzielle Ausführung
der Anweisung im Rumpf
Okay, das ist das, was an dieser Stelle hier passiert.
Und ich will auch jetzt so ein paar weitere Begriffe einführen.
Das eine ist, ihr habt jetzt hier schon gesehen,
der Zeichner benutzt ein anderes Objekt.
Wir haben hier ein anderes Beispiel. Aus den letzten Wochen
hat der EC-Automat und dieses Girokonto. Objekte interagieren in dem Objekte,
Methoden an anderen Objekten aufrufen. Wir haben gerade gesehen,
man kann das auch in diesen Figurobjekten machen oder hier so.
Zum Beispiel kann das der EC-Automat irgendwie erstmal beim Girokonto nachfragen,
ist denn das Auszahlen möglich?
Da will jemand 300 Euro abheben
So, und was wir jetzt hier sehen ist,
das habt ihr auch in den Übungen schon gemacht,
ihr habt dann auch Parameter übergeben.
Das heißt, ihr habt bei einem Aufruf etwas mit angegeben.
Zum Beispiel hier die 300. Und dieses Parametrisieren,
da muss man sehr genau hingucken, da gibt es nämlich einmal
die Sichtweise des Klienten und einmal die Sichtweise des Dienstleisters.
In der Sichtweise des Klienten ist das Entscheidende hier,
der aktuelle Parameter, weil da gibt nämlich der Klient,
der jetzt diese Dienstleistung aufruft, der erstmal diese Abfrage haben will,
ist das überhaupt möglich?
Gibt einen konkreten Wert an. Aktueller Parameter heißt so viel
wie ein echter tatsächlicher Wert, der da übergeben werden muss.
Also zum Beispiel hier 300 Euro
Aktueller Parameter ist eine Heldentat der deutschen Informatiker.
Denn das ist die Übersetzung des englischen Actual Parameter.
Und Actual heißt nicht aktuell, sondern tatsächlicher Parameter.
Das ist der tatsächliche Parameter. Aber weil sämtliche Lehrbücher auf Deutsch jetzt
überall aktueller Parameter schreiben, sagen wir auch aktueller Parameter.
Nur euch, dass das klar ist,
also das ist nicht so glücklich. Eigentlich ist es der,
man kann das mit dem aktuell auch noch irgendwie so reindeuten,
dass es vielleicht auch ganz gut passt.
Das ist nur der Aktuelle. So,
und dann gibt es aber natürlich die Sicht des Dienstleisters.
Der hat irgendwann mal behauptet, also wenn man mich aufrufen will,
wenn man zum Beispiel von mir wissen will,
ob ein bestimmter Betrag gedeckt ist, ich auch diesen Betrag bekomme.
Und das ist eben halt das, was in der Dienstleister üblicherweise deklariert.
Das haben wir schon so gesehen. Man kann so an seiner Schnittstelle
ja dann sagen, was man haben will als Dienstleister.
Und dann sagt er hier, formaler Parameter. Und diesen Parameter hier,
der ja auch noch einen Typ hat, das ist zum Beispiel etwas,
was ein Betrag sein muss, was immer das ist.
Das ist etwas, was hier beim Dienstleister steht.
Da steht üblicherweise im Kopf einer Methode, wenn wir den
solche Klassendefinitionen selber schreiben, werden wir gleich noch machen.
Okay. So, und dann ist es tatsächlich so,
so ein Dienstleister kann nach dem Ende einer Methodenausführung auch ein Ergebnis zurückgeben.
Also ich kann tatsächlich hier jetzt, man sieht Tier ist Auszahlen möglich.
Dann steht da hier noch so ein Doppelpunkt Bulien.
Das ist dann der Ergebnis-Typ in der UML-Notation.
Das heißt also, hier kommt möglicherweise jetzt True zurück.
Das heißt, dieses Konto hat einen Zustand, das sagt,
ja, ich kann hier 300 Euro auszahlen.
Und dann ruft der EC-Automat wirklich das Auszahlen aus und sagt
wirklich jetzt, hier, gib mir mal 300 Euro.
Okay, das ist auch nochmal so ein bisschen zentral für Objektorientierung,
Methodenaufrufe mit Parametern. Was wir auch in den Übungen schon
so ein bisschen diskutiert haben, ist die Frage einer Signatur.
Das ist im Einleitungstext des ersten Aufgabettes ja so ein bisschen
Da haben wir dann gerne mal nachgefragt, was ist denn
die Signatur dieser Methode? Also habe ich hier gerne gesagt,
nehmen wir mal so ein Kreisexemplar wieder hier, mach doch mal.
So, und jetzt habe ich hier gefragt,
was ist denn die Signatur von dieser Methode?
Na klar. Wenn man das gelesen hat, weiß man,
die Signatur ist hier in diesem Fall Größe ändern in.
Weil die Signatur ist definiert als der Name einer Methode in Java
, in Java. Der Name der Methode plus Anzahl,
Stelligkeit, also Reihenfolge und Typen der Parameter.
Aber zum Beispiel der Name des Parameters ist erstmal nicht Teil
der Signatur. Also hier Name, Methode, Anzahl,
Reihenfolge und Typen der Parameter.
Das gehört zur Signatur einer Methode
Wenn man eine Methode sinnvoll aufrufen will, also muss man
natürlich mehr wissen. In dem Fall zum Beispiel,
wenn ihr hier euch diese andere Methode anguckt,
von Dreieck, mach nochmal ein Dreieck, so erzeugt,
jetzt kann ich hier die Größe ändern.
Jetzt hat diese Operation, diese Methode hat die Signatur Größe ändern,
int-int. Zwei Int-Parameter. Jetzt muss ich schon wissen,
was ist jetzt die Höhe und was ist die Breite?
Und das weiß ich nicht vom Typ her. Es sind einfach
beides ganze Zahlen. Da brauche ich dann schon mehr Informationen.
Das heißt, diese Informationen sind schon auch relevant für einen Klienten.
Der Name des Parameters, Der Ergebnistyp ist auch wichtig.
Was kommt denn da was raus? Und der Kommentar,
der üblicherweise da stehen sollte, ist auch wichtig.
Das ist alles wichtig. Wir unterscheiden nur,
die wir sozusagen, wir differenzieren noch,
dass wir sagen, diese Bestandteile gehören zur Signatur.
Den Signaturbegriff, werden wir noch wieder brauchen im Laufe des Semesters.
Von daher haben wir ihn einfach mal so ein bisschen formaler
schon mal eingeführt. Genau. Also das ist der Signaturbegriff
. So, dann haben wir bisher über Objekte gesprochen,
über konkrete Objekte. Ich habe ja Objekte erzeugt,
habe man
den Zustand mir angesehen
Was ihr bisher noch nicht so richtig gesehen habt,
wir haben jetzt eben einmal in so einen Quelltext hineingesehen,
also wir haben uns mal hier tatsächlich so den Quelltext der Klasse-Zeichner angesehen.
Das heißt, wir machen hier so einen Doppelklick da drauf und
dann sehen wir tatsächlich hier Quelltext, Programm-Code. Ganz wichtig nochmal,
wenn ich von einer Klasse ein Exemplar erzeuge,
also mit New-Kreis zum Beispiel ein Exemplar erzeuge,
dann ist das ein Objekt,
der Begriff Exemplar und Objekt wird bei uns hier austauschbar verwendet,
dann differenzieren wir noch nicht sehr stark.
Am Ende des Semesters machen wir eine kleine Differenzierung,
aber erstmal könnt ihr sagen,
Exemplar oder Objekt
ist das Gleiche
Vorläufig gilt das so. Es gibt auch Lehrbücher, die sprechen davon Instanzen.
Wenn ihr irgendwelche deutschen Lehrbücher in die Finger bekommt,
da ist die nächste Heldentate,
da ist dann das englische Instance in Instance of a Class,
übersetzt mit Instanz und eine Instanz in Deutschland ist was ganz anderes.
Aber gut, also Exemplar finde ich eigentlich sehr schön und
wir verwenden das auch überwiegend hier, wenn jemand Instanz sagt,
werden wir ihn nicht aus dem Übungsbetrieb verbannen,
aber ist halt bei uns nicht so gerne gesehen.
Das heißt, eine Klasse definiert das prinzipielle Verhalten aller ihrer Exemplare.
Das ist sozusagen in dem Quelltext festgelegt.
Trotzdem kann ich von einer Klasse natürlich beliebig viele Exemplare erzeugen,
haben wir auch in den Übungen schon mit euch besprochen.
Jedes Exemplar kann einen eigenen Zustand haben,
das habt ihr auch gesehen
Das heißt, verschiedene Exemplare derselben Klasse können durchaus unterschiedlich reagieren
auf dieselbe Anfrage. Wenn ich das eine Exemplar,
das Kreisexemplar frage, welche Farbe hast du denn,
dann sagt das vielleicht gelb und das andere sagt blau.
Beide sind aber von derselben Klasse. Das heißt,
die Klasse lässt dann Varianz zu. Okay. So,
und jetzt haben wir hier schon gerade gesehen,
innerhalb eines Rumpfes einer Methode hier, also Public Void, zeichne.
Da haben wir jetzt hier sequenzielle Anweisungen. Das sind hier die Dinge,
die dann tatsächlich sequenziell ausgeführt werden. Und das ist,
was wir jetzt ja hier primär im ersten Semester in SE1
uns ansehen werden, nämlich so das Programmieren im Kleinen.
Das heißt, früher hat man darunter nur verstanden, Algorithmen.
So, wie baue ich denn einen Algorithmus? Wie baue ich
ein Programm, das einen Algorithmus umsetzt? Da war dann die Idee,
man baut so ein lauffähiges Programm, das aus Anweisungen besteht,
das ist bei uns zwar auch ein zentrales Thema, diese imperativen Grundbegriffe,
aber wir haben das halt eingebaut in den größeren Kontext von.
Eigentlich sind diese sequenziellen Anweisungen innerhalb des Rumpfes einer Methode,
das heißt also, wir betrachten hier auch Klassen,
kleine Systeme bestehen aus mehreren Klassen,
die haben ihre Methoden und in den Anweisungen,
in den Methoden stehen dann
diese Anweisungen
Was wir hier erstmal nicht betrachten, ist,
programmieren im Großen, also komplexe Anwendungsprobleme,
professionell im Team lösen, wie kann ich dafür sorgen,
dass die Architektur eines solchen großen Systems nicht über die Zeit zerfällt.
Teilweise machen wir das schon in SE2 so ein bisschen,
also so Entwurfsfragen, wie kann ich da bestimmte Strukturhilfsmittel zur Hilfe einsetzen.
Das kommt aber erst in SE2. Okay, hier jetzt mal so
ein ganz banales, erstes Beispiel für so einen imperativen Algorithmus.
Ziemlich blöd, aber es ist zumindest anschaulich.
Also wir wollen das Maximum von zwei
Ganzen, zwei natürlichen Zahlen ermitteln. Also hier so ein Algorithmus mal so aufgeschrieben.
Das erste ist, das ist unabhängig von einer konkreten Programmiersprache.
Algorithmen sollten eigentlich Programmiersprachen unabhängig sein. Der Algorithmus besagt,
Vergleiche, zwei natürliche Zahlen A und B.
Und wenn A größer als B ist,
dann setzt er das Ergebnis Max gleich den Bett von A,
sonst setzt er das Ergebnis, mag es gleich den Bett von B.
Das ist sehr iperativ formuliert. Wir haben also irgendwelche Variablen,
die dann irgendwelche Werte halten können und die werden da gesetzt.
Das heißt, also das ist das, was hier dabei ist.
Algorithmus besteht aus einer Folge von Aktionen.
Das sind dann keine Anweisungen,
sondern Aktionen
Vergleichen, setzen, diese einzelnen Aktionen haben wir auch immer
einen gewissen Aufwand. Das ist ganz wichtig, wenn man
Algorithmen später systematisch betrachten will, wie aufwendig sie sind.
Dann muss man immer gucken, wie aufwendig es denn die einzelnen Operationen.
Da komme ich auch, kommen wir zum Ende des Semesters,
gehen wir da so ein bisschen drauf ein.
So, jede Aktion bezieht sich hier auf Variablen,
also ein imperativer Algorithmus, arbeitet viel mit Variablen.
Also A, B und Max sind hier irgendwelche Variablen und die auch teilweise verändert werden.
Also Max wird hier irgendwie gesetzt und Max ist von einem bestimmten Typ.
Man kann vermuten, das ist der Typ natürliche Zahl ist,
weil auch A und B vom Typ natürliche Zahl sind.
Also natürliche Zahl ist hier sozusagen der Typ der Variablen,
die betrachtet werden. Das ist so ganz schön.
Wenn wir jetzt einfach nur auf imperative Programmierung gucken,
die in Java ja in den Objekten drinsteckt,
dann ist zum einen wichtig,
dass wir die Ausführungsreihenfolge tatsächlich festgelegt haben durch die Reihenfolge der Anweisung im Quelltext.
Also wenn in einer Methode Anweisung da untereinander stehen,
dann werden die auch in der Reihenfolge
üblicherweise ausgeführt
Das ist anders als zum Beispiel in den funktionalen Sprachen,
auch in den logischen Programmiersprachen.
Da sind das einfach Aussagen, die formuliert werden.
Und das sagt erstmal nichts über die Reihenfolge aus. Das heißt,
hier in der Imperativen Programmierung ist das schon mal relativ schlüssig.
Einfach Anweisungen, die direkt dem Computer sagen, was er tun soll.
Man kann jetzt mithilfe höherer Programmkonstrukte, bestimmte Anweisungsfolgen zusammenfassen und sagen,
diese Anweisungsfolge benenne ich jetzt mal so und so.
Und dann kann ich sie einfach nur über diesen Namen aufrufen.
Das werden wir uns auch nächste Woche ausführlich ansehen.
Und wir werden uns auch in den nächsten zwei Wochen
dann noch das Konzept von Variablennähe ansehen
Was das denn bedeutet, solche imperativen Variablen,
dass dieser Begriff eigentlich wenig mit dem variablen Begriff in der Mathematik zu tun hat.
Das ist immer möglicherweise missverständlich. Die ganze emperative Programmierung baut
auf dem Konzept des von Neumann-Rechners auf, das heißt,
hier ist die Logik, wir haben eine Maschine mit einem Speicher,
auf diesem Speicher werden Anweisungen ausgeführt, jetzt der Speicherinhalt wird verändert.
Und die imperative Programmierung ist dann eine Astraktion über dieser sehr nackten Speicherstruktur.
Zwischen sind wir bei Objekten, die schon ein bisschen,
sagen wir, reicher sind in dem, was sie können.
Das ist sozusagen ein Bottom-Up immerhin, höhere Abstraktionsschichten bauen über
der Maschine. Aber es ist immer noch sehr maschinenorientiert,
wenn die logische und die funktionale Programmierung,
die basieren auf ganz anderen Grundlagen, auf mathematischen Kalkülen,
auf Logikregeln und kommen sozusagen von der Mathematik und bilden das
dann ab auf den Computer.
Wir kommen aber jetzt sozusagen von der Maschine und betrachten was
eine Maschine so für uns tun kann.
Also das ist eben halt sehr stark abhängig vom Zustandskonzept in
dem Speicher, sind Speicherzellen und ihren Inhalte können wir verändern
Die Ablaufsteuerung ist, geschieht durch Kontrollstrukturen,
auch Kontrollstrukturen sehen wir uns ausführlich an. Die simpelste Kontrollstruktur,
die ihr kennt, ist tatsächlich hier die Sequenz.
Die haben wir jetzt, die werdet ihr diese Woche kennenlernen,
tatsächlich hier einfach Anweisungen werden der Reihe nach ausgeführt.
Das ist die Sequenz. Und dann gibt es aber auch
noch die Fallunterscheidung und die Wiederholung, gebe jetzt einen kurzen Überblick darüber,
also Sequenz, einfach nur eine Anweisung nach der anderen.
Es gibt auch die leere Anweisung, also da passiert einfach nichts.
Man muss nur wissen, wie die voneinander getrennt sind.
Also hier tatsächlich, hebe den Hörer ab,
wähle die Telefonnummer, führe das Gespräch,
lege den Hörer auf,
sehr einfach
informelle Algorithmus telefonieren
Hier jetzt, sagen wir, ein nicht ganz so glückliches Beispiel,
das ist nämlich eigentlich variablen Deklarationen, die dann auch gleich initialisiert werden.
Das sind eigentlich glücklicherweise keine Java-Anweisungen. So, und dann
haben wir hier die Falleunterscheidung, das werdet ihr ganz viel brauchen.
In der Programmierung kann man eigentlich nichts Vernünftiges tun, ohne so eine Fallunterscheidung.
Auch die ganzen grundlegenden theoretischen Konstrukte zur Programmierung brauchen immer mindestens eine Fallunterscheidung.
Vergleich mit Null oder so zumindest. Und was man auch noch braucht,
ist dann die Möglichkeit, Dinge wiederholt auszuführen, schleifen.
Aber hier erstmal, wenn irgendetwas zutrifft,
dann mach er das eine,
wenn es nicht zutrifft,
dann mach was anderes
Wenn die Telefonnummer beim Telefonieren,
wenn ich jetzt so ein Telefon habe mit einem Adressbuch,
wenn die Telefonnummer gespeichert ist,
dann drücken wir die Kurzwahltaste, sonst wählen die Telefonnummer.
Und wenn der Gesprächspartner antwortet, dann führt das Gespräch,
sonst natürlich nicht. Und lege den Hörer auf. Klar,
das ist in Java hier, sieht das ungefähr so aus,
wenn A kleiner B ist, dann ist das Minimum durch A,
Elz, mitweise Minimum, den Wert von B zu.
Das ist die Fallunterscheidung und zum Schluss die Wiederholung,
die wir hier erstmal in den ersten Wochen
noch gar nicht angucken werden,
weil da gibt es
relativ fortgeschrittene Konzepte dazu
Zum Beispiel hier, solange da Geld da ist,
wiederhole ich mir den Hörer ab, wirf Geld ein,
führe das Gespräch regeln Hörer auf.
Üblicherweise irgendwie eine logische Bedingung damit verknüpft,
also solange noch irgendetwas zutrifft, macht das weiter.
Da gibt es dann so lange noch Schleifen, solange bis Schleifen
und so weiter. Das gucken wir uns nochmal genauer an,
aber erst in ein paar Wochen, was wir relativ früh brauchen,
sind die sogenannten imperativen Variablen.
Da ist es so, dass so eine Variable hier Ja,
wie soll man das mal sagen?
Eine Variable repräsentiert so ein Stück Speicher, mal grob gesagt.
Also eine Abstraktion eines physischen Speicherplatzes. Üblicherweise hat er einen variablen Namen,
über den sie angesprochen werden kann und hat so den Charakter eines Behälters.
Man kann da was reinschmeißen, eine Belegung reinsetzen.
Und so eine Variat hat auch einen Typ. Also hier
in diesem Beispiel habe ich jetzt sowas wie einen Pfefferstreuer,
da würde ich jetzt erwarten, wenn der Pfeffer draufsteht,
dass dann da auch nur Pfeffer reinkommt.
Wie viel Pfeffer drin ist, das kann wieder variieren,
aber es sollte vom Typ her Pfeffer sein.
Genauso ist es bei einer ganzzahligen Variablen in der Programmierung
Und da sollte üblicherweise auch nur eine ganze Zahl drin gespeichert sein.
Und üblicherweise garantiert mir das auch der Compiler.
Hier haben wir mal so ein Beispiel,
nehmen wir mal an, ich habe hier diese Geschichte,
dass hier ein neues Quadrat erzeugt wird.
Hier, an dieser Stelle wird ein Quadrat erzeugt.
Und dann kann ich über diese variable Wand,
das ist eine variable,
die ist deklariert von diesem Typ Quadrat,
das ist Objektvariablen,
gucken wir uns später noch intensiver an
Und dann kann ich über diese Variable hier die Operation sichtbar machen, aufrufen.
Und dann kann ich hier aufrufen, Farbe ändern.
Und hier könnte ich jetzt an dieser Stelle statt Gelb,
das ist eine Zeichenkette, ich soll ja, wenn ich eine Farbe angeben soll,
muss ich ja als Zeichenkette den Namen der Farbe angeben.
Ich könnte jetzt hier auch 60 angeben.
Das wird jetzt vermutlich schiefgehen. Wenn ich das jetzt übersetze,
dann sollte der Compiler eigentlich meckern.
Method Farbe ändern in Klaas Quadrat, Kennert be Apply 2
und so weiter, Given Types.
Also ich habe hier was angegeben
Ganze Zahl, die Methode möchte aber eine Zeichenkette bekommen,
also ist es hier ein Typfehler. Das ist tatsächlich sehr hilfreich,
dass Programmiersprachen, die so typisiert sind wie Java,
mir da auf die Finger klopfen, wenn ich was Falsches tippe.
Manchmal vertippt man sich einfach. Und wenn jetzt die 60 irgendwie,
sagen wir, irgendwas umgewandelt würde, was eine Zeichenkette ist ungefähr,
dann wäre das, sagen wir nicht so glücklich.
Es gibt Programmiersprachen, die sind da etwas toleranter für den
Einstieg zum Programmieren. Lernen scheint es uns ganz sinnvoll,
dass man hier eine Programmiersprache wie Java nimmt,
die da ein bisschen strenger ist.
Also hier tatsächlich dann
auch dieses Gelb erwartet
Okay, vor der Verwendung einer Variablen muss ich sie deklarieren.
Also auch das, einfach, dass ihr nochmal so ein
bisschen seht, was ihr überhaupt in dieser Methode passiert.
Hier oben stehen diese variablen Deklarationen. Das muss ich so
machen. Ich kann also jetzt nicht hier einfach mit der
variablen Wand irgendetwas tun, bevor sie nicht deklariert ist.
Wenn ich jetzt diese Zeile hier auskommentiere,
kann ich hier tatsächlich einfach mit F8 in Blue Jay auskommentieren.
Dann, wenn ich das jetzt versuche zu übersetzen,
dann wird gemeckert, Cannot Fine Zimble, variable Wand.
Ich kann also mit dieser Wand hier,
mit dieser Variante nichts tun,
bevor sie
nicht deklariert ist
Das ist also tatsächlich wichtig, dass man das immer tut.
Und wenn so eine Variable deklariert ist, dann kann sie halt verwendet werden.
Und dann sagt aber der Typ der Variablen auch,
was man damit machen kann,
also mit so einer Variablen vom Typ Quadrat,
kann ich halt nur die Operation aufrufen, die ein Quadrat anbietet.
Der Klassik Quadrat definiert. Okay, was man vielleicht nochmal sagen kann,
ist, wenn so eine Variable deklariert wird,
also wenn wir jetzt auch im Quelltext Variablen deklarieren,
Sind die Varialien, die ihr hier seht?
Das sind lokale Varianten. Das heißt, diese Variablen,
hier diese vier Variablen, sind deklariert im Rumpf dieser Methode.
Und sobald Variablen im Rumpf einer Methode deklariert sind, heißen sie lokale Variablen.
Und lokale Variablen haben keine Standardbelegung. Also ihr müsst erstmal etwas reinspeichern,
bevor ihr das dann, was da drin ist, auch benutzen dürft.
Also wenn ich jetzt zum Beispiel hier die variable Wand deklariere,
aber diese Initialisierung nicht vornehmen würde,
also an dieser Stelle jetzt nicht dieser Variablen,
die Referenz auf ein Objekt speichern würde.
Ich kann also auch mal diese Zeile hier einfach auskommentieren.
So, auskommentiert. Wie ich das jetzt übersetze,
dann sollte der Compiler auch wieder meckern, das tut er auch.
Nämlich an dieser Stelle sagt er, Variable Wand,
might not have been initialized. Das heißt,
du versuchst mit der Variablen was zu machen,
bevor du überhaupt irgendwas drin gespeichert hast, bevor die initialisiert ist.
Das heißt, Variablen müssen üblicherweise initialisiert werden. Bei den Exemplarvariablen,
die wir uns ja gleich nochmal nach der Pause ansehen werden,
ist das ein bisschen anders.
Aber prinzipiell ist das so, dass die eigentlich initialisiert
werden sollten
Man kann auch direkt bei der Deklaration einer Variablen sie initialisieren.
Ich kann also auch sowas schreiben wie hier, eine Variable vom Typ Int,
die I heißt und die wird gleich bei der Deklaration initialisiert.
Während das hier zwei verschiedene Schritte sind. Einmal wird die
Variable nur deklariert, eine Variable B vom Typ Bulien,
also eine Variable, die Wahrheitswerte enthält.
Das finden wir uns auch nochmal ein bisschen genauer ansehen.
Und dann wird in den nächsten Zeile hier tatsächlich eine Zuweisung vorgenommen.
Also irgendein Wahrheitswert wird in der Variable gespeichert. Ja,
okay, das ist soweit alles zu dem,
was wir hier jetzt gemacht haben. Das heißt also,
wenn wir jetzt noch mal so ein bisschen Revue passieren lassen,
was passiert ist, Objekte,
ganz wichtig haben Zustand und bieten Dienstleistungen an.
Der Zustand wird in den Feldern gehalten, das Verhalten wird über die Methoden definiert.
Das, was an Klient aufrufen kann, das ist die Schnittstelle.
Wir werden, ich kann hier vielleicht noch mal,
habe ich die Lösung jetzt hier?
Nee, habe ich jetzt nicht hier. Ihr werdet auch
in den Übungen dazu kommen, dass ihr Methoden baut,
die Nur innerhalb der Klasse benutzt werden können.
Was wir bis jetzt gesehen haben, ist,
dass die Methode zum Beispiel hier, die Methode des Zeichners,
die ist public und kann für einen Klienten von einem Klienten benutzt werden.
Das gehört zur Schnittstelle dieser Klasse, aber es ist auch möglich,
Methoden privat zu machen, also sie zu verstecken,
dass sie nur als Hilfsmittel innerhalb der Klasse zur Verfügung stehen.
Dass wir in den Übungen diese Woche auch tun. Okay. Gut,
Klassen sind Schablonen zur Erzeugung von Exemplaren, ganz wichtig.
Das ist etwas, was wir hier schon betonen.
Objektuelle Programmierung heißt, wir haben Klassen, die als Schablonen dienen können.
Wir versuchen nicht, über Klassifikationen zu reden.
Also irgendwie die Welt in Kategorien einzuteilen,
sondern schon sehr technisch hier Klassen sind Schablonen.
Okay, und dann runtergebrochen jetzt zur Richtung operative Programmierung.
Innerhalb einer Methode werden Anweisungen sequenziell ausgeführt.
Und diese Anweisungen folgen Kontrollstrukturen, die elementarste ist die Sequenz.
Die Fallunterscheidung werdet ihr kennenlernen und die Wiederholung kommt sicherlich auch nach.
Gut, und dann ganz wichtig, Variablen,
die ihre Belegung dynamisch ändern können, sind zentral in der imperativen Programmierung.
Das soweit jetzt erstmal hier für diesen begrifflichen Teil gibt es
dazu noch irgendwie Fragen
Es Fragen zu dem, was ich gerade in Blue Jack
gezeigt habe oder da ist eine Frage da ganz oben
. Kannst du die Frage nochmal wieder oder lauter sprechen?
Sie fragt, ob man Rekursion auch unter Wiederholung einordnen würde.
Ja, das ist genau richtig. Wir werden genau,
wenn wir uns mit Wiederholungen beschäftigen in dieser Veranstaltung,
so in Woche sechs und sieben,
werden wir auch über Rekursion reden.
Also eine alternative Möglichkeit,
um Wiederholungen zu formulieren
Da ist noch eine Frage. Ja. Sogar die Jahre,
in der Namensbürger Japan war nicht zum Beispiel,
kann ich den frei auswählen? Sie fragt,
ob man den Namen für eine Variable frei auswählen kann,
also zum Beispiel hier in der die variable Wand,
diesen Namen hier, ob ich den frei wählen kann.
Ja, mit kleinen Einschränkungen. Es gibt in jeder Programmiersprache reservierte Wörter,
die darf man nicht nehmen für solche variablen Namen.
Ansonsten gibt es nur die Konvention, die wir haben,
dass die mit einem kleinen Buchstaben anfangen sollten.
Gibt es sonst noch Fragen hier zu diesem Jahr
da oben
Bitte? Sonderzeit. Was mit Sonderzeichen ist? Okay,
also die Frage lautet, was ist mit Sonderzeichen? Sonderzeichen,
möglicherweise im Namen von Bezeichnern, ist üblicherweise nicht zugelassen.
Es gibt einfach einen Satz an zulässigen Zeichen innerhalb eines Namens.
Das sind ja hier Namen oder auch Bezeichner.
Es sind zugelassen Buchstaben, es sind zugelassen Ziffern.
Es ist auch zugelassen ein Unterstrich. Es ist zum Beispiel
nicht zugelassen, ein Bindestrich, ein Fragezeichen und so weiter.
Also es gibt da einfach Einschränkungen, die in jeder Programmiersprache
anders sind. In Java ist das klar festgelegt,
was dazugelassen ist und was nicht
Und das werden wir uns auch noch ein bisschen näher ansehen in den nächsten Veranstaltungen.
Sonst noch Fragen hier zu diesem, was wir bisher diskutiert wurde.
Da ist noch eine Frage. Allgemein. Allgemein ist das vielen
für unser Stärker. Die Frage lautet, ob New,
das New, zum Beispiel hier, dieses New,
das gemeinen wir ja ein bisschen aktivieren hier.
Ob das allgemein der Begriff ist, um neue Objekte zu erzeugen.
Ja, das ist in Java auf jeden Fall so.
Also in Java werden Exemplare von Klassen
mit New erzeugt
Ganz genau, ja. Weihnachtszuverbindung. Er fragt,
ob in Java Variablennamen mit einer Ziffer beginnen können.
Die Antwort ist nein, das ist nicht möglich.
Solche Detailfragen könnt ihr auch gerne in den Übungen stellen.
Das werdet ihr auch da natürlich dann bekommen, die Antworten.
Gibt es sonst noch jetzt vielleicht Fragen zu dem,
was ich hier so grundsätzlich erzählt habe?
Ja, da oben nochmal? Die Klaration von eduzialen Dingen zum Eindruckskörper.
Ja, die Frage war, ob es möglich ist,
in einer Zeile sowohl Deklaration als auch Initialisierung zusammenzufassen.
Hier ist ein Beispiel
Deklaration und Initialisierung, also In-E gleich 42, gibt es
in Java auch. Da ist noch eine Frage. Ja,
so dicke Assozialisierung ist in einer Zeitung. Er fragt,
warum bei einem Bulien diese Initialisierung und Deklaration nicht in einer Zeile geht.
Natürlich geht das auch in einer Zeile,
das ist nur in diesem Beispiel nicht so hingeschrieben.
So, jetzt noch ein paar Fragen vielleicht.
Ich will euch ermuntern. Also es ist wirklich,
es soll hier interaktiv passieren. Ich rede ja sowieso schon
zu viel zu viel. Wenn jetzt keine Fragen mehr sind,
dann würde ich sagen, können wir mal eben
fünf Minuten Pause machen
Ja. Das war das Zwischenfazit. So, jetzt gehen wir
mal ein bisschen konkreter rein in die Definition von Klassen.
Wir haben ja bisher nur gesehen, wie solche Klassen da
schon stehen. Wir werden jetzt mal uns angucken,
wie die tatsächlich strukturiert sind.
Das ist eine
sehr einfache Klassendefinition
Klar, Syrokonto, Private Insaldo, Public Void einzahlen.
Da stehen irgendwie so ein paar Sachen auf dieser Folie.
Das erste ist, jedes Java-Programm besteht aus Textdateien.
Das heißt, das ist eine Textdatei. Ich kann das vielleicht auch mal zeigen,
wenn wir uns jetzt mal hier dieses Projekt hier,
das noch mal eben ganz kurz, ich lade jetzt ein weiteres Projekt,
Girokonten.
Das ist tatsächlich jetzt das Projekt, mit dem wir arbeiten.
Und dieses Projekt steht ganz normal im Dateisystem.
Also hier jetzt Girokonten,
das ist ein Verzeichnis,
in dem
alle BlueJ-Dateien liegen
Da sieht man hier irgendwie so eine Package-Datei, die hält Informationen irgendwie,
wie viele Klassen da drin sind und so weiter.
Also ein bisschen auch Layout-Informationen. Aber das Entscheidende ist hier
, Girokonto.java. Da steht der eigentliche Java-Quelltext drin.
Und hier ist die übersetzte Klasse. Das ist,
werden wir uns auch nochmal später nochmal angucken,
aber letztendlich ist tatsächlich das hier eine Datei,
eine Textdatei, in der Java-Code drinsteht.
Und das ist genau das, was auch jetzt hier angezeigt
wird, wenn ich den Editor öffne. Das heißt,
das ist ganz wichtig, wenn ihr mit einem einer Programmiersprache umgehen,
lernen wollt, dann müsst ihr mit einem Editor umgehen können.
Ihr kommt fast nicht ohne einen Editor aus,
es gibt Ansätze, dass man irgendwie durch Klicken programmieren kann,
irgendwie sich Sachen visuell zusammenklicken kann oder ähnliches.
Aber eigentlich geht es nicht ohne den Text, den man da schreiben muss.
Also Programmiersprachen bestehen aus Text und auch so eine Klassendefinition,
also eine Klassendefinition definiert eine Klasse.
Das ist sozusagen die begriffliche Unterscheidung. Dieser Text hier,
den nennen wir die Klassendefinition und die muss mit einem Editor wahrarbeiten.
Und ein Editor ist etwas, was man tatsächlich auch beherrschen kann.
Also wenn ich zum Beispiel jetzt hier diese beiden Zeilen selektieren will,
dann kann ich das mit der Tastatur ganz schnell machen,
weil ich so ein paar Tastatursachen ganz gut beherrsche.
Wenn ich das jetzt versuchen würde,
das mit der Maus zu machen, dann fange ich jetzt an,
irgendwie erst hier mühsam die Maus irgendwie herzunehmen und dann ziehe ich hier so rüber.
Und das wusste ich natürlich auch. Aber wenn ich jetzt irgendwie anfange,
tatsächlich irgendwie hier, was weiß ich,
ich möchte ein Wort hier selektieren, da ausschneiden,
woanders einfügen, das solltet ihr lernen.
Also das ist tatsächlich nützlich. Es ist fast noch nützlicher,
wenn ihr sogar einen Schreibmaschinenkurs macht, um zehn Finger zu lernen,
damit ihr irgendwie beim Tippen nicht ständig auf die Tastatur gucken müsst,
sondern tatsächlich auf den Bildschirm gucken könnt.
Man wird viel schneller dadurch
Also programmieren wird flüssiger, dadurch, dass man schneller tippen kann.
Es ist erstaunlich, aber es ist tatsächlich so.
Und es ist eben halt gut, wenn man den Editor
beherrschen kann. Das gehört mit dazu. Gut,
das ist aber nur, wie gesagt, ein Aspekt hier.
Wir bearbeiten das also mit einem Editor. Java-Programme bestehen allgemein
aus Klassenbier. Ist natürlich jetzt ein bisschen großkotzig zu sagen,
dass das hier ein Java-Programm wäre.
Ja, das ist einfach nur eine Klasse.
Wir betrachten jetzt wirklich so einzelne Bausteine von Java-Programmen.
Das ist kein Java-Programm. Ein Java-Programm besteht aus Meer.
Wir gucken uns jetzt hier eine einzelne Klasse an,
aber dann ist es eben so, es sind alles Klassen bei einem Java-Programm.
Diese Klasse definiert genau eine Methode
Nämlich die Methode einzahlen. Diese Methode erhält einen Parameter,
also hier irgendwie Betrag vom Typ Int und hat keinen Rückgabewert.
Also das Schlüsselwort Void. Ein Brumpf der Methode wird ein Wert
einem Zustandsfeld zugewiesen, hier Saldo. Also hier passiert tatsächlich schon
relativ viel. Und dieses Feld muss auch erstmal deklariert sein.
Also tatsächlich haben wir hier ein Feld, das unterstrich Saldo heißt.
Und das können wir uns auch nochmal hier live ansehen.
Also das hier, das ist ein Feld.
Eigentlich ist das ja in der Klassendefinition, es ist nicht
das Feld, sondern werden wir jetzt ein Exemplar.
Also wenn wir diese Klasse jetzt übersetzen. Dann haben wir
eine ausführbare Klasse. Von dieser Klasse können wir ein Exemplar erzeugen.
Und das Exemplar, das hat dann ein Feld.
Und dann haben verschiedene Exemplare verschiedene Felder. Was wir hier haben,
ist ja eigentlich die Definition, dass alle Exemplare so ein Feld haben sollen.
Und deswegen wird das hier im Quelltext auch,
nennen wir es ein bisschen anders, dann nennen wir es Exemplar variables.
Also eine spezielle Form von Variablen. Ich habe eben schon
diese imperativen Variablen angesprochen, die wir uns auch noch näher ansehen werden.
Eine solche imperative Variablen ist hier tatsächlich dieses Feld.
Oder diese Exemplar-Variale, wie sie hier heißt
So, wenn ich also tatsächlich jetzt von dieser Klasse hier ein Exemplar erzeuge,
ich kann also hier ein Girokonto erzeugen und kann jetzt tatsächlich
mir das mal anzeigen lassen, hier, juhu,
der Zustand ist, irgendwie Saldo ist null.
Also es hat ein Feld vom Typ Int und ich kann jetzt hier aufrufen und einzahlen,
20, wupp, und dann sieht man hier tatsächlich dieser,
Saldo hat sich erhöht.
Und ich kann das nochmal aufrufen. Und dann haben wir
den Saldo wieder erhöht. Ihr seht, das ist ein
ziemlich langweiliges Konto, ich sehe den die Meldung, kommt sofort.
Das ist ein relativ langweiliges Konto, weil ich kann hier nur einzahlen.
Also ich glaube, es würde keiner mögen,
wenn es bei einer Bank angeboten würde
Üblicherweise würde man da auch noch auszahlen wollen.
Da ist eine Frage. Muss man in der Klassendimension die
erst mal geben, das Sagen, Initialisierung auch null.
Ah, sehr gute Frage. Er fragt,
ob man nicht in der Klassendefinition diesen Saldo irgendwie initialisieren muss.
Ja, eine sehr gute Frage. Tatsächlich komme ich da
noch drauf. Das wird gleich noch thematisiert werden.
Diese Exemplarvariabe hier ist korrekt initialisiert, aber das passiert implizit.
Das macht Java sozusagen. Das können wir gleich noch expliziter
machen. Da war noch eine andere Frage eben
Da oben ist eine Frage. Warum Unterstrich, Saldo?
Genau, ganz gute Frage. Warum nennen wir Exemplarvariable mit einem Unterstrich
? Das ist eine Konvention. Man hat allgemein immer,
wenn man Software entwickelt, in einem Team Regeln,
wie man Dinge benennt, sogenannte Programmier- oder Quelltextkonventionen.
Und wir haben eine Konvention für SE1,
dass wir die Exemplarvariablen immer mit einem Unterstrich anführend benennen.
Dann erkennt man sofort, was für eine Art von Variable es ist.
Das ist eine Regel, die wir hier haben.
Das ist kein Muss. Das gibt in anderen Projekten,
gibt andere Programmierrichtlinien. Das ist eine Regel,
die wir hier für SE1 haben und auch für
Okay, gut. Wir haben also hier erstmal jetzt so eine
ganz einfache Klasse mit einer Exemplarvariablen und wir haben eine Operation,
eine Methode einzahlen, die wir aufrufen können.
Dann so ein bisschen hier Prinzipien der Objektorientierung,
Verhalten eines Objektes ist durch seine angebotene Dienstleistung bestimmt,
also ein Zahlen ist durch das Public für Klienten aufrufbar.
Das Feld hingegen, also diese Exemplarvariable, der Saal, die ist private deklariert.
Das heißt, ich komme da nicht ran als Klient,
kann ich jetzt nicht einfach dem Saal da was zuweisen.
Wir wollen bei so einem Konto eher so den vernünftigen Umgang modellieren. Das heißt,
das, was man mit einem Konto normalerweise macht,
also ich zahle was ein, ich hole was ab,
dass ich nicht einfach hart irgendwie jetzt da einen Wert reinsetzen
kann in den Saldo als Klient.
Das ist die Grundidee bei der Objektorientierung, dass man eben halt Dinge verstecken kann.
Und hier ist tatsächlich diese Realisierung nach außen hin versteckt.
Wenn ich tatsächlich dann diesen Saldo ändern will,
dann muss ich eben halt die Methode benutzen.
Okay, jetzt ein bisschen Struktur, woraus besteht denn so eine Klassendefinition?
Erstmal ganz grob. Man hat üblicherweise einen Kopf der Klasse,
das ist hier klar. Girocontent, da drüber steht,
idealerweise ein Schnittstellenkommentar für die Klasse, der dann tatsächlich diese Klasse beschreibt.
Das haben wir jetzt hier in diesem Beispiel nicht gemacht.
Das werde ich auch jetzt hier erstmal nicht machen,
weil es erstmal tatsächlich um die programmierrelevanten Dinge geht,
die tatsächlich vom Compiler ausgewettet werden.
Wir werden da aber dann im Laufe des Semesters auch noch drauf eingehen.
Diese Kommentare, die man da schreibt,
tauchen dann auch in der Dokumentation auf, die von Blue Jay generiert werden.
Wenn ich jetzt hier sage, generiere mir mal die Dokumentation,
dann steht hier nicht sehr viel drin.
Dann gibt es irgendwie hier Einzahlen und sonst nicht viel.
Da gibt es auch keinen Kommentar für die Klasse
Das ist also noch nicht so richtig hilfreich.
Also üblicherweise würde man da einen Klassenkommentar erwarten. Gut,
dann gibt es den Rumpf der Klasse und das
ist einfach hier von der Öffnen bis zur schließenden Klammer.
Das ist der Rumpf der Klasse und der ist ja hier auch wunderbar hervorgehoben.
Also alles das, was grün ist, ist der Rumpf der Klasse.
Und in dem Rumpf der Klasse haben wir jetzt verschiedene Bestandteile
so einer Klassendefinition, nämlich die Deklaration einer Exemplarvariable und hier
die Deklaration einer Methode
Das ist eigentlich auch schon das,
was man wissen muss, wie eine Klassendefinition aufgebaut ist.
Klar, ist Klassenname, dann hier der Rumpf.
Und dann kann man da Felder definieren, Konstruktoren, Methoden.
Hier sieht man jetzt in diesem Beispiel, dass es keinen Konstruktor gibt.
Was ist denn überhaupt ein Konstruktor? Ein Konstruktor ist das,
was man aufrufen muss, um ein Exemplar zu erzeugen.
Das heißt, wenn ich jetzt hier dieses New aufrufe,
dann ist das ein Konstruktor.
Wenn ich das New aufrufe, ist das ein Konstruktor Aufruf.
Das heißt, ich rufe an dieser Stelle einen Konstruktor auf,
also es ist ein Konstruktor Aufruf,
und dann erzeuge ich hier ein neues Exemplar
So einen Konstruktor kann fehlen und in Java ist es tatsächlich so,
wenn kein Konstrukt da angegeben ist, dann wird ein sogenannter Standardkonstrukt da eingesetzt.
Das hat man jetzt hier auch gerade gesehen,
weil ich hier in dieser Klassenedition keinen habe,
ist in der Dokumentation trotzdem einer angegeben, nämlich hier,
Constructor, Summary, da steht ein parameterloser Konstruktor.
Also der Compiler generiert automatisch einen Konstruktor, wenn keiner angegeben ist.
Das ist eine Java-Regel, die man einfach kennen muss.
Wir können es natürlich aber auch tatsächlich hinschreiben,
wir können hier einen Konstruktor hinschreiben,
und das mache ich jetzt einfach mal,
ein Konstruktor heißt immer genau so, wie die Klasse,
also hier in diesem Fall Girokonto, Ja, so.
Und jetzt kann ich nämlich auch die Frage beantworten.
Schöner wäre natürlich, wenn ich im Konstruktor tatsächlich dafür sorge,
dass das frisch erzeugte Exemplar auch wirklich in einen definierten Anfangszustand kommt.
So, und dann würde ich natürlich jetzt zum Beispiel mir vorstellen,
dass ich jedes habe, Saldo ist gleich null.
Exemplarvariablen vom Typ Int werden automatisch auf null initialisiert.
Das ist eine Regel für Exemplarvariablen vom Typ Int.
Das passiert implizit, es ist netter, es explizit zu machen.
Gerade für Programmieranfänger ist es wahrscheinlich schlau,
auch solche Initialisierungen, die eigentlich redundant sind,
Es dokumentiert einfach klarer, was hier passiert.
Deswegen war die Frage genau richtig, so würde man sich
das wünschen, dass tatsächlich hier der Konstrukt da steht.
Denn wenn ich das jetzt hier übersetze, dann habe ich die gleiche Dokumentation.
Es gibt dann immer noch einen parameterlosen Konstrukt. Und jetzt
habe ich ihn tatsächlich explizit hingeschrieben. Ich könnte aber auch
etwas anderes machen. Ich könnte hier zum Beispiel jetzt sagen,
in Anfangssaldo und würde jetzt hier sagen, ja, Anfangssaldo. So,
das heißt, ich würde, wenn ich ein Exemplar vom Girokonto erzeuge,
müsste ich einen Anfangssaldo angeben, also das Geld,
was ich am Anfang, wenn ich das Konto eröffne,
schon einzahlen will.
Auch das kann ich übersetzen
Wenn ich jetzt hier ein Konto erzeuge,
dann muss ich plötzlich beim Konstruktoraufruf einen Parameter angeben.
Das heißt, hier muss ich jetzt zum Beispiel 100 angeben.
Und dann wird mir ein neues Exemplar erzeugt,
dass hoffentlich genau hier ein Saldo von 100 hat.
Das heißt also, in meiner Klasse habe ich hier tatsächlich
diesen Wert, der hier reingegeben wird vom Klienten,
dann wird der hier abgespeichert in der Exemplarvariable.
Da sieht man auch wieder genau,
wie so eine Imperative Zuweisung aussieht.
Warum ist eine Frage
Im Bereich, ja. Sie fragt,
ob es eine Möglichkeit gibt, bei solchen Parametern vermute ich,
die möglichen Eingabewerte zu beschränken, auf bestimmte Bereiche oder ähnliches.
Ja, prinzipiell gibt es die Möglichkeit,
über die Möglichkeit, Typen zu definieren, eigene Typen.
In der Hinsicht ist Java relativ schwach,
also wenn es int ist, dann ist es eben halt,
sind es alle Inst, die zugelassen sind.
Man kann höchstens einen Kommentar schreiben und sagen,
hier nur Werte von zwischen 1 und 100 angeben oder so.
Aber das kann man nicht sozusagen durch den Compiler erzwingen lassen.
Das geht hier nicht.
Also Standardkonstruktor, wenn keiner angegeben ist, kann fehlen,
aber wenn wir ihn hinschreiben,
ist das auch in Ordnung und dann kann ich ihn explizit angeben.
Und der heißt immer genauso wie die Klasse.
Gut. Wir haben jetzt dieses Beispiel mit diesem Parameter.
Jetzt nochmal die Frage der Objekterzeugung. Eben kam schon
die Frage, ist das New immer eine Objekterzeugung?
Ja. Also Exemplare werden über New erzeugt.
Hier haben wir so ein Beispiel aus dieser Klasse Zeichner,
wo hier sozusagen verschiedene Aufrufe stehen und dann neue Exemplare erzeugt werden.
Und das New ist ein Schlüsselwort. Das heißt,
die Frage, die eben kam, kann ich meine Variablen?
Meine lokale war ja aber auch New nennen, lautet eben nein.
Ich darf eben solche reservierten Wörter, solche Schlüsselwörter nicht für
die Namen von Variablen verwenden
Ansonsten bin ich aber relativ frei. Okay, ein Zusammenhang,
der ganz zentral ist, das wird immer wieder gern durcheinander geschmissen.
Die Leute, die in der Vorlese sitzen,
die kriegen das meistens mit, aber dann viele auch nicht,
die das, wir unterscheiden den Konstruktor vom Konstrukt der Aufruf.
Das, was hier steht in der Klassendefinition,
das hier, das ist ein Konstruktor.
Merkt euch vielleicht so als Eselsbrücke, das,
was da steht, das ist ein Initialisierer.
Das Ding heißt zwar Konstruktor, aber es ist missirreführend
zu glauben, dass damit ein Objekt konstruiert wird
Das Objekt wird konstruiert durch das New. Das New erzeugt ein neues Exemplar.
Bei einem New muss ich aber immer ein Konstrukte angeben.
Das ist also eng im Miteinander verbunden. Aber tatsächlich,
was da passiert ist an dieser Stelle,
wenn ich hier jetzt zum Beispiel dieses New Quadrat mir genau angucke,
dass diese Zeichenfolge hier New Quadrat ist eine Anweisung,
ein Ausdruck, der führt dazu, dass erstens,
das ist der Oma angedeutet,
ein neues Exemplar erzeugt mit dieser Klasse.
Und dann, das ist halt untrennbar,
ich muss ja beim New immer auch ein Konstrukt da angeben,
wird eben halt dann dieser Konstruktor anschließend auf dem Exemplar ausgefüllt
Das heißt, der Konstruktor initialisiert dann das Exemplar. Das sind die Initialisierungen,
die wir gerade gemacht haben, zum Beispiel auf diesen Anfangssaldo.
Also zwei Dinge, ja. Das eine ist,
das Objekt wird erzeugt und das ist für alle Konstruktoren gleich.
Also für die Konstruktoren einer Klasse. Und dann kann man
eben halt durch die Angabe eines konkreten Konstruktors sagen,
welche Initialisierung da jetzt drauf ausgeführt werden soll.
Also wir unterscheiden Konstrukte, Aufruf und Konstruktor. Dann haben wir
hier diese Idee des Methodenaufrufs, nochmal ein bisschen explizit auf der Folie.
Kennt ihr jetzt aus diesem Bezeichnerbeispiel, also Üblicherweise gibt man ein Objekt an,
an dem man etwas aufrufen will, dann einen Punkt und dann die Methode,
die man aufrufen will, eventuell gefolgt von Parametern.
Die gerufene Methode ist dann üblicherweise Teil der Schnittstelle und was
wir auch haben werden in dieser Übung in dieser Woche,
ist, dass ihr private Methoden schreibt,
die nur innerhalb der Klasse aufgerufen werden.
Und die werden dann tatsächlich ohne so eine Qualifizierung aufgerufen.
Also die eigenen Methoden der Klasse kann ich selber direkt aufrufen.
Okay, Methodenaufrufe werden auch Botschaften genannt,
das ist so ein Detail,
das kommt so ein bisschen aus der Smalltalk-Welt
eher so am Rande interessant
Gut, Punktnotation, das ist etwas,
was zur Objektorientierung quasi dazugehört, wie das Wasser zum Schwimmen.
Nicht alle Sprachen haben tatsächlich so eine Punktnotation. Objective Sea zum Beispiel auf den iPhones,
die machen das irgendwie syntaktisch ein bisschen anders,
aber im Allgemeinen, traditionell ist es so,
man hat immer so diese Idee, das Objekt.
Dann der Punkt und dann die Methode auf dem Objekt.
Damit ist immer klar, an dem Objekt möchte ich jetzt diese Methode aufrufen.
In Java ist das eben halt so konkretisiert,
dass das immer in runden Klammern steht,
auch wenn man keine Parameter angibt,
muss man immer die runden Klammern angeben bei einem Methodenaufruf.
Ihr könnt also immer erkennen,
ob es ein Methodenaufruf ist, in dem ihr tatsächlich
immer nach diesen runden Klammern sucht
Gut, in Java ist das hier eigentlich,
bei diesem Zeichnerbeispiel, das ist eine Referenz auf das Objekt,
aber Referenzen thematisieren wir erst in Woche 5.
So, jetzt noch mal ein bisschen genauer auf eine Struktur einer Methodendefinition.
Das haben wir jetzt ja auch schon gesehen.
Das ist so ein bisschen wie bei der Klasse auch.
Ich habe am Anfang so einen Kopf und der kann eben
halt so verschiedene Dinge enthalten.
Einen Zugriffsmodifikator, einen Ergebnistyp, einen Namen und einen Parameter.
Also zum Beispiel hier in diesem kleinen Beispiel,
da habe ich hier die Methode einzahlen.
Und diese Methode hat hier als Ergebnistyp Void.
Das heißt,
da kommt nichts raus
Also es kommt nichts an den Aufrufer zurück.
Dann steht hier der Zufallsmodifikator, Public heißt so viel
wie ein Klient, kann das Ding jetzt einfach aufrufen.
Das ist also nichts, was privat innerhalb dieser Methode benutzbar ist.
Und wir haben hier die Parameter, also in diesem Fall
ein Int, der als Betrag interpretiert werden soll.
Okay, und dann haben wir den Rumpf einer Methode,
da stehen dann die emperativen Anweisungen.
Auch nochmal hier wiederholt, Signatur einer Methode,
die steckt hier drin, also Name und die Typen der
Parameteranzahl und Reihenfolge
Okay, jetzt ganz wichtig, wir unterscheiden zwei Arten von Methoden,
nämlich die, die etwas verändern. In diesem Fall haben
wir hier genossene Methode schon drin, also ein Zahlen.
Für Klienten sichtbar, Methode liefert keinen Rückgabewert und die Methode
heiß einzahlen und man möchte damit etwas verändern an dem Objekt.
Wir können aber auch sondierende Methoden definieren. Das ist
eine Methode, die den Zustand eines Objektes nur abfragt.
Kann also tatsächlich sowas schreiben wie Gibsaldo,
kann ich hier auch mal live reinschreiben?
Ja, also wir schreiben hier mal eben eine weitere Methode,
Public Int gibt Saldo
So. Und dann machen wir hier nichts weiter,
als tatsächlich den Wert der Exemplarvarianen Saldo, die Belegung,
die aktuelle Belegung, da rauszugeben.
So, das kann ich jetzt übersetzen. Und dann kann ich
tatsächlich jetzt hier mir ein Girokonto anlegen, Anfang Saldo 100.
In Blue Jack kann ich mir das jetzt ja interaktiv angucken.
Das ist aber eine Spezialität von Blue Jay.
Ich kann aber auch jetzt über die Schnittstelle, hier,
Gib Saldo aufrufen und dann kommt tatsächlich hier dieser Wert zurück
Und damit man auch sieht, dass dieser Wehr tatsächlich zurückkommt,
ich kann tatsächlich jetzt auch hier in der Direkteingabe,
dass es etwas auch eine Besonderheit von Blue J. Giro kommt,
Punkt Gibsaldo aufrufen.
Also das einfach so,
als wenn ich jetzt in einer anderen Klasse wäre,
als Klient auftreten würde, und dann kommt hier tatsächlich auch 100 raus.
Ich kann das auch einer Variablen zuweisen.
Also ich kann euch jetzt hier in I deklarieren und sagen
, ist gleich Giro Cont 1.gibsaldo.
So, dann wird sozusagen diese Variable I
hier deklariert
Lokal an dieser Stelle und mit gleich initialisiert mit dem Saldo von
dem Girokonto. Das geht, es ist nichts passiert,
ich kann jetzt hier I den Wert von ihm hier
anzeigen lassen und siehe da, er hat den Wert 100.
Also tatsächlich kann ich so ein, wenn eine Methode,
die eine sondierende Methode, die ein Ergebnis liefert, in einem Ausdruck verwenden.
Ich kann auch sowas schreiben hier. Hier ist gleich 200
plus. Das, was da als Ergebnis kommt,
kann ich direkt in einem Ausdruck hier verwenden.
I ist bereits definiert, okay, hat er recht.
Also sage ich jetzt hier I, die Variable habe ich schon deklariert,
aber er soll einen neuen Wert bekommen, nämlich So,
und dann habe ich jetzt hier, wie hat den Wert 300?
200 plus den Saldo von dem Konto.
Das geht also auch. Und das ist ganz elementar,
dass man zum einen verändernde Methoden hat,
die den Zustand verändern und dann sortierende,
sondierende Operationen, womit man den Zustand abfragen kann.
Dieses Interaktive sich angucken eines Exemplares geht ja nur in Blue J. Okay,
dann haben wir jetzt noch fünf Minuten und jetzt machen wir
noch mal einen kleinen Test von Storesi.
Folgende Klasse habe ich hier gegeben. Seht euch
diese Klasse gut an
Versucht, sie zu verstehen, zu analysieren. Ihr wisst,
es gibt Felder, es gibt Konstruktoren, es gibt Methoden.
Und jetzt würde ich hier mit Storesi fragen,
schieben das mal so ein bisschen rüber.
Wie viele Zustandsfelder definiert die Klasse A?
Also sind es 0, 1, 2 oder 3 Zustandsfelder?
Wie viele Zustandsfelder hat diese Klasse A
Versucht das erstmal alleine, versucht nicht drüber zu reden,
sondern versucht erstmal jeder für sich irgendwie was rauszuhauen,
was ihr für richtig haltet.
Naja, da ist das schon irgendwie zurückhaltend,
hier mit der Stimmabgabe.
Aber es kommen immer noch Stimmen
rein hier
Gut, ich glaube, so bei 250 kann man dann
auch Schluss machen. Ich beende das mal eben ganz kurz.
260, 270, 280, ja gut,
ich muss es ein bisschen knapp halt mit der Zeit.
Okay, ich hoffe mal, ich kann jetzt einfach auf
die nächste Umfrage umschalten. Wie viele Methoden definiert die Klasse A?
0,1,2 oder 3. Wie viele Methoden sind hier definiert?
So, ich stoppe, ich starte wieder und ihr
könnt abstimmen
Mhm. Das sieht prima aus. Rege Beteiligung. Bei 250
werde ich wieder stoppen. Ja. Okay. Und die letzte Frage,
und die ist jetzt gemein, Wie viele Konstruktoren definiert die Klasse A?
Also dann mal los. Wie viele Konstruktoren? A,
0, B, ein C2, D,
3. Also da sollte alles beantwortbar sein mit dem,
was ich hier erzählt habe.
Ich vermute trotzdem, dass das nicht so ganz eindeutig ausfällt.
Schauen wir mal.
Ich bin gespannt
Das ist immer hier. So, super. 280 Stimmen,
92 Stimmen. Ich stoppe. So, jetzt gehen wir
nochmal zurück. Also wie viele Zustandsfelder definiert die Klasse A?
Da haben wir hier jetzt als Ergebnis bekommen.
Zwei. Zwei Zustandsfelder. Also 70 Prozent sind der Meinung,
es sind zwei Zustandsfelder. Das kann ich auch enthüllen.
Das ist natürlich auch die richtige Antwort. Ja,
weil hier zwei Exemplarvariablen stehen. Das sind die Zustandsfelder.
Okay. Dann wie viele Methoden definitiv Klasse A. Da seht
ihr schon, das ist schon nicht mehr ganz so eindeutig.
Da haben doch auch einige Leute gesagt, null,
dann gibt es einige, die meisten haben gesagt, ist das eine.
Dann gibt es Leute, die sagen, es sind 200,
einige sagen so, es sind drei.
Und was wir hier sehen, sind ja zwei Exemplar-Varianten,
zwei Konstrukturen und eine Methode.
Das heißt also, das hier ist die richtige Antwort.
Das heißt also auch hier, die richtige Antwort ist eins.
Da ist die Antwort nicht mehr ganz so klar,
aber das ist natürlich auch, ich habe das vermutet,
dass es in diese Richtung geht.
Das sieht so ähnlich aus, Konstrukturen und Methoden sehen so
irgendwie ähnlich aus. Und deswegen die Frage nach den Konstrukturen,
Ah, da sitzt aber auch so aus.
0-1 oder 2, sind durchaus beliebte Antworten gewesen.
Und da ist natürlich die richtige Antwort auch, es sind zwei.
Also tatsächlich zwei Konstruktoren hier an dieser Stelle. Okay,
das war so der Versuch, das mal so ein bisschen
anhand der Themen zu machen.
Ich hoffe, das hat ein bisschen was gebracht heute,
wenn keine Fragen mehr sind,
machen wir Schluss.