Ja, dann jetzt noch mal herzlich willkommen zur zweiten Vorlesung von SE1,
wo wir gerade bei Vorstellungen waren,
wo hier gerade die Jungs von Hanseatic Consulting sich vorgestellt haben.
Ich will auch mich selbst noch mal eben ganz kurz vorstellen,
nicht nur namentlich, sondern auch ein bisschen mehr erzählen,
damit ihr einfach wisst, wer der Typ ist,
der hier vorne so viel erzählt.
Ich habe selbst Informatik studiert in Bremen vor ziemlich langer Zeit,
habe dann mein Diploma so 93 gemacht,
habe dann ein halbes Jahr bei einem Startup in Bremen gearbeitet,
bin dann doch wieder an die Uni gegangen
Nach Ulm, habe da als wissenschaftlicher Mitarbeiter gearbeitet und
dann promoviert 1999 über das Design von objektnotierten Programmiersprachen.
Dann hat mir der DARD ein Jahr Forschungsaufenthalt in Australien finanziert.
Das war in Melbourne. Dabei habe ich unter anderem auch
im BlueJT mitgearbeitet. BlueJ ist in Australien entwickelt worden.
Und das war dann auch der Grund, warum ich das
dann hiermit nach Deutschland genommen habe und dann auch hier in Hamburg installiert habe.
Dann bin ich nach Hamburg gekommen 2001 und habe erst mal
zwei Jahre auf einer halben Stelle gearbeitet bei einem Unternehmen,
nämlich bei der heutigen C1 WPS,
die hieß damals noch ein bisschen anders, als Softwareentwickler, als Softwarearchitekt.
Und habe dann nach zwei Jahren mich dann doch auf eine volle Stelle an der Uni bewegt,
einfach weil ich da meinen Schwerpunkt gesehen habe an der Uni-Arbeit.
Hatte also zwei Jahre lang halb Halbstelle, das war interessant.
Also neue Stadt, zwei neue Jobs. War interessant.
Dann seit 1.6.2009 bin ich auf einer Dauerstelle. Das heißt also,
ich bleibe der Uni noch theoretisch beliebig lange erhalten.
Vielleicht noch auf rechts stehen kann. Und bin jetzt inzwischen
akademischer Rat
Für einen Beamter. Damit ihr es wisst. Das erklärt
einiges. Gut. Meine Forschungsinteressen sind im Bereich Objektorientierung relativ
klar fokussiert. Also erstmal Design, Objektorientierung, Programmiersprachen.
Da habe ich ziemlich viel zum Thema Vererbung selbst geforscht.
Hier in Hamburg bin ich ziemlich intensiv in Kontakt gekommen durch Projektarbeit mit agilen Entwicklungsmethoden.
Das Thema Softwarearchitektur interessiert mich eher in dem Sinne der Ausbildung.
Also wie kriegt man denn das Thema Studierenden vermittelt?
Und ich habe über die Jahre so einige neue Lehrkonzepte entwickelt
und teilweise veröffentlicht und sehr erfolgreich eingesetzt.
Ich habe unter anderem, wie gesagt, das Object-First-Buch übersetzt.
Der betreute Laborbetrieb ist nicht meine Idee, aber von uns,
von der Handvoll Leuten, die wir das entwickelt haben.
Die Teachlits habe ich vor ein paar Jahren entwickelt, ein Konzept,
um Softwareentwürfe in einer größeren Gruppe zur Diskussion zu stellen,
sehr organisiert und allgemein Komplexitätsstufen von Objektsystemen, einfach um,
ja, in aufsteigender Komplexität, die Komplexität von Softwaresystemen gut zu vermitteln.
Das soweit in aller Kürze zu mir gibt es dazu Fragen.
Hat jemand eine Frage, da ist eine Frage.
Was für eine Wertung für Er fragt, was sind agile Entwicklungsmethoden?
Entwicklungsmethoden sind Vorgehensmodelle, nach denen man Software entwickelt.
Und agile Vorgehensmodelle gibt es seit 15 Jahren ungefähr.
Und die haben die Welt der Softwareentwicklung ziemlich, sagen wir,
aufgerüttelt, haben vieles anders gemacht. Weg von,
wir haben ein klares Phasenmodell,
wo wir am Anfang eine Analyse machen,
dann einen Entwurf machen, dann eine Implementierung und am Ende
dann das Deployen und dann testen und dann irgendwann nur noch warten.
So einen Durchgang und dann ist das durch,
wie das bei klassischen Bauprojekten,
bei Häusern oder ähnlichem ist
Sondern in der Softwareentwicklung läuft das üblicherweise inzwischen anders.
Und das sind agile Entwicklungsmethoden, die zyklisch inkrementell vorgehen,
prototypisch arbeiten, sehr schnell Feedback einholen von den Kunden,
sehr stark auf Feedback setzen,
genau wie wir hier im Übungsbetrieb sehr stark auf Feedback setzen.
Gibt es sonst noch Fragen zu dem, was da steht?
Ja. Ja, nochmal viel zwei für uns,
das hört sich eben so an,
als ob sie nicht mehr stilbetiert sind, sondern so angedeutet.
Er fragt, ob ich auch noch SE2 lesen werde.
Ich weiß nicht, wo du das jetzt her hast.
Ich hatte eigentlich gedacht, ich hätte gerade gesagt,
ich bleibe der Uni noch eine Weile erhalten
Ja,
also ob ich das jetzt hier über den Livestream so verkünden will,
weiß ich nicht, aber also ich kann aber sagen,
dass ich einen Ruf habe an die HAW hier in Hamburg.
Und dass es Möglichkeiten gibt, dass ich zum ersten Dritten wechseln werde.
Und dann werde ich aber möglicherweise noch Teile von SE2 noch lesen.
Das ist aber noch nicht geklärt mit meinem möglicherweise zukünftigen Arbeitgeber.
Ich hoffe, das reicht erstmal. SE1 werde ich
noch in voller Blüte hier durchziehen. Also da könnt ihr
euch auf alles verlassen, was hier bisher gelaufen ist.
Sonst noch Fragen
Gut, prima. Sehr schön. Dann wollte ich an
das Student-Response-System erinnern. Ihr habt ja inzwischen auch wahrscheinlich euch
schon ausgerüstet mit Klickern. Nochmal zur Erinnerung, Wolf,
Postdorfer hat diese Software ja entwickelt im Rahmen seiner Bachelor-Arbeit.
Hat auch Informationen dazu ins Kommen sie gelegt. Das heißt,
ihr findet da alle möglichen Informationen. Unter anderem hat er auch geschrieben,
dass es, wenn ihr ein iOS-Gerät habt,
dass ihr dann eine App bzw. zwei Apps benutzen könnt,
nämlich iSturesi und iSturesi Pro.
Beide zeigen nicht nur die Fragen, sondern auch die Antworten
im Klartext, was ja die Web-Version nicht macht.
Da werden ja nur die Buttons mit den Buchstaben eingeblendet
Die Pro-Version erlaubt zusätzlich auch noch ein paar nette Dinge,
wie zum Beispiel das eure Antworten, die Fragen gespeichert werden,
sodass ja auch noch sozusagen eine Art History habt von dem,
was ihr gemacht habt.
Warum erzähle ich das mit der Pro-Version? Ich würde keine
Werbung machen für diese Pro-Version, aber es ist so,
Wolf musste, um diese Software zu entwickeln, eine Entwicklerlizenz kaufen,
beziehungsweise er muss jedes Jahr jetzt 80 Euro zahlen.
Und ja, wenn Leute von euch jetzt sagen,
Mensch, ich finde das irgendwie cool mit Storesi,
dann wäre es einfach eine nette Geste,
wenn ein paar von euch einfach auch die Pro-Version kaufen.
Für 89 Cent ist das, glaube ich,
nicht zu teuer. Und ihr unterstützt damit, dass Wolf
das auch zukünftig
noch weiterpflegen kann
Okay. Dann der Link für Personen ohne Barcode-Reader.
Also wenn ihr jetzt nochmal irgendwie mit einem Laptop oder sowas
hier jetzt den Link sehen wollt, HTTP,
Tiny Urail.com, UHHSE1. Okay,
und ihr könnt das natürlich auch auf euren Smartphones ablegen.
Dieser Link bleibt stabil durch das ganze Semester.
Okay, ja, wir haben doch Sturise hier.
Ich mache mal wieder eine Abstimmung, weil ich beim letzten Mal
in der letzten Woche hat das nicht geklappt mit den Klickern.
Ich habe es jetzt getestet, es müsste eigentlich jetzt klappen.
Ich hoffe, dass die Klicker jetzt dabei sind.
Wir machen mal wieder so die übliche Umfrage hier.
Vorlesung 2 heute hier,
Ich nehme an diese Achtung teil. So,
jetzt würde ich euch einfach bitten, einfach mal eben hier eure Stimme abzugeben,
sodass wir sehen, was so an Leuten hier ist.
Android, Smartphone, A oder iPhone oder meinetwegen auch iPad,
also iOS, B. Den Barcode kann ich nochmal zeigen,
ja, hier ist der.
Sofort gehen die Handys hoch, das sieht toll aus.
Das hätte ich
gern fotografiert jetzt
So, haben alle den Barcode gesehen?
Alle, was abfotografiert hier, sehr schön.
Reicht. Gut. Es sind mal wieder erstaunlich wenig Stimmen
hier. Da können wir alle zwei befreien.
Die falsche Frage. Welche Frage wird da eingeblendet gerade?
Programmiert. Ah, ich weiß schon,
woran es liegt
Es ist ganz banal. Ich muss ins Netz gehen.
So, und jetzt dürften hier ein paar mehr Stimmen kommen.
Ich mache mal Folgendes. Ich beende das mal ganz kurz
und mache das normal. Hoffentlich wird es jetzt besser klappen.
Ich bin so und gestartet. So. So. Jetzt ist es natürlich
so, dass die anderen Stimmen dann irgendwie weg sind.
Also das ist ja auch erstmal nur wieder jetzt hier,
um das Ganze zu testen.
Ihr seht, das ist ja keine besonders wichtige Frage.
Vermutlich sind das jetzt die 130 anderen Stimmen,
die hier im Raum sind. Gut. Eigentlich geht es,
wie gesagt, nur mal ums Testen der ganzen Geschichte hier.
Wir gucken uns das mal ganz kurz an.
Das dürft ihr ja verteilungsmäßig relativ ähnlich sein.
Ich halte das mal an. Wir gucken uns das mal
an, wie das aussieht. Ah ja. Ja,
ziemlich viele Clicker diesmal. Das ist gut,
weil letztes Jahr, letzte Woche
haben die Clicker
nicht funktioniert
Und ansonsten, ja, wahrscheinlich waren die anderen schneller jetzt.
Ich weiß es nicht genau. Egal. Gut. Damit
ihr aber jetzt auch mal seht,
wie man dieses Sturis ja auch anders einsetzen kann,
wie ich es auch im Semester jetzt einsetzen werde,
habe ich hier noch eine zweite Frage.
Und das ist eine ganz einfache Frage. Welcher der folgenden
Begriffe hat nichts oder nur sehr wenig mit objektorientierter Programmierung zu tun?
A, klasse, B-Methode, C, Klausel, D-Exemplar.
Einige von euch werden jetzt vermutlich ein bisschen schmunzeln über
diese Frage
Das ist tatsächlich eine echte Frage aus unserer Klausur.
Ja, lacht nur, lacht nur.
Ihr werdet auch dann noch vielleicht lachen, wenn ihr erfahrt,
dass es Leute gibt, die das nicht richtig beantworten.
Okay. Ja, das ist recht zäh,
das ist recht zäh. 200. Na gut,
also von den 500 Teilnehmern in dieser Veranstaltung sehe ich
bisher nicht
sehr viel
Das ist ein gemeint. Okay, ich halte es mal an.
Und jetzt gibt es eben halt genau diesen Effekt.
Ich kann erstmal die Verteilung zeigen. Ganz viele haben die
richtige Antwort gegeben. Ein paar Scherzkekse haben auch die falsche
gegeben. Ich kann jetzt auch aber,
und das ist das Schöne an Sturis,
ich kann jetzt die richtige Antwort auch erkennbar kennzeichnen.
Ich kann nämlich hier jetzt das einblenden. Und dann sieht man,
ah, ja, 90 Prozent haben die richtige Antwort gegeben.
Und ich kann jetzt neuerdings auch hier absolute Stimmen mir anzeigen lassen.
Das heißt, jetzt sieht man tatsächlich hier,
wie viele Stimmen das sind.
Toll, ne? Sagenhaft. Sturisi ist toll.
Und wir werden das dann am Ende dieser Veranstaltung
auch nochmal einsetzen
Ja. Erstmal jetzt weg damit. Gut, jetzt ist
auch genug Zeit voran. Worum geht es heute? Ich habe
schon so einen kleinen Einstieg gegeben letzte Woche in die Objektorientierung
und so ein bisschen auch zwei andere Paradigmen nochmal angedeutet,
die ihren anderen Veranstaltungen belegen könnt.
Wir konzentrieren uns jetzt auf die objektorientierte Programmierung.
Und was ich letzte Woche schon gesagt habe, ist,
dass dieser Zusammenhang hier, dieser Zusammenhang zentral ist,
nicht nur in der Objektorientierung, sondern eigentlich in jeder Art von Softwareentwicklung.
In jeder Art von Software hat man genau das,
dass es einen Dienstleister gibt, irgendetwas anbietet und ein Klient,
das in Anspruch nimmt. Der Klient kann sein, eine Person,
die vor einem Computer sitzt und diese Dienstleistung interaktiv benutzt.
Der Klient kann sein, ein Objekt, das ein anderes
Objekt aufruft und da Dienstleistungen in Anspruch nimmt. Das ist so elementar,
dass sie es vielleicht auch nochmal hier in Blue Jay zeigen werde,
weil das nämlich genau das ist,
was ihr auch schon in der ersten Woche in den Übungen gesehen habt,
wenn ihr mit Blue Jay schon gearbeitet habt.
Das ist ein ähnliches Projekt hier, nur eine Klasse ins Neue
dazugekommen, die werdet ihr diese Woche ein bisschen bearbeiten.
Wir gucken uns erstmal das übliche Spiel an, Kreis,
So, hier ist ein Exemplar dieser Klasse Kreis und ich
kann jetzt hier die Dienstleistung dieses Objektes interaktiv aufrufen.
Wir werden uns jetzt ansehen, dass tatsächlich das,
was wir hier interaktiv machen oder was ihr auch interaktiv gemacht habt,
dass man das auch hinschreiben kann, aufschreiben kann im Programmtext.
Also so ein Hauszeichnen zum Beispiel,
wenn ich jetzt hier mal zeige, was der Zeichner so tut,
ich kann bei dem Zeichner jetzt hier sagen,
zeichne mal was und dann passiert hier sowas.
Dann zeichnet er so ein Haus und dann bewegt sich die
Sonne so ein bisschen, das sieht ganz hübsch aus.
Das ist tatsächlich hier in dieser Klasse implementiert ist mehr oder
weniger so ähnlich wie das, was ihr gemacht habt.
Das heißt, hier werden irgendwelche Quadrate erzeugt und Dreiecke und
dann werden die Farben geändert, werden in der Größe verändert.
All das schauen wir uns gleich genauer an.
Gut. Was aber erst mal noch interessant ist, ist,
dass hier diese Dienstleistung, diese Methoden, die ein Objekt anbietet,
die bilden die Schnittstelle eines Objektes und werden von anderen Objekten den Klienten in Anspruch genommen.
Das kennt ihr schon, das habe ich jetzt schon gesagt. Das ist die Schnittstelle,
was aber immer auch ganz wichtig ist in der Objektorientierung,
ist, dass ein Objekt, das Dienstleistung anbietet,
selten diese Dienstleistung alle selbst erstellt,
sondern oft wieder selbst auf andere Dienstleister zurückgreift.
Das heißt, dieses Objekt hier, um seine Dienstleistung zu erbringen,
benutzt möglicherweise ein oder mehrere andere Objekte und wird dann plötzlich zum Klienten.
Und das ist, wie gesagt, durchgängig in der Softwareentwicklung fast überall so.
Okay, also ein Objekt kann sowohl Dienstleister als auch Klient sein.
Auch das sieht man hier in diesem Blue-Jay-Projekt ganz schön,
wenn ich hier ein Exemplar von Kreis mir erzeugt habe und hier gesagt habe,
mal ganz kurz, nochmal die Leinwand einblenden.
Wenn ich jetzt hier dieses Objekt sichtbar mache,
dann kommt da dieser Kreis, Und dieses Kreisobjekt, ja,
das benutzt die Leinwand und ich will gar nicht wissen,
wie dieses Kreisobjekt das macht.
Man sieht hier irgendwo, dass da eine Benutzbeziehung ist,
aber ich als Klient von Kreis habe einfach nur gesagt,
Kreis macht dich sichtbar, wie das erfolgt,
wollen wir meistens nicht wissen.
Und das ist auch ganz elementar, dass wir üblicherweise bei
einer Dienstleistung nicht alle Details wissen wollen, wie sie zustande gekommen ist.
Wenn ihr ein Produkt kauft, dann wollt ihr üblicherweise das
Produkt benutzen und nicht den ganzen Herstellungsprozess kennen und verstehen.
Manchmal will man das aus Nachhaltigkeitsgründen, aber im Allgemeinen ist es so,
auch wenn ihr eine Pizza bestellt, ihr wollt nicht wissen,
wie die zustande gekommen ist.
Ich wollte sie
wahrscheinlich dann nur essen
So, also das ist immer so eine Trennung zwischen der Dienstleistung,
die man als Klient in Anspruch nimmt und wie sie zustande kommt.
Und das wird gerne ein bisschen weggekapselt. Gut,
jetzt haben wir, letzte Woche habe ich schon gesagt,
Objektsysteme, Softwaresysteme bestehen aus vielen Objekten, die interagieren.
Die Objekte haben eine Schnittstelle, bieten Dienstleistungen an,
jetzt zoomen wir immer weiter rein,
um sozusagen so die Objekte dann uns ganz genau angucken zu können.
Und hier ist nochmal ein anderes Beispiel,
was wir letzte Woche schon so halb gesehen hatten.
Das war die Idee mit einem Girokonto,
ein Objekt einer Klasse in einer Bank,
die diese Objekt hält die Information über ein Konto eines Kunden.
Und hier ist eine Notation, die ihr noch kennenlernt, nämlich eine UML-Notation.
Das ist ein Objektdiagramm. Hier ist also ein Objekt angedeutet.
Es ist von der Klasse Girokonto. Es bietet Methoden an,
ist Auszahlen möglich. Also man kann beim Konto erstmal abfragen.
Hallo, ich würde gerne 300 Euro ab auszahlen mir lassen.
Und dann kriegt man ein bullshites Ergebnis zurück. Ja,
das geht. Und dann kann man hinterher dann aufrufen,
okay, dann zahle ich, möchte ich jetzt mal
300 Euro um mir auszahlen lassen.
Das ist das, was das Objekt an Verhalten anbietet,
an Dienstleistungen nach außen.
Das sind die Methoden
Und außerdem hat das Objekt einen Zustand. Das heißt,
es wird sowas geben wie ein Dispo,
es wird sowas geben wie den Saldo, also den aktuellen Kontostand.
Und der kann sich natürlich ändern. Das heißt,
je nach Zustand des Kontos ändert sich die Art und Weise,
wie das Objekt auf Anfragen reagiert. Wenn ich einmal frage,
kann ich mir 300 Euro auszahlen, ja,
dann lasse ich mir die auszahlen, dann rufe ich nochmal auf,
kann ich mir nochmal Draht Euro auszahlen lassen,
dann ist es vielleicht nicht mehr gedeckt und dann ist die Antwort eine andere.
Also das heißt, abhängig von dem Zustand ändert sich das Verhalten.
Das ist ganz zentral in der Objektorientierung und das ist dann,
wenn wir uns jetzt so ein Objekt nochmal so ein bisschen abstrakter vorstellen,
kann man sich das ungefähr so vorstellen wie in diesem Bild
So ein Objekt hat irgendwie einen internen Zustand.
Der ist gekapselt. Man sieht hier so,
die Methoden liegen so drumherum wie so ein Schutzwall.
Von außen kann man also eigentlich den Zustand nicht direkt manipulieren,
sondern nur über die Methoden etwas damit tun.
Also das ist auch hier in diesem Beispiel so,
wenn ich jetzt hier mir das Kreisexemplar mal genauer angucke,
mit dem Objektinspektor von Blue Jay, dann ist dieses Exemplar hier.
Ich habe hier zwar diese Felder, diese Zustandsfelder,
die kann ich mir angucken, aber ich kann die nicht manipulieren.
Ich kann jetzt nicht direkt da reingreifen und irgendwas verändern.
Wenn ich hier was verändern will,
dann muss ich das über die Schnittstelle tun.
Also hier sind Dinge und damit ändere ich den Zustand.
Genauso ist das hier auch
Der Zustand, das Verhalten ist definitiv
die Methoden und der Zustand ist in den Zustandsfeldern definiert.
Ganz einfaches Modell. Und wir nennen diese Zustandsfälle auch gerne kurz Felder,
weil in Java, einem englischen Original, die Dinger Fields heißen.
Das ist also erstmal relativ nah dran an dem,
was in Java passiert. Gut, und jetzt haben wir
genau diese Situation, irgendein Klient ruft eine Methode auf.
Jetzt haben wir tatsächlich mal sowas wie dynamische Ausführung,
also nicht so eine statische Sicht auf so ein Objekt.
Wie sieht es denn aus, sondern was kann denn jetzt
passieren, wenn da irgendjemand was aufruft?
Also hier Kontrollfluss, kommt, fließt sozusagen in das Objekt
Jetzt wird hier eine Methode aufrufen und Methode 1. Und diese
Methode besteht aus lauter Anweisungen. Und das ist auch genau das,
was man hier sehen kann. Wenn jetzt von dem Zeichner hier,
wenn ich an dem Zeichner die Methode Zeichner aufrufe,
dann sieht man, dass dann hier genau diese ganze,
dieser ganze Rumpf aufgerufen wird.
Man sieht hier, dass es die ganze Klasse Zeichner,
hier oben ist nur erstmal ein Kommentar, dann steht hier Klaas Zeichner,
dann kommt hier in gelb eine Methode, Zeichner heißt die.
Und in diesem Rumpf dieser Methode stehen lauter Anweisungen.
Und die werden sequenziell ausgeführt. Jetzt habt ihr eben
schon gesehen, wie das passiert. Das können wir uns
gleich nochmal angucken
So, und das ist hier genauso. Die werden also
sequenziell ausgeführt und am Ende wird zurückgesprungen zu demjenigen,
der das Ganze aufgerufen hat. Und da geht der Kontrollfluss weiter,
wird vielleicht die nächste Methode von einem anderen Objekt aufgerufen.
Das ist ganz wichtig, das ist da,
wo wir jetzt in den Bereich kommen, emperative Programmierung.
Bisher haben wir überwiegend objektorientierte Begriffe uns angesehen.
Und jetzt kommen wir dahin, dass wir uns ansehen müssen,
wie denn in diesen Methoden was drinstehen kann.
So, nur nochmal jetzt hier am Beispiel der Klasse Zeichner hier verdeutlicht.
Das ist nochmal ganz interessant. Hier dieses Exemplar der
Klasse Zeichner
Hat keine Exemplarvariable. Keine Attribute, keine Felder. Das heißt,
das sieht man auch hier in dem Quelltext, da stehen keine Exemplarvarianten.
Ich werde gleich noch erzählen, was Exemplarvariablen sind.
Kennen Sie immer noch, also ihr müsst es noch nicht unbedingt wissen.
Aber der Zeichner hat eben halt genau eine Methode und deswegen
hat das eine Exemplar, was wir hier erzeugt haben,
genau diese Methode zeichnen und die kann ich aufrufen.
Und genauso ist das auch hier. Also Verhalten in der
einzigen Methode definiert, keine Felder, keinen Zustand.
Das ist also sozusagen eine reine Tätigkeit, die diese Exemplare
dieser Klasse hier ausführen, ohne irgendwie einen Zustand selbst zu haben.
New Quadrat, bla bla bla, die Wand und so
weiter, sequenzielle Ausführung und zurück.
Was auch noch ganz wichtig ist, ist,
wenn ein Objekt ein anderes aufruft, dann wird eine Methode aufgerufen.
Und am Beispiel jetzt von unserem Bank-Szenario,
zum Beispiel der EC-Automat, fragt bei einem Girokonto,
das vorher irgendwie rausgesucht wurde, anhand der Kontonummer oder ähnliches,
fragt jetzt der EC-Automat dieses Objekt bei dem anderen Objekt,
bei dem Girokonto nach, kann jetzt der Klient,
der hier steht, 300 Euro auszahlen.
So, und was was man hier sieht, ist,
da ist eine Methode, die heißt,
ist Auszahlen möglich und die wird parametrisiert mit dem,
was angefragt wird.
Also hier steht tatsächlich ein Parameter. Und dieses Parametrisieren von Aufrufen
ist auch ganz zentral. Das habt ihr auch schon teilweise gemacht.
Ihr habt also zum Beispiel bei einem Kreisexemplar die Farbe geändert.
Da musstet ihr als Zeichenkette die Farben, den Farbennamen übergeben.
Ja, und hier ist es jetzt zum Beispiel so,
hier werden jetzt 300 Euro als aktueller Parameter übergeben.
Das ist ein aktueller Parameter. Das ist ganz wichtig,
dass ihr diese Begriffe relativ schnell verinnerlicht.
Aktueller Parameter und hier formaler Parameter
Aktueller Parameter ist eine der Heldentaten der deutschen Informatik.
Das ist die deutsche Übersetzung für das englische Actual Parameter.
Und ihr wisst, dass Actual nicht aktuell heißt.
Sondern Actual heißt tatsächlich. Das ist also der tatsächliche Parameter.
Also aktuelle Parameter hat sich eingebürgert, deswegen verwenden wir den Begriff auch.
Aktuelle Parameter sind die, die tatsächlichen Parameter,
die bei einem konkreten Aufruf übergeben werden.
Also ein konkreter Wert. Also hier zum Beispiel 300. Aber
dieses Girokonto, das kann ja auf alle möglichen Anfragen reagieren.
Einmal fragt einer, ob 300 ausgezahlt werden können,
anderes Konto wird gefragt
Ob 500 ausgezahlt werden können. Das wird sozusagen hier allgemeingültig angegeben,
indem hier ein formaler Parameter angegeben wird. Das heißt,
im Quelltext, das Girokonto steht dann in der Signatur dieser Methode,
ist auszahlen möglich, dass da als Parameter irgendeinen Betrag übergeben werden muss.
Das ist dann eine Variable. Da kann halt jederzeit irgendwas
gesetzt werden, je nachdem, welcher Client das aufruft.
So, dann kommt da irgendein Ergebnis zurück.
Und da ist es dann auch so,
dass da hier Bulien steht als Ergebnistyp.
Das heißt, das Ergebnis ist entweder wahr oder falsch.
Ein Bulscher wird ein Wahrheitswert
Sehr zentral in der Programmierung. So,
da kommt jetzt zum Beispiel True zurück,
das geht also und dann ruft der EC-Automat wirklich auszahlen aus und er übergibt als Parameter,
ja, jetzt möchte ich 300 Euro Ostzahlen lassen.
So, das sind die wichtigen Begriffe. Dann haben wir
noch die Signatur einer Methode, die haben wir auf dem
ersten Aufgabenblatt schon mal so reingebracht, in den Einleitungstext.
Einfach um euch zu zeigen, dass wir in dem Einleitungstext
durchaus auch so kleine Definitionen drin haben und wir dann testen,
ob ihr in der Lage seid,
so eine Definition zu lesen und zu verstehen.
Das heißt also, wenn man zum Beispiel hier sieht,
Bulien ist aus Zahlen möglich, Betrag B,
dann ist das erstmal der Kopf einer Methode in irgendeiner Klassendefinition
Und dann muss man dazu wissen, dass in Java
zu einer Signatur einer Methode gehört der Name der Methode,
Anzahl Reihenfolge und Typen der Parameter.
Aber zum Beispiel nicht der Name der Parameter.
Auch nicht der Ergebnistyp der Methode zählt nicht dazu.
Also verkürzt ist sozusagen von diesem Methodenkopf, dass hier die
Signatur ist Auszahlen möglich in Betrag. Also die Stelligkeit,
die Reihenfolge der Parameter, welche Typen haben die Parameter?
Zum Beispiel die Namen sind nicht Teil der Signatur. Das heißt,
die Signatur ist ein sehr technischer Begriff,
der sehr relevant ist für die Programmierung mit Java,
aber ihr müsst aufpassen,
dass ihr euch nicht sozusagen darauf beschränkt nach dem Motto,
der Name eines Das ist ja nicht wichtig.
Das ist nicht richtig. Wenn wir uns noch mal das Beispiel hier angucken.
Ich habe hier ein Exemplar der Klasse Dreieck. So,
und wenn ich jetzt hier an diesem Dreieck aufrufe, größer ändern,
dann seht ihr da, es sind zwei Inparameter zu übergeben.
Und da ist es schon wichtig zu wissen, dass der
eine neue Höhe heißt, in der anderen neue Breite.
Für so ein Dreieck wäre das ja irgendwie schon interessant,
dass man weiß, welcher Parameter ist was.
Die sind vom gleichen Typ. Das heißt,
die Signatur ist eigentlich größer ändern int-int.
Und man weiß jetzt nicht, welcher von beiden was bedeutet.
Also ist das schon auch relevant,
wie die Parameter heißen
Nur es gehört eben nicht zur Signatur. Das ist,
wie gesagt, erstmal noch ein Terminus Technikus, den ihr hier lernen solltet,
weil der wird noch eine Rolle spielen im weiteren Verlauf des Semesters.
Gut, was wir auch schon mehrfach jetzt bemerkt haben,
ist, dass Klassen, also diese Dinger hier in dem Objektdiagramm,
in dem Klassendiagramm von BlueJay, diese eckigen Dinger,
das sind die Klassen und von denen lassen sich Exemplare erzeugen oder mit deren Hilfe.
Das heißt, das hier sind quasi Schablonen,
mit denen man sich neue Objekte stanzen kann, grob gesagt.
Und wir bezeichnen die Objekte gerne auch als Exemplare.
Also wenn ich von einer Klasse ein Exemplar erzeuge,
ein Objekt erzeuge, dann ist das ein Exemplar der Klasse
Das ist ein Begriff, den wir gerne verwenden hier.
Es gibt viel Literatur im Deutschen,
die der nächsten Heldentat folgen, nämlich die deutschen Lehrbücher,
die das englische Instance, ein Instance of a Class,
übersetzt haben mit Instanz einer Klasse.
Wir finden Exemplar in der Klasse besser, deswegen verwenden wir Exemplar.
Instanz ist nicht falsch. Wir finden es nur einfach weniger
passend. In den meisten Lehrbüchern steht eben halt Instanz.
Auch in dem Blue Jay-Buch übrigens, ich wurde dazu gezwungen,
das so zu übersetzen.
Kannst du ein bisschen lauter sprechen,
ich verstehe es nicht
Er fragt, ob man nicht auch Objekt sagen kann und
ich sage ja, ja, ihr könnt auch Objekt sagen.
Exemplar und Objekt ist super. Instanz ist so lala und ja,
was euch sonst noch so einfällt,
aber Objekt und Exemplar ist erstmal gleichwertig,
aber zum Ende des Semesterns werden wir noch ein bisschen differenzieren.
Aber das kommt erst ganz zum Ende. Gut,
ganz wichtig auch, man kann von einer Klasse beliebig viele Exemplare erzeugen.
Das habt ihr ja sicherlich auch schon gesehen.
Ich kann also auch jetzt hier noch einen weiteren Kreis erzeugen,
der kann seinen eigenen Zustand haben.
Ganz wichtig, jedes Exemplar seinen eigenen Zustand,
aber prinzipiell,
welche Zustände
es annehmen kann
Das ist festgelegt durch die Klasse. Und das lässt sich
auch nicht mehr ändern. Also ein Exemplar, wenn es
einmal erzeugt ist, bleibt immer ein Exemplar seiner Klasse.
Gut. Jetzt haben wir eben schon gesagt,
oder ich habe eben schon gesagt, dass in so einer
Methode einer Klasse im Rumpf der Methode ja die sequenziellen Anweisungen stehen.
Und da kommen wir jetzt langsam auf das zu,
was viele auch programmieren im Kleinen nennen.
Also wie kann ich einen Algorithmus, Begriff wird noch erläutert,
also eine Lösungsbeschreibung umsetzen in ein lauffähiges Programm, aus Anweisungen besteht.
Dieser Begriff Anweisung ist auch relativ zentral.
Also es sind ganz viele Anweisungen im Rumpf einer Methode.
Und das ist natürlich auch ein Thema hier in SE1.
Also diese imperativen Grundlagen behandeln wir mit. Was ist
eine Anweisung und was ist eine Variable und so weiter?
Aber heutzutage ist es eben halt so, wenn man moderne Softwareentwicklung betrachtet,
dann ist meist Objekt und Tierung im Spiel und dann gehört eben bei im Kleinen auch dazu,
dass man Klassen hat und Exemplare dieser Klassen und dann Methoden hat,
die dann Anweisungen enthalten.
Und in der Objektorientierung mit Java ist es tatsächlich so,
es gibt keine Anweisungen außerhalb von Methoden
Es ist einfach so, alles, was an Anweisungen in
einem Java-Programm passiert, steht in irgendeiner Methode.
Oder in mehreren Methoden über das ganze System verteilt.
Und dann ist es wirklich so, die Ausführung erfolgt dann ein Objekt,
ruft eine andere Methode auf von einem anderen Objekt und dann wird da was ausgeführt,
dann wird ins nächste Objekt aufgerufen und so weiter.
Was ich schon mal gezeigt habe, so ein roter Faden,
der sich durch verschiedene Objekte und verschiedene Methodenrümpfe zieht.
Nur der Ausblick hier, das ist jetzt erstmal Programmieren im Kleinen,
das ist das Thema von SE1, Programmieren,
im Großen heißt dann komplexe Probleme, professionell im Team lösen,
eher sowas, was hier auch die Hanseatic Consulting Leute schon vorgestellt haben.
Da braucht man auch sowas wie eine,
möglicherweise eine Softwarearchitektur und erste Eindrücke davon geben wir euch in
Gut. Gucken wir uns jetzt mal so ein ganz banales Beispiel an.
Ein imperativer Algorithmus. Jetzt also Algorithmus auch noch sehr vereinfacht.
Eine Handlungsbeschreibung, eine abstrakte Beschreibung einer Lösung, mehr oder weniger.
Hier jetzt Vergleiche, zwei natürliche. Also es geht um Maximumermittlung.
Ich habe irgendwie zwei Zahlen, ich möchte das Maximum ermitteln.
Dazu vergleiche ich zwei natürliche Zahlen A und B.
Wenn A größer als B ist,
dann setze das Ergebnis Max gleich den Wert von A. Also
da ist so diese Idee von,
ich speichere etwas in einer Variablen ab.
Max ist eine Variable
Und ansonsten, wenn das nicht der Fall ist,
dann setze das Ergebnis Max gleich den Wert von B. Aha.
Also da sieht man jetzt so ein paar Dinge.
Ein Algorithmus besteht aus einer Folge von Aktionen. In der
Programmierung dann jetzt bei uns die Anweisung mehr oder weniger.
Jede Aktion bezieht sich auf Variablen oder die meisten Aktionen.
Hier auf jeden Fall A, B und Max.
Und in der imperativen Programmierung können solche Variablen ihre Belegungen verändern.
Das werden wir uns gleich nochmal ein bisschen genauer angucken.
Und auch im Laufe des Semesters. Und was auch noch
wichtig ist, jede Variable hat einen Typ
Das heißt, wenn wir auch in diesem Beispiel uns jetzt mal angucken,
wie das in der Klasse Zeichner ist,
hier haben wir jetzt diese Methode, die dieses Haus zeichnet,
da sieht man hier schon mal vier Variablen,
die hier deklariert werden.
Und dann werden diese Variablen hier benutzt, dann wird hier,
werden die irgendwie initialisiert und damit über diese Variablen irgendwas aufgerufen,
sichtbar machen und ähnliches.
Und was ganz wichtig ist, dass in so einer Variable,
dass so eine Variable in Sprachen wie Java,
da haben diese Variablen einen Typ.
Das sagt so viel wie in dieser Variablen,
zum Beispiel Wand, die ist vom Typ Quadrat.
Da kann ich also nur, vereinfacht gesagt, Quadrate drin abspeichern.
Ich kann da nicht jetzt plötzlich ein Dreieck reinlegen oder ein Kreis.
Und ich kann auch nur die Methoden aufrufen an einem Quadrat,
die für ein Quadrat definiert sind. Das ist ganz wichtig
, diese Typinformation. Das ist auch bei einfachen Variablen,
die wir uns gleich noch ansehen werden,
vom Typ Int zum Beispiel, die ganze Zahl,
da kann ich nur Operationen drauf ausführen, die zu einem Int passen.
Ich kann also da nicht plötzlich sagen,
ändere deine Farbe,
macht nicht
so viel Sinn
Okay. Okay. So, und jetzt sind wir sozusagen,
haben wir einmal die Kurve gekriegt hier von dem großen Objektsystem runter,
immer weiter in die Objekte jetzt in der imperativen Programmierung.
Und jetzt bei der Imperativen Programmierung ist es einfach so,
da werden Programme einfach als Folgen von Anweisungen formuliert.
Ausführungsreihenfolge ist üblicherweise textuelle Reihenfolge. Das ist in
den anderen Paradigmen funktionale Programmierung, logische Programmierung deutlich anders.
Was da textuell im Programmtext steht, muss nicht unbedingt bedeuten,
dass das auch textuell in der Reihenfolge ausgeführt wird.
Hat damit oft nichts zu tun. Hier ist es meistens so,
wenn da irgendwas in einer bestimmten Reihenfolge steht,
dann wird es auch in der Reihenfolge ausgeführt
Das ist tatsächlich in der imperativen Programmierung relativ einfach.
Dann gibt es höhere Programmkonstrukte, um Anweisungsfolgen zusammenzufassen oder Anweisungsreihenfolgen zu ändern.
Und Variablen können Wert haben. Also diese Variablen,
diese imperativen Variablen sind was sehr typisches für imperative Programmierung,
die sind ganz anders als die Variablen, die ihr aus der Mathematik kennt.
Falls ihr Mathematik kennen solltet. Das ist ganz wichtig.
Das ist ein häufiges Missverständnis und deswegen müssen wir da auch relativ genau Wert drauf legen.
Und was bei der imperativen Programmierung auch bei der Objektorientierung,
die da so ein bisschen drauf aufsetzt, gilt, ist,
das baut alles auf einem bestimmten Konzept auf von Rechnern,
nämlich ein Modell von Computern, die letztendlich aus einem großen Speicher bestehen,
in dem die Zustände im Speicher,
die Belegungen von Speicherzellen geändert werden.
Also es gibt so ein Zustandskonzept von Speicherzellen.
Das ist das Grundmodell für sehr viele der Programmierpaaradigmen,
insbesondere eben imperative Programmierung und Objektorientierung. So,
und dann gibt es verschiedene Kontrollstrukturen, die werden wir uns
auch in einer späteren Folge so etwas genauer ansehen.
Ganz einfach die Sequenz, einfach in der Reihenfolge,
die die Anweisung da stehen, werden sie ausgeführt.
Ganz einfach, dann gibt es die Fallunterscheidung,
trifft eine Bedingung zu, dann macht das eine,
sonst macht das andere
Oder wie oft soll etwas wiederholt werden, bis dann
irgendwie weitergearbeitet wird. So, ganz kurz nur angedeutet,
Sequenz ist eine Kontrollstruktur, eine Klausur gerne mal vergessen,
wenn wir danach fragen, was sind denn so Kontrollstrukturen,
dann kommen immer so die großen Antworten,
aber die Kleinen eben nicht.
Und das ist eben halt ganz einfach.
Die einfachste Kontrollstruktur ist die Sequenz. Ich kann tatsächlich durch
sequenzielles Hinschreiben erreichen, dass die Dinge nacheinander abgearbeitet werden.
Damit wird kontrolliert, wie die Dinge abgearbeitet werden.
Hier habe ich das mal aus dem Skript gegenüber so ein bisschen geändert,
habe also hier, es sind eigentlich Deklarationen von Variablen,
gar keine richtigen Anweisungen, aber hier wollte ich die Sequentialität auch zeigen.
Das heißt also, hier wird eine Variante I deklariert vom Typ Int
und bekommt einen Wert zugewiesen, wird initialisiert mit der 4.
Und dann die nächste Variable wird hier deklariert und bekommt die
Belegung von der vorher deklarierten Variablen ihm und darauf wird 5 drauf addiert.
Und dann eine weitere Variable bekommt dann die Summe dieser beiden Variablen Belegungen zugewiesen.
Das ist also eine Sequentialität drin. Das könnte man auch
noch deklarativ machen. Die müsste die Reihenfolge keine Rolle spielen,
wenn die Variablen unverändert bleiben. Aber in der imperativen Programmierung
ist es so, dass im Laufe eines Programm,
in der Programmausführung, sich die Belegungen von Variablen ändern können.
Ganz anders als in der Mathematik
Gut, Fallunterscheidung, gucken wir uns auch nochmal später ausführlicher an,
wenn eine Bedingung zutrifft, dann mach etwas,
sonst mach etwas anderes oder einfach nichts, geht auch.
Hier in den Java-Code so ein bisschen angedeutet,
werden wir uns noch genauer ansehen und Wiederholungen,
da gibt es ganz viele Möglichkeiten,
wie man die programmieren kann, die werden wir alle kennenlernen.
Das eine sind einfache Schleifen in Java,
aber auch mit Rekursion kann man Wiederholungen programmieren,
auch Rekursion werden wir kennenlernen hier in SE1. Aber das ist
erstmal nur so ein Ausblick,
das sind so die Grundbegriffe.
Letzter Grundbegriff hier,
imperative Variablen
Ich habe da jetzt schon mehrfach drüber gesprochen,
jetzt will ich es noch mal ein bisschen klarer sagen.
Eine Variable ist eine Abstraktion eines physischen Speicherplatzes. Das heißt,
ich habe gesagt, das Modell,
auf dem wir aufsetzen, ist,
wir haben einen großen Speicher und eine Variable belegt einen Teil dieses Speichers.
Da ist also Speicherplatz reserviert für die Belegung einer bestimmten Variable.
Und damit wir darauf zugreifen können, benennen wir solche Speicherplätze.
Das heißt, eine Variable wird immer einen Namen oder einen Bezeichner im englischen Identifier.
Darüber kann ich die Variable ansprechen. Und die hat so
den Charakter eines Behälters tatsächlich, also diese Speicherzelle,
die kann ich
verschieden belegen mit verschiedenen Inhalten
Und kann ich also tatsächlich auch ändern. Und sie hat
einen Typ. Das ist wieder ganz wichtig in so Sprachen
wie Java, dass Variablen einen Typ haben.
Es gibt auch Programmiersprachen, da haben Variablen erstmal keinen Typ.
Da kann ich an der Variablen alles zuweisen.
Erst weise ich ihr einen String zu, eine Zeichenkette.
In der nächsten Zeile weise ich dem ein Objekt zu und dann ein Int oder noch ein Bulli.
So ganz flexible Programmiersprachen. Da gibt es viele Leute,
die sagen, ja, das ist super,
da kann ich wirklich total flexibel programmieren,
wenn ich nicht eingeschränkt bin dadurch, dass eine Variable mir vorschreibt,
was denn da reingeschrieben werden kann.
Beim Lernen von Programmieren ist es unserer Meinung nach deutlich besser,
wenn die Sprache bestimmte Einschränkungen macht. Das hat auch den Vorteil,
dass viel klarer transportiert ist, wofür die Variable da ist.
Wenn eine Variable nicht nur einen Namen hat,
sondern auch einen Typ, zum Beispiel Int,
dann weiß man, da werden jetzt ganze Zahlen drin gespeichert.
Und dann kann es auch nicht aus Versehen passieren,
dass sich da eine Zeichenkette drin speichere.
Das schützt uns auch als Programmierer vor Fehlern.
In dem Sinne sind also getypte Programmiersprachen,
die fordern, dass Variablen einen deklarierten Typ haben.
Tatsächlich bei der Deklaration einer Variable muss sich ihren Typen mit
angeben und lege damit fest,
was überhaupt mit so einer Variablen
passieren darf
Das ist so ähnlich wie mit so einem Behälter,
wie so ein Gewürzglas. Da steht irgendwie Pfeffer drauf,
dann sollte ich tun, liest auch nur Pfeffer reintun.
Wenn das Ding nicht durchsichtig ist, ist es noch besser,
wenn ich irgendwie nur drauf gucken muss und sage,
aha, ist es vom Typ Pfeffer,
wenn da dann Muskartnuss drin ist,
ist das nicht so lecker.
Okay, das ist eben halt genauso bei den Variablen,
die wir sonst so in der Programmierung kennen.
Ganz wichtig noch für Variablen in der imperativen Programmierung.
Bevor ich so eine Variable verwenden kann, muss ich sie
erst deklarieren. Also auch hier in diesem Beispiel,
hier benutze ich Variablen wie Wand, Fenster und Dach.
Und ich muss die
erst hier oben deklarieren
Okay. Und da gebe ich den Typ an und einen Namen.
Also das ist ganz wichtig, die Deklaration an der Weihe
besteht aus einem Typ und einem Namen.
Das ist relativ elementar und das ändert sich auch kaum in anderen Programmiersprachen.
Das ist also relativ universell. In Java ist es so,
dass man erst den Typ angibt und dann den Namen,
gut, das ist halt ein bisschen gewöhnungsbedürftig.
Und dann ist es aber auch so, so eine Variable
darf ich erst dann benutzen, wenn sie vernünftig initialisiert ist.
Also ich kann ja, ich deklariere ja erstmal nur,
dass es einen Speicherplatz gibt, deren Namen hat auch einen Typ hat.
Da steht aber
noch nichts drin
Das heißt, ich kann das Ding auch nicht benutzen,
was da drinsteht, weil ich lese dann ja irgendwas aus,
was im Speicher zufällig drinsteht.
Das wollen wir ungern in der Programmierung,
sondern viele Sprachen und auch Java fordern,
dass bevor man was rausholt aus so einem Behälter, erstmal was reintut.
Organisiert das Ding initialisiert. Und das ist eben halt auch etwas,
was man tun kann. Man kann Variablen erstmal nur deklarieren,
wie in dem Beispiel,
was sie gerade in Blue Jay gesehen habt oder hier,
eine Variable Ivid deklariert vom Typ Int oder ein Variable B von Tybulien.
Aber hier werden diese Variablen auch noch initialisiert.
Also hier wird in einer Zeile eine intvariable deklariert und dann
auch gleich initialisiert
Kann man machen in Java. Und hier wird eine Variable deklariert.
Dazwischen darf diese Variable nicht ausgelesen werden. Ich darf da
nichts rauslesen. Erst wenn ich sie einmal initialisiert habe,
dann darf ich wirklich mit den Belegungen dieser Variablen arbeiten.
Gut, also das ist auch etwas, was man hier nochmal so zeigen kann.
Ich kann hier zum Beispiel zeigen, hier ist diese Variable Wand.
Die ist hier oben deklariert. Ich kenne ja jetzt mal
hier diese Deklarationen wegnehmen, auskommentieren. F8 in Java,
in BlueJay, F7 einkommentieren, auskommentieren, einkommentieren, oh toll.
Ganz schnell, ihr werdet das noch zu schätzen wissen,
dass man mit dem Editor auch umgehen kann bei der Programmierung, relativ wichtig.
Jetzt habe ich das, die Deklaration auskommentiert. Jetzt ist also,
hier wird jetzt eine Variable benutzt, die gar nicht deklariert ist.
Wenn ich das jetzt übersetze, dann meckert der Compiler.
Cannot find Simble variable Wand. Wunderbar. Ich kann also nicht
einen Fehler machen, dass ich jetzt irgendwie irgendwas damit mache,
weil der Compiler sagt, nee, also das kenne ich nicht.
Also kommentieren wir das wieder ein. Wenn ich jetzt aber zum Beispiel hier diese Initialisierung der Variablen hier,
diese Initialisierung, Wenn ich die jetzt mal auskompentiere,
dann versuche ich hier auf die variable Wand zuzugreifen,
also irgendwas mit der Variablen zu tun,
ohne ihr vorher was zugewiesen zu haben,
ohne dass sie initialisiert ist.
Ein guter Compiler kann sowas durchaus auch entdecken. Und das ist tatsächlich
auch so, variable Wand, might not have been initialized.
Wunderbar. Also ich kriege hier den Hinweis,
du willst da was machen mit einer Variable,
die hat noch gar keinen richtigen Wert.
Also auch das sehr hilfreich in der Programmierung,
dass man das hat, sich das eher als eine Hilfe,
denn als eine Einschränkung.
Ja, soweit gibt es noch erst mal jetzt Fragen dazu,
was ich jetzt hier gerade so gezeigt habe, zu diesen Variablen.
Sonst würde ich nämlich jetzt hier einfach mal eben so
ein kleines Zwischenfazit ziehen. Ich habe angefangen letzte Woche,
in dem ich gesagt habe, Softwaresysteme sind einfach,
kann man als eine Menge von interagierenden Objekten betrachtet werden,
modelliert und auch programmiert werden.
Da ist eine Frage, ja. Ja,
warum wurde der Entwickler, die Zertifikation,
das kann man auch mal in einer Zeit stellen.
Er fragt, warum wurde jetzt deklarieren und initialisieren voneinander getrennt?
Das kann man ja auch in einer Zeile schreiben. Klar,
geht auch, also ich könnte jetzt auch hier hinschreiben,
Quadrat,
Wand ist gleich
New Quadrat
Hätte man machen können. Hier wollten wir auch deutlich machen,
das ist ja sowas, das Projekt, das wir euch vorgeben,
dass es sowas konzeptuell gibt wie eine Deklaration und da
muss nicht initialisiert werden und dann wird später initialisiert.
Man kann das auch zusammen machen. Es ist immer ärgerlich,
wenn Dinge so zusammengematscht eingeführt werden. Wir finden es klarer,
wenn wir es deutlich trennen. Ihr könnt dann immer noch
lernen, dass man das in eine Zeile machen kann.
Sonst noch Fragen dieser Art? Das sieht nicht so aus,
dann kann ich noch mal ein bisschen mit der Zusammenfassung fortsetzen.
Objekte haben einen Zustand und bieten Dienstleistungen an.
Das ist ganz wichtig, das ist elementar eine Objektorientierung.
Der Zustand wird durch Zustandsfelder modelliert, Die Dienstleistungen werden
in Form von Methoden angeboten. Und die ganzen Methoden,
die man an einem Objekt aufrufen kann, die bilden quasi die Schnittstelle.
Klassen sind Schablonen zur Erzeugung von Exemplaren, innerhalb einer Methode
werden Anweisungen sequenziell ausgeführt, habt ihr auch gesehen.
Prinzipiell die erst beeinfachste Kontrollstruktur ist die Sequenz. Und Variablen,
deren Belegung während der Programmausführung geändert werden können,
sind zentral in der imperativen Programmierung.
Das ist erstmal der Stand bis hier,
wenn da keine Fragen sind, dann machen wir fünf Minuten Pause.
Gut. Okay. Was wir uns jetzt ansehen werden,
ist auch nochmal so ein bisschen elementares Zeug von Objektorientierung,
wir gehen jetzt, konkret auch ein bisschen stärker in den Quelltext hinein.
Das heißt, wir sehen uns jetzt an, wie Klassendefinitionen aufgebaut sind.
Okay, dazu nehmen wir hier mal die erste selbstgeschriebene Klassendefinition.
Sowas werdet ihr auch in den Übungen irgendwann mal machen.
Ihr werdet eigene Klassendefinitionen erstellen, von Grund auf ganz neu.
Momentan ist es ja noch so, wir geben euch Klassendefinitionen
vor, die ihr dann so ein bisschen bearbeitet.
Aber irgendwann werdet ihr auch sowas machen
wie das hier
Ja, also das ist eine selbstgeschriebene Klassendefinition.
Ich kann das natürlich auch in Blue Jay zeigen.
Was ich vielleicht auch nochmal eben zeigen könnte,
das ist mir gerade auch, das habe ich jetzt vergessen zu zeigen,
das will ich nochmal eben machen.
Also ich übersetze hier nochmal den Zeichner. Dann kann ich
nämlich in Blue Jay sehr einfach an einer bestimmten Stelle einen Haltepunkt setzen.
Ich klicke einfach hierhin und dann hält die Ausführung an dieser Stelle an.
Wenn ich jetzt tatsächlich den Quelltext schließe Und ein Exemplar des Zeichners
erzeuge. Und jetzt zeichne Aufrufe, dann passiert folgendes,
dann wird jetzt hier der Quelltext angezeigt und hier wird der
sogenannte Debugger angezeigt und der Debugger erlaubt mir jetzt,
dass ich schrittweise diese Anweisung im Rumpf der Methode ausführen kann.
Also ich kann tatsächlich jetzt hier, ja,
das mal ein bisschen kleiner machen.
Man sieht jetzt hier auch die lokalen Variablen.
Also wenn ich jetzt hier an diesem Punkt angehalten bin,
es wird immer Debugger, die Zeile gelb unterliegt,
die als nächste ausgeführt wird.
Das heißt, Noch ist kein Quadrat erzeugt.
Jetzt kann ich hier sagen, mach mal einen Schritt.
Also eine Anweisung wird ausgeführt. Dann sieht man jetzt tatsächlich hier,
ist diese lokale Variable Wand jetzt sichtbar für den Debugger.
Vom Typ Quadrat. Okay. Und dann kann ich jetzt hier aufrufen,
wann sichtbar machen, wenn ich das jetzt ausführe,
dann wird tatsächlich hier die Leinwand gezeigt.
Können wir hier mal so ein bisschen zur Seite schieben. So,
jetzt kann ich hier tatsächlich einen Schritt nach dem anderen machen,
dann wird hier die Farbe in Gelb geändert,
dann wird als nächstes das Ding vertikal bewegt.
Und dann wird die Größe nochmal geändert und zack,
ist das Ding auch ein bisschen größer
Also hier machen wir das Fenster nochmal ein bisschen kleiner, damit ihr es auch sehen könnt. Okay,
und dann wird hier ein neuer, lokale Variable jetzt initialisiert,
dadurch ist sie hier auch jetzt sichtbar für den Debugger,
dann wird sie sichtbar gemacht, sie wird horizontal bewegt,
sie wird vertikal bewegt, zack,
und dann ist sie da an der richtigen Stelle.
Dann wird das Dach sichtbar gemacht, Größe geändert,
bewegt, bewegt und dann wird hier der Kreis erzeugt,
das ist die Sonne, die Farbe wird geändert,
sie wird vertikal bewegt,
größer wird geändert und dann lässt man sie langsam
horizontal sich bewegen
Okay, also man kann hier genau sehen,
dass tatsächlich mit dem Debuggermann sehr schön diese sequenzielle Ausführung im
Rumpf einer Methode auch nachverfolgen kann.
Das ist also sehr angenehm. Wenn ich jetzt hier noch
einen weiteren Schritt mache, dann ist hier tatsächlich jetzt der Rumpf der Methode markiert.
Wenn ich jetzt noch einen weiteren Schritt mache, ist die Ausführung auch beendet.
Also das nochmal so am Rande. Ich wollte aber jetzt
eigentlich ein neues Projekt aufmachen, nämlich hier Girokonten.
Das ist das, was wir uns jetzt ansehen.
Wir haben also hier eine klasse Girokonto in einem BlueJ-Projekt.
Und diese Klasse sieht genauso aus, die, die hier
auf der Folie steht. Also hier, meine Folie,
ja, Klaas Girokonto, dann irgendwie, Klammer auf,
Private Int unter Strich Saldo und so weiter, das steht hier genauso.
So, was man jetzt hier sieht, ist, ein Java-Programm besteht aus Textdateien.
Das sieht man hier erstmal nicht, das ist Text,
aber das ist auch eine Textdatei dazu gibt, sieht man hier erstmal nicht.
Das können wir uns aber im Dateisystem angucken,
was ist überhaupt keine Hexenkunst, ja, dieses Verzeichnis,
in dem die Dateien liegen eines Blue Jay-Projektes,
also hier zum Beispiel für Girokonten,
da gibt es so verschiedene Dateien und eine Datei ist hier Girokonto.
Java. Würde ich vermuten, ja, das ist diese hier,
die Java-Datei, da ist jetzt die Extension nicht angezeigt.
Das ist irgendeine Spezialität von meinem tollen Windows, was ich
hier verwende. Aber ich kann das Ding jetzt öffnen,
ja, öffnen mit einem Editor,
nehmen also irgendeinen Editor wie Wordpad und hab hier tatsächlich diese Textdatei,
also diesen Klassentext mir in einem beliebigen Editor anzeigen lassen.
Das ist ganz elementar und auch das Ding,
was ihr hier seht, ist ein Editor.
Das ist ein Editor, der integriert ist,
in die Entwicklungsumgebung. Das gehört üblicherweise bei Softwareentwicklungswerkzeugen dazu,
dass man einen Editor hat,
mit dem
man Texte bearbeiten kann
Und was auch ganz wichtig ist, dass man mit solchen Texten
auch umgehen kann, auch mit solchen Editoren umgehen kann.
Also, am besten ist, ihr macht einen Schrattmaschinenkurs,
zehn Finger. Weil dann kommt ihr davon weg,
dass hier das Einfinger-Suchsystem anwendet, wenn ihr irgendwas eintippt.
Es ist total gut, wenn ihr flüssig seid am Schreiben von Texten mit der Tastatur.
Am besten, wie gesagt, einen Schreibtmaschinenkurs machen.
Und dann auch zusätzlich sowas beherrscht, wie bewege ich mich
denn in meinem Editor irgendwie hin und her über die Tastatur.
Es ist zum Beispiel so, dass ich hier,
wenn ich jetzt einen Doppelklick mache, dann wird hier dieses Wort selektiert.
Das ist gut zu wissen. Ich kann aber auch mich hier
so wortweise durchbewegen, indem ich einfach hier Steuerung, Pfeiltaste benutze.
Ich kann aber auch Steuerung, falsch hast du,
Shift, kann ich hier irgendwie nacheinander Worte selektieren.
Das sind alles so Sachen, die lernt ihr mit der Zeit
und dadurch werdet ihr sehr viel produktiver mit einem Editor.
Also ich kann euch nur empfehlen, lernt diese Tastaturgeschichten,
die sind auch relativ universell.
Also so Steuerungen, dass man damit irgendwie sich wortweise bewegt,
das ist in vielen Editoren so.
Also es ist nicht nur in dem Bluejay-Editor
so.
Textuelle Beschreibung einer Klasse, nennen wir die Klassendefinition.
Also wir unterscheiden die Klasse, die dann irgendwie auch Exemplare erzeugbar macht.
Und die Beschreibung der Klasse, nämlich die Klassendefinition.
Okay, was haben wir so für Merkmale? Na gut,
Java-Programm besteht aus Klassen. Jetzt ist es natürlich so,
in diesem Beispiel, hier in diesem sehr kleinen Beispiel,
besteht es nur aus einer einzigen Klasse.
Eigentlich ist das gar kein Java-Programm. Wie ein Java-Programm aussieht,
während wir im Laufe des Semesters noch kennenlernen.
Das ist hier nur eine einzelne Klasse. Selten kann man
mit einer einzelnen Klasse irgendwie viel anfangen. Es ist einzig,
Bluejay zu verdanken, dass wir sozusagen das Ding hier so
sehen und dass wir es dann auch manipulieren können,
dass wir uns also jetzt hier ein Exemplar dieser Klasse erzeugen
können und dann irgendwie einen Doppelklick machen können und so weiter.
Also das ist alles Blue Jay zu verdanken, dass man
interaktiv mit Objekten umgehen kann, da richtig was tun kann.
Das geht normalerweise in Java nicht so ohne weiteres.
Also die meisten Java-Programme sind deutlich größer als eine Klasse.
Okay, die Klasse definiert eine Methode. Das ist hier
diese Methode einzahlen. Die erhält einen Parameter vom Typ Int
und hat keinen Rückgabewert, nämlich hier steht Void.
Das heißt, so viel wie der Aufrufer,
der mich aufruft, der kriegt nicht unmittelbar nach dem Aufruf
irgendetwas geliefert
Wir werden uns gleich ansehen, wie das anders aussehen kann.
Im Rumpf der Methode wird der Wert eines Zustandsfeldes verändert.
Also hier wird irgendwo dieses Ex, diese Zustandsvariable hier,
dieses Zustandsfeld wird verändert. Und dieses Feld muss auch
deklariert sein, also es ist auch vom Typ Int.
Und wir nennen diese Felder, ich habe bisher gesagt,
innerhalb eines Objektes, diese Zellen, diese Zellen,
die irgendwelche Belegungen haben können, die nennen wir Felder oder Zustandsfelder.
Im Rahmen einer Klassendefinition, dann nennen wir die Dinger dann Exemplar variabel.
Weil das sind die Variablen, die jedes Exemplar der
Klasse hat
Hier, es wird ja sozusagen in der Klasse definiert,
welche Variablen haben alle Exemplare oder jedes Exemplar.
Da ist eine Frage, die freie Zeit.
Er fragt, ob diese Zustandsfelder, ob die private sein
müssen oder ob die auch public sein können.
Die Antwort bei uns ist, die sollten möglichst immer private sein.
Das ist eine Konvention in der Programmierung mit Java,
nicht nur von uns vertreten, sondern auch allgemein vertreten.
Sie müssen aber nicht
private sein
Java ermöglicht, dass die Dinge auch public sein können,
was das bedeutet, kommt später. Da gehen wir gleich
noch drauf ein, beziehungsweise eigentlich mehr oder weniger jetzt schon.
Das nämlich, und die kommt auf der nächsten Folie,
dass diese Methode hier public ist und dieses Feld private.
Das ist ganz wichtig, dieser elementare Zusammenhang.
Private ist etwas, was ein Klient nicht zu sehen bekommt.
Alles, was public ist, gehört zur Schnittstelle.
Und kein Klient kann das benutzen. Okay,
das ist nämlich genau das, was hier steht.
Einzahlen ist durch Public für Klienten aufrufbar
Aber es ist kein Zugriff direkt darauf, wie das umgesetzt ist.
Also der Rumpf ist sozusagen verborgen. Ich kann mir das also auch hier angucken,
wenn ich jetzt hier mir Girokonto angucke,
dann sehe ich hier nur die Dokumentation, dann sehe ich nur,
es gibt eine Methode einzahlen und wie die umgesetzt ist,
sehe ich nicht.
Also ein Klient sieht nur, ich kann einzahlen,
ich kann den Betrag übergeben, der da eingezahlt werden soll,
wie es intern gemacht wird, interessiert mich eigentlich nicht.
Da ist eine Frage, sind die Klassiker bewusst geschrieben und
die betriebene Kleidung.
Das ist also Kondition
Ja, die Frage, die er stellt,
ist hier der Name der Klasse ist groß geschrieben und
der Name der Methode ist klein geschrieben.
Ob das eine Konvention ist? Ja, das ist eine Konvention
. Das ist eine Java-weite-Konvention. Das ist keine Konvention,
die wir hier eingeführt haben,
sondern üblicherweise bei Java-Programmierung schreibt man Klassennamen groß und Methodennamen
klein.
Da hatte Arsenal Frage
Auch eine sehr gute Frage. Hier, er fragt,
warum hier dieser Unterstrich steht.
Warum haben wir die Exemplarvariable mit einem Unterstrich beginnend benannt?
Das ist eine Konvention, die wir hier in SE1 haben.
Die ist nicht unbedingt Java spezifisch, auch nicht Java in der Community weit verbreitet.
Wir machen es in SE1 und auch in SE2,
sodass wir sagen, Exemplarvariablen sollen mit einem Unterstrich benannt werden.
Das hat den Vorteil, dass man an allen Stellen,
an denen so ein variabler Name auftaucht, weiß,
dass da jetzt tatsächlich eine Exemplarvariable verändert wird und nicht etwa
eine lokale Variable
Da ist eine Frage. Weitere Methode bedeutet,
dann könnte man die Methoden auch machen.
Ah, also eine interessante Frage. Er fragt,
wenn ich jetzt bei der Methode hier das Public durch ein Private
ersetzen würde, könnte ich dann diese Methode noch aufrufen?
Total coole Frage, weil wir es einfach ausprobieren.
Wofür haben wir denn hier eine Live-IDE? Also ich kann es jetzt,
Moment, ich kann hier jetzt das Einzahn aufrufen, sieht man ja.
Es ist Public, deswegen kann ich es aufrufen.
Jetzt mache ich hier mal Folgendes,
ich mache das Ding jetzt mal private
Private, übersetzen, geht. Ich erzocke mir ein Exemplar,
schwuppdiwupp und siehe da, keine zugreifbaren Methoden. Das heißt,
Private ist das, was für Klienten nicht sichtbar ist.
Das heißt, diese Methode ist jetzt für Klienten nicht aufrufbar.
Üblicherweise ist das nicht das, was wir tun.
Es gibt durchaus Methoden, die wollen wir privat haben,
weil die sozusagen nur Teil der Implementation sind.
Wenn ich eine große Methode zerkliedere in kleinere Methoden,
dann ist das hilfreich, dass ich diese ausgelagerten Methoden privat mache,
sondern nicht an die Schnittstelle der Klasse kommen.
Das kann ich zeigen an einem anderen Beispiel
Wo wir gerade dabei sind, passt ganz gut.
Hier ist eine andere Musterlösung für dieses Zeichnerprojekt.
Und in dieser Klasse Zeichner ist es so,
hier gibt es eine Methode, zeichne Häuser, Ergebnistyp,
Worte, also die liefert erstmal sozusagen kein Ergebnis zurück.
Ist Public. Ist also von außen aufrufbar.
Eine weitere Methode ist hier Zeichnerhaus. Also hier werden
mehrere Häuser gezeichnet. Und hier wird also Zeichenhaus aufgerufen.
Gut, und hier zeichnehaus ist auch noch Public.
Aber dann ist es so, dass da drunter dann Methoden kommen,
wie Zeichen eine Sonne oder zeichnet Dach.
Und die sind private
Wenn ich mir jetzt die Schnittstelle anzeigen lasse, dieser Klasse,
dann sieht man hier, hier sind nur die Methoden,
zeichne Häuser und Zeichnerhaus zu sehen.
Und auch nur die sind für einen Klienten aufrufbar.
Aber es sind hier deutlich mehr Methoden drin. Zeichne Wand
, die sind aber alle private. Das ist eine extrem
nützliche Möglichkeit, Dinge vor einem Klienten erstmal zu verstecken.
Weil das ist sozusagen die interne Angelegenheit, wie man das aufteilt.
Interessiert den Klienten mal wieder nicht. Das, was man
dem Klienten anbieten will, das sollte public sein.
Okay. Und was eben halt auch jetzt hier ist,
diese Exemplarvariable
Maldo oder Unterstrichsalter, wie wir sie immer nennen, ist privat.
Das heißt, ich kann auch nicht als Klient direkt darauf zugreifen.
Ich kann also jetzt nicht als Klient einfach sagen,
oh, ich will den Saldo ändern,
ich schreibe da mal was rein in die Variable.
Nein, die Idee ist,
die Methoden definieren den organisierten Zugang zu dem Zustand.
Und wenn ich den Saldo ändern will, dann bitte über die Methode einzahlen.
Oder wenn es ein nützliches Konto werden soll, sollte man
auch auszahlen können. Ihr würdet wahrscheinlich ein Konto nicht mögen,
wo ihr nur einzahlen könnt und nie was wieder runterkriegt.
Die Schnittstelle ist also hier relativ klein.
Kurze Auswertung, was wir bisher gesickt haben.
Grobstruktur einer Klassendepetion. Es gibt den Kopf einer Klasse.
Das ist das, was hier so oberhalb mit inklusive Class-Girokonto steht.
Üblicherweise steht da oben ein Schnittstellenkommentar. Das ist ein Kommentar,
der für Klienten der Klasse beschreibt, wofür die Klasse gut ist.
Das ist jetzt hier in diesem Beispiel,
in meinem Girokonto hier, nicht der Fall.
Ich habe da jetzt einfach gar keinen Klassenkommentar geschrieben.
Finden wir im Allgemeinen nicht so gut,
wenn da kein Klassenkommentar steht. Es ist nur einfach,
um jetzt erstmal hier zu zeigen,
was ist denn das Nackte,
was wirklich zur Ausführung
dienlich ist
Für einen menschlichen Klienten, der lesen will, wofür ist
das Ding denn da? Der sollte einen Klassenkommentar da stehen.
Und das zählen wir zum Kopf einer Klasse. Alles,
was dann zwischen diesen beiden Klammern stellt,
also wenn ich hier zum Beispiel diese Klammer so mit dem Cursor da hinsetze,
wird ja die schließende Klammer dazu markiert in Blue Jay,
sehr hilfreich.
Auch wenn ich mich jetzt hier hinstelle,
wird die schließende Klammer der Methode markiert.
Da weiß ich immer gleich, welche Klammer gehört dazu.
Üblicherweise rückt man die auch so ein, dass die zueinander passen,
damit man es besser lesen kann.
Das ist jetzt hier der Rumpf der Klasse.
In dem Rumpf der Klasse,
was steht da drin
Naja, da stehen Exemplarvariablen und Methoden drin.
Da kommt noch ein bisschen mehr dazu. Also hier,
das ist mal so die allgemeine, also vereinfachte Syntax.
Man schreibt Klaas, dann einen Klassennamen für die Klasse,
dann öffnen die schließende Klammer und dann stehen da Felder, Konstrukturen, Methoden.
Aha, Konstrukturen. Was ist denn jetzt ein Konstruktor?
Wie man ja sieht, kann der ja fehlen.
Man muss anscheinend keinen Konstruktor angeben, denn die Klasse war ja übersetzbar.
Mein klassisches Girokonto hier ist ja so, wie sie hier ist,
übersetzbar. Obwohl da kein Konstruktor drinsteht. Interessant ist,
Wenn ich jetzt mir die Dokumentation anzeigen lasse, dann steht da ein Konstruktor.
Das ist ein Automatismus in Java, dass der Compiler automatisch
einen Konstruktor generiert, wenn keiner angegeben wird. Das heißt,
wenn ihr nicht explizit einen Konstruktor hinschreibt, sagt der Compiler mal,
also wahrscheinlich will er ja wohl schon Exemplare erzeugen können.
Dafür braucht man so ein Konstruktor. Kommen wir gleich
noch genauer drauf. Der wird also automatisch generiert.
Ihr könnt aber auch explizit einen Konstruktor hinschreiben.
Das ist ganz nützlich, weil ein Konstruktor ist dazu da,
etwas zu initialisieren,
nämlich den Zustand eines Exemplares
So, wir haben jetzt schon gesehen, ich habe vorhin gesagt,
Variablen, das ist eine Exemplarvariable, auch eine Variable.
Wie sollte eigentlich initialisiert werden? Habt ihr ja vorher schon gehört,
sollten immer initialisiert werden, bevor sie benutzt werden.
Deswegen könnten wir jetzt einfach mal sagen, hier,
ich schreibe mal einen Konstruktor, Public Girokonto,
Konstruktoren heißen immer genau wie die Klasse in Java.
So, schreibe ich hier mal einen Konstruktor und sage,
unterstrich Saldo, es soll anfangs den Wert Null haben.
Das ist das, was vorher hier implizit passiert ist
Weil, Exemplarvariablen immer auf einen Standardwert initialisiert werden.
Für jeden Typ gibt es einen Standardwert, für Int zum Beispiel Null. Okay,
aber ich habe das jetzt hier explizit gemacht, das heißt,
mein Konstruktor sagt jetzt, hier wird das Saldo Offnung sitzen.
Spannender wird jetzt so ein Konstrukt. Das ist jetzt praktisch
das Gleiche wie das, was der Compiler mir generiert hat.
Als ich es nicht hingeschrieben habe, hat er mir das sozusagen da reingeneriert.
Was jetzt so ein Konstrukt ein bisschen spannender macht,
ich kann jetzt einen Parameter übergeben.
Ich kann also definieren, dass wenn ich den Konstrukter aufrufe,
ich einen Parameter übergeben muss,
zum Beispiel
den Anfangssaldo
Also in Anfangssalo. Und dann ist es ganz schön,
wenn ich dann hier sage, naja, das soll tatsächlich festlegen,
welchen Saldo hat das Konto, wenn man es erzeugt.
Kann ich übersetzen. Kann mir hier ein Exemplar erzeugen.
Und jetzt wird bei meinem Konstruktoraufruf,
also bei meiner Exemplarerzeugung, wird hier ein Parameter abgefragt.
Jetzt gebe ich hier an 100 Euro.
Das wird von Anfang an schon 100 Euro.
Ich habe irgendwie mein Konto eröffnet mit 100 Euro gleich eingezahlt.
Dann hat dieses Exemplar tatsächlich den Zustand,
das ist Schon 100 als Anfangszustand hat. Das heißt,
ein Konstruktor ist dafür da, ein neu erzeugtes Objekt zu initialisieren.
Und man kann eben Initialisierungsparameter übergeben. Das ist dann ein Konstruktorparameter
. Okay, das ist hier mit dem expliziten Konstruktor.
Also tatsächlich haben wir den hier mal reingeschrieben.
Ich habe es jetzt live gezeigt mit einem Konstruktorparameter,
also noch ein bisschen komfortabler.
Kann explizit angewinnen, heißt immer wie die Klasse.
Okay, jetzt haben wir schon gesehen,
diese Dinge mit der Objekterzeugung
Objekte müssen zur Laufzeit durch einen expliziten Ausdruck erzeugt werden.
Dazu wird ein eigenes Schlüsselwort in Java New verwendet.
Ein Schlüsselwort ist etwas, was in der Programmiersprache festgelegt ist.
Und zwar so, dass man nicht zum Beispiel Variablen mit
diesem Namen benennen kann. Also das Schlüsselwort Klaas zum Beispiel
dürft ihr nicht verwenden für eine lokale Variable.
Da meckert der Compiler einfach. Da sagt er,
das ist ein reserviertes Wort, das kannst du dich ja nicht verwenden.
Und New ist ein weiteres solches reserviertes Wort.
Und mit New erzeuge ich halt Exemplare von Klassen
Ja, das ist tatsächlich hier Objekterzeugung. Und wir nennen das
jetzt im folgenden Exemplarerzeugung. Das ist tatsächlich im Skript noch
ein bisschen anders. Ich habe gestern die Keynote von Apple
mir kurz reingeguckt und da wurde dann gesagt, ja,
wir haben jetzt ein neues iPad.
Es ist viel leichter und es ist viel schmaler an seinem Rand.
Und wir nennen es iPad Air. So,
und ich stimme mich jetzt hier auch in und sage,
wir nennen es Exemplarerzeugung. Schön, ich habe gerade,
aber die Idee kam nicht von mir,
sondern von Kollegen von mir, der sagte,
warum nennen wir die Dinger denn Konstrukt
Aktoraufrufe, da kommen die Studierenden immer durcheinander mit dem Konstruktor,
der ja nur initialisiert und dem Konstrukte aufruft,
der das Objekt erzeugt, genau,
wir nennen es jetzt ab sofort zur besseren Klarheit, Exemplarerzeugung.
Also hier mal am Beispiel Exemplarerzeugung und Konstruktor, sehr enger Zusammenhang.
Wenn ich ein Exemplar erzeuge in Java mit Judan,
wird zuerst ein neues Objekt der Klasse erzeugt.
Also hier dieser Ausdruck hier, der ein neues Quadrat erzeugt,
erzeugt im ersten Schritt ein neues Exemplar.
Und auf diesem Exemplar wird im zweiten Schritt der Konstrukte
ausgeführt,
es geht nicht ohne
Man muss bei New immer einen Konstruktor angeben und der wird dann auch ausgeführt.
Das heißt, so garantiert die Sprache Ja war,
dass immer eine Initialisierung der Exemplarvariablen vorgenommen wird.
Also hier der zweite Schritt. Und jetzt kommen hier die
Initialisierung. Merkt euch als alternativen Namen für einen Konstruktor,
Initialisierer, ein Konstruktor ist ein Initialisierer. Weil missverständlich,
Konstruktor klingt so, als wenn da ein Objekt konstruiert wird.
Wenn der Konstrukte ausgeführt wird, wenn der Rumpf des Konstruktes
ausgeführt wird, ist das Objekt schon da.
Es wird sozusagen nur noch
das Objekt initialisiert
Ganz wichtig, also ein Konstruktor konstruiert nichts, ein Konstruktor
initialisiert eigentlich. Okay, dann haben wir schon gesehen,
dass es so Methoden gibt, die man aufrufen kann.
Jeder Methodenaufruf richtet sich immer an ein bestimmtes Objekt, den Adressaten des Aufrufes.
Wir haben das hier gesehen in diesem Zeichnerbeispiel, Wand,
Wand ist eine Referenz auf ein Objekt.
Und über diese Referenz wird jetzt dem Objekt,
das dahinter hängt, gesagt, beweg dich mal vertikal um 80.
Diese gerufene Methode ist dann üblicherweise Teil der Schnittstelle.
Ein Klient kann ja nur das sehen,
was Teil der Schnittstelle ist
Das Public ist. Oder es wird eine Methode des aktuellen Objektes
aufgerufen, wie zum Beispiel sowas hier, zeichne Dach.
Das war das, was ich hier vorhin gezeigt hatte in diesem anderen Zeichnerbeispiel.
Hier werden dann tatsächlich, also hier oben, hier wird aufgerufen,
innerhalb der Methode Zeichenhäuser wird aufgerufen, zeichne Haus.
Da ist dann ganz klar, es ist eine Methode der eigenen Klasse.
Da muss ich nicht noch das Empfängerobjekt mit angeben.
Es ist implizit sozusagen das aktuelle Objekt, an dem
diese Methode aufgerufen wird. Genau. Und diese Hilfsmethoden,
die nur innerhalb einer Klasse verwendet werden,
die werden private deklariert
Okay, das einfach nochmal jetzt so, wenn ihr über Objektorntierung
was lest, dann immer Punktnotation, ein ganz wichtiger Begriff.
Die Methoden eines Objektes werden in vielen Objektnischen Sprachen der Punktnotation aufrufen.
Nicht in allen, O-O-Sprachen. Zum Beispiel Objective Sea wird momentan immer wichtiger,
weil die ganze iOS ist in Objective Sea geschrieben oder jedenfalls große Teile.
Die haben eine andere Syntax, die verwenden nicht einen Punkt,
sondern diese eckigen Klammern. Aber in den meisten klassischen O-O-Sprachen
ist es so, dass es mit einem Punkt passiert.
Es hat Smalltalk, glaube ich, mal so eingeführt.
Also das aufzurufende Objekt, dann der Punkt,
welchem Objektpunkt wird jetzt welche Methode aufgerufen und dann welche Parameter werden noch übergeben.
In Java sieht das eben so aus, relativ nah dran
an dieser Punktnotation. Nur in Java werden die Parameter,
die aktuellen Parameter, die tatsächlichen Parameter, die konkreten Werte,
die da übergeben werden, die werden in runden Klammern angegeben.
Und wenn eine Methode gar keine Parameter bekommt,
muss man die runden Klammern trotzdem angeben.
Wir müssen also bei jedem Methodenaufruf in Java runde Klammern verwenden.
Das ist schon alles, was ihr da so wissen müsst.
Dann haben wir jetzt die Methodendefinition in Java
Die wollen wir uns auch noch mal ein bisschen genauer angucken.
Haben eine ähnliche Struktur wie eine Klasse, es gibt also einen Kopf und einen Rumpf.
Und beim Kopf ist es wieder so, der Kommentar,
den zählen wir eigentlich auch zum Kopf dazu.
Also wenn eine Methode vernünftig kommentiert ist,
also wenn für einen Klienten beschrieben ist,
was die Methode denn in dem Klienten gegenüber leistet,
das sollte in diesem Schnittstellenkommentar hier stehen,
dann gehört das zum Kopf der Methode.
Und dann sieht man hier relativ viel Zeug.
Ein Zugriffsmodifikator habt ihr schon gesehen, Public oder Private.
Ein Ergebnistyp kann Void sein,
das wird nichts zurückgeliefert oder es kann auch einen anderen Typ
haben,
werden wir
gleich mal sehen
Name der Methode, dann die Runden klammern und dazwischen die formalen Parameter.
Und dann stehen hier im Rumpf die imperativen Anweisungen innerhalb der Methode.
Und hier ist jetzt nochmal, um das nochmal deutlich zu machen,
das hier legt die Signatur fest. Also der Name und die Typen,
die Reihenfolge und die Anzahl der Parameter,
das ist alles in der Signatur definiert,
aber zum Beispiel den Namen der Parameter stecken nicht mit in der Signatur.
Und der Ergebnis-Typ ist auch nicht Teil der Signatur.
Okay. Zum Schluss jetzt noch zwei zentrale Begriffe,
nämlich verändernde Methoden sind sondierende Methoden. Verändernde Methoden sind genau die,
die etwas an dem Zustand des Objektes, das ich da gerade manipuliere, ändern. Das heißt,
ich habe jetzt hier dieses Beispiel mit dem Konto,
ich habe hier den Objektinspektor, ich kann jetzt hier aufrufen,
ach so, kann ich jetzt nicht aufrufen,
habe ich heldenhaft ja wieder private gemacht,
muss ich mal eben wieder public machen.
Also übersetzen. Ja, gut, jetzt habe ich hier
wieder meinen Exemplar, Anfang Saldo 100, Zustand hier.
Und jetzt kann ich hier als Klient, interaktiv aufrufen,
zahl da mal 50 ein, dann erhöht sich der Saldo auf 150.
So, das heißt, ich ändere den Zustand des Objektes über einen Methodenaufruf.
Aber die Methode, mit der ich den Zustand ändere,
die nennen wir auch verändernde Methode, ziemlich kreativer Name von uns.
Und was man hier wieder sieht für Klienten sichtbar,
also Public, liefert keinen Rückgabewert, einzahlen, kleingeschrieben,
Parautannahme und so weiter.
Spannender ist jetzt, dass es auch solche Methoden gibt,
mit denen man den Zustand nur sondiert
Was wir hier in Blue Jay machen können,
kann man ja üblicherweise in der Java-Programmierung nicht so ohne weiteres.
Also sich den Zustand eines Objektes ansehen.
Wenn ich den Zustand aber irgendwie rauskriegen will,
also wie ist denn der aktuelle Saldo dieses Girokontos?
Dann definiere ich einfach eine sondierende Methode. Ich schreibe also
jetzt hier einfach dazu, Public Int gibt Saldo.
Und dann wird hier einfach unterstrich Saldo zurückgeliefert.
Return hat sowas wie diese Methode. Hier hat ein Ergebnistyp
, liefert also ein Ergebnis einen Wert zurück
Die heißt Gibsaldo und hier wird jetzt definiert,
dieser Ausdruck hier legt fest, was als Ergebnis geliefert wird.
Kann ich übersetzen? Kann mir wieder ein Exemplar erzeugen.
Habe hier wieder die 100 Anfangssaldo, kann mir wieder anzeigen lassen,
wie der Zustand ist dieses Objektes und kann aber mir auch jetzt interaktiv,
und das geht halt in jedem Java-Programm, dann nicht nur in Bluedray,
dass ich da so reingucken kann wie hier,
sondern ich kann einfach aufrufen,
Gibsaldo.
Und dann kommt ja tatsächlich die 100 zurück und diese 100
kann ich jetzt in einem Ausdruck weiterverwenden.
Ich kann also tatsächlich auch hier jetzt eine Variable,
das ist übrigens die Direkteingabe in Blue Jay,
die ist ganz schick
Ich kann da so Dinge hinschreiben wie 50. Da sagt er mir,
50 ist ein Literal, hat den Typ int.
Kann aber auch sagen, intti ist gleich null.
Dann habe ich eine Variable, hier so ganz lokal deklariert.
Und dann kann ich fragen, wie ist denn der Wert
von IVs, die Belegung von ihm?
Dann sagt er, da ist null drin.
Jetzt kann ich aber auch schreiben, I ist gleich,
Giro-Cont. Ich kann mich also genau auf dieses Exemplar,
was ich hier gerade in der Mache habe, beziehen,
Giro-Cont 1,
gib Saldo
Dann kommt dieser Wert, gib Saldo, kommt zurück,
das ist also ein Ausdruck hier,
der einen Wert liefert und der wird dann gleich der Variablen I zugewiesen.
Kann ich also jetzt hier direkt ausführen und dann sagt er,
I hat den Wert 100. Könnte also tatsächlich diesen Wert jetzt
direkt weiter benutzen in einer Anweisung.
Das sind die sondierenden Operationen. Mit denen der Zustand
sondiert werden kann und man liefert ein Ergebnis und dieses Ergebnis
kann in einem Ausdruck weiterverwendet werden.
Das ist ziemlich zentral. Okay. Gut,
das war jetzt erstmal das, was ich heute erzählen wollte
Gibt es noch Fragen,
sonst würde ich gleich mal eine Frage stellen in Storesi.
Erstmal noch Fragen jetzt hier. Bleibt noch mal
ein bisschen ruhig. Bleibt noch mal ein bisschen ruhig.
Das ist ja kein Grund, unruhig zu werden.
Wir haben jetzt hier eine Klasse. Da ist noch eine
Frage. Vielleicht noch mal eben eine Frage, ja.
Das muss ich jetzt jetzt gerade einführen. Ich habe die
Frage nicht verstanden. Ich habe die Frage nicht verstanden.
Okay, ich glaube, den Kasten, meinst du?
Ja, hier. Ach,
dieser Kasten hier
Das ist die Direkteingabe. Das ist Ansicht hier, Direkteingabe.
Im englischen Original ist es den Codepad, das ist die Direkteingabe,
da kann man so kleine Ausdrücke direkt mal ausprobieren.
Das werde ich auch in der Frise noch benutzen,
werdet ihr auch in den Übungen noch benutzen.
Direkteingabe. Okay, bitte, guckt euch diese Klassendefinition an.
Ihr habt heute von mir jetzt ein bisschen was gelernt.
Welche Begriffe es da so gibt. Jetzt ist hier eine
ziemlich ungewöhnliche Klassendefinition und ich werde jetzt einfach in Storesi
ein paar Fragen dazu stellen. Meine erste Frage ist,
ich werde das hier mal so ein bisschen zur Seite schieben,
damit ihr das auch lesen könnt.
Also hier, ich brauche dann
den Button noch
So, wie viele Zustandsfelder definiert die Klasse A?
Wie viele Zustandsfelder definiert die Klasse A? Also ihr müsst euch überlegen,
was habe ich euch erzählt, wie sehen Zustandsfelder aus?
Wie kann man die erkennen? Woran sieht man, dass die Zustandsfelder sind?
Und ihr könnt jetzt hier einfach mal eure Meinung dazu abgeben.
Hat diese Klasse A A null Zustandsfelder B, ein Zustandsfeld,
C, zwei Zustandsfelder oder D, drei Zustandsfälle.
Bitte? Den Barcode nochmal all, ja gut,
das kann ich versuchen
So, also, ich stelle gleich noch mehr Fragen
dazu und dann gucken wir uns die Ergebnisse hinterher an.
Ihr werdet wahrscheinlich überrascht sein. Okay, jetzt haben wir
hier schon 200 Stimmen, das reicht mir erstmal.
Es scheint irgendwie noch nicht so richtig zu funktionieren mit allen Teilnehmern.
Ich weiß nicht genau, was da schief geht.
So, ich halte das mal an. Bevor wir uns das angucken,
nächste Frage, wie viele Methoden definiert die Klasse A?
Einfach mal eure Meinung abgeben, wie viele Methoden definiert
die Klasse A
Klar. A0, B1, C2 oder D3.
Ich denke so bei 200 machen wir dann wieder Schluss,
dass es nicht zu lange dauert. Ich hatte so
den Eindruck, dass ich 200 Stimmen hier meistens zusammenbekomme.
Jetzt klackern noch so ein paar Stimmen rein.
Es wird knapp, es wird knapp.
Stimmt einfach ab,
es ist ja anonym
Klickt irgendwas. Okay, also wir sind nah dran an der 200.
Dritte Frage. Wie viele Konstruktoren definiert die Klasse A?
Wie viele Konstruktoren definiert die Klasse A?
Auch hier jetzt Abstimmung gestartet. Und dann gucken wir uns
das gleich mal an,
wieso eure Ergebnisse waren
Na? Es wird nicht viel mehr als 170, na gut,
ich halte es mal an. Okay, jetzt gehen wir
mal zurück. Wie viele Zustandsfelder, wir gucken mal,
was ihr so gemeint habt, falsch, der hier.
Also da haben doch die meisten gesagt, es sind 3.
Es sind zwei Zustandsfelder. Das war nicht schwierig,
weil die Zustandsfelder haben wir ja immer gerne mit Unterstrichen markiert.
Und ich habe ja hier netterweise diese Konvention eingehalten.
Deswegen war das relativ leicht zu erkennen.
Das ist auch die richtige Antwort. Okay,
nicht ganz so einfach ist es möglicherweise bei der Frage nach,
wie viele Methoden sind denn das?
Ihr seht, da ist das schon deutlich anders verteilt.
Es überrascht mich jetzt gar nicht. Das war im letzten Jahr genauso.
Also es gibt, die Mehrheit ist der Meinung, es ist genau eine.
Es gibt aber auch durchaus Leute, die meinen,
es sind drei oder zwei oder es gibt sogar welche,
die meinen, es sind gar keine Methoden drin.
Die richtige Antwort ist, Es ist eine. So,
das heißt also, ihr habt jetzt diesen Effekt gemerkt,
ich habe was erzählt. Alles, was ich erzählt habe,
hat ausgereicht, um das beantworten zu können.
Aber ihr habt möglicherweise entweder nicht genügend aufgepasst oder,
ja, es kann tausend Gründe haben.
Jetzt habt ihr teilweise ein Fehlverständnis. Das haben wir jetzt
schon mal rausgekriegt. Es ist nämlich hier genau eine Methode,
die beiden anderen Dinger sind Konstruktoren.
Weil Konstruktoren heißen immer so wie die Klasse,
wenn eine Methode so heißt wie die Klasse, ist es keine Methode.
Das ist ein Konstruktor. Das heißt also auch hier,
Bei der nächsten Frage, zwei Konstruktoren, das haben immerhin die meisten gesagt.
Und die richtige Antwort ist, es sind zwei Konstruktoren.
Zwei Konstruktoren, eine Methode. Alles klar. Gut.
Das ist die Zusammenfassung für heute. Wenn keine Fragen mehr
sind, dann machen wir Schluss.
Vielen Dank