4, 3, 2, 1, Mainz.
Dieser Hörsaal gehört jetzt die nächsten 45 Minuten hier.
Und nicht ihnen, wenn sie sich unterhalten wollen,
benutzen Sie bitte moderne Kommunikationsmedien. Das heißt, machen Sie
das lautlos. Schönen guten Tag. Für die,
die sich nicht erinnern, mein Name ist Guido Gritzern.
Ich werde noch ungefähr acht bis zehn Mal dieses Semester hier
vorne stehen und ihnen versuchen, was über die Grundlagen,
objektorientierter Programmierung zu erzählen.
Heute Wer von Ihnen hat die Feuerzangenbohle gesehen?
Ach, das ist ja erfreulich viele. Jetzt stellen wir
uns mal ganz doof, was ist ein Dampfmaschinen?
Also was ist, wir fangen bei der objektorientierten Programmierung,
vielmehr bei der objektorientierten Modellierung, fangen wir jetzt mal ganz vorne an.
Sie sehen da so ein paar Gegenstände bzw. Symbole,
die auf Gegenstände hinweisen sollen und mindestens einen von diesen Gegenständen
werden sie in den nächsten sechs Semestern,
werden sie in allen Facetten
Werden sie den kennenlernen. Und das ist hier dieser blaue Gegenstand.
Jetzt versuche ich noch mal eine Maus zu finden,
da ist sie. Dieser blaue Gegenstand, dieses Symbol für
einen Ordner. Und sie ahnen heute noch nicht,
was sie alles nicht wissen über Ordner. Das werden wir,
dieses unbekannte Unwissen über Ordner werden wir in bekanntes Wissen,
werde ich versuchen, ihnen ein bekanntes Wissen umzuwandeln.
Wie kann man so einen Gegenstand des Alltags,
also den benutzen wir so als Ausgangspunkt,
für so einige Überlegungen zur objektorientierten Modellierung und Programmierung.
Und den gucken wir uns jetzt mal ein bisschen genauer an,
diesen Ort. Für alles, was ich so die nächsten
paar Minuten hier sage, vergessen Sie vieles von dem,
was Sie über Programmierung bis jetzt gehört haben.
Diejenigen, die noch nichts gehört haben, für die ist das Leben im Moment einfacher.
So, wir schauen uns dieses Ordnersymbol mal an. Und ich hoffe,
vor Ihrem geistigen Auge, also ist jetzt irgend so ein Ordner,
wo Sie meinetwegen ihre ihre Schulunterlagen drin verwalten, irgendwas von der Kante.
So, ich schätze mal, die meisten von ihnen werden so
ein Gerät ja auch schon mal in den, in den Händen gehalten haben.
So, das erste, was ich jetzt mal festhalten will,
ich hoffe, es kriegt jetzt niemand, so,
ich wollte Informatik studieren und nicht Germanistik.
Was tut er hier? Was will er von mir? So,
der Ordner als solches, dieses Wort ist erst mal ein Substantiv für,
in der Grundschule haben sie, glaube ich, kennengelernt, den Begriff Dingwort.
Also so der Ordner. Das ist ein Dingwort. Und wenn wir uns versuchen,
in der objektorientierten Modellierung über Konzepte im Klaren zu werden,
dann sind diese Konzepte Gegenstände, sind also zunächst mal Dinge,
die wir auf den Begriff zu bringen haben.
Und dafür verwendet man dann in der deutschen Sprache eben Substantive.
So, den Ordner. Jetzt könnte ich einen Test mit Ihnen machen und sagen,
schreiben Sie mal in den Zettel raus, Namen drauf,
schreiben Sie alles auf, was Ihnen zu ordnen einfällt.
Dann kriege ich hier von den 500 Leuten,
die hier sitzen, kriege ich wahrscheinlich so 250 verschiedene Antworten,
was Sie jeweils,
also so an traumatischen Erlebnissen mit Ort dann gehabt oder
nicht gehabt haben
Vor allem, wenn er weg ist, wenn man den sucht,
das ist ein anderes Thema der objektorientierten Programmierung. Das,
was uns in der objektorientierten Modellierung an diesen Konzepten interessiert,
an diesen Dingen sind, ist das, was man mit ihnen tun kann.
Und wenn ich jetzt sage, tun kann, dann ist das das,
was hier als Umgangsform bezeichnet wird, das sind Werben oder Deutsch-To-Wörter.
So, was kann ich mit einem Ordner tun?
Und hier sehen Sie jetzt schon so ein paar Beispiele,
Man kann also so aus einem Ordner,
kann man ein Dokument entnehmen, man kann eins einfügen.
Und auf diese Art und Weise, also wir nehmen,
bezeichnen ein Ding, einen Gegenstand mit einem deutschen Begriff,
substantiv und wir beschreiben dann, was man mit diesem Ding,
mit diesem Gegenstand tun kann, eine Form von Verben,
so erarbeiten wir uns ein Begriffsverständnis für das,
was wir nachher programmieren wollen,
mithilfe der Objekte,
mit den Mitteln der objektorientierten Programmierung
So, das sind jetzt so die, sagen wir mal so,
ich versuche, ihnen gerade zu vermitteln,
dass sie sich so eine objektorientierte Brille aufsetzen und sagen,
was kann ich so an Gegenständen in meiner Umgebung entdecken?
Und was kann ich mit diesen Gegenständen jeweils anfangen?
Was kann ich damit tun? Und das ist so einer der Ausgangspunkte für die objektorientierte Programmierung. So,
wenn ich jetzt von Werben gesprochen habe,
also da verlassen mich dann auch langsam aber sicher meine grammatikalischen Grundkenntnisse,
also Entnehmen, Einfügen, Beschriften, so,
das sind alles, würde ich mal sagen,
das sind gute deutsche Two-Wörter versus also voll.
Das passt irgendwie nicht so richtig in diese Kategorie rein.
Jetzt kommt der nächste Schritt. Und das ist jetzt
so einer der Zeitpunkte, wo man sich berechtigterweise fragt,
also wie bin ich hier hingekommen?
Warum bin ich hier? Bitte stellen Sie sich jetzt für
den Moment vor, Sie sind ein Ordner
Und jetzt könnte ich also jeden Einzelnen von ihnen,
der jetzt so im Vollbesitz seiner geistigen Kräfte glaubt,
ein Ordner zu sein.
Den könnte ich jetzt fragen, bist du voll? Ja,
das kann man doch so einen Ordner fragen, oder?
Oder man kann, man könnte ihn auch fragen,
bist du leer? Und jetzt, so hoffe ich,
wenn sie jetzt weiterhin im Rahmen dieser Vorlesung
sich weiter vorstellen,
ein Ordner zu sein
Man kann mit ihnen etwas tun. Das heißt, man kann
ihren Zustand verändern. Sie befinden sich ja in einem Zustand danach.
Und ich kann sie dann auch nach ihrem Zustand befragen.
Insbesondere kann ich also fragen, bevor ich etwas in einen Ordner einfüge,
könnte ich den mal fragen, bist du voll?
Und dann kriege ich eine Antwort. So,
wenn die Antwort ja ist, dann sollte ich vielleicht nicht
mehr versuchen, noch etwas in diesen Ordner einzufügen.
Ich könnte ihn auch fragen, bist du leer?
Und dann sagt er, ja, dann sollte ich vielleicht
nicht mehr versuchen, etwas aus ihm zu entnehmen. So,
und das ist so, was ich jetzt gerade mit ihnen
hier mit meinen Ordnern Und was ich jetzt hier gerade versuche,
mit ihnen zu spielen ist, so ein objektorientiertes Modell,
also versucht, so ein Konzept zu vermitteln.
Was kann man sinnvollerweise mit so einem Gegenstand tun?
Und das bildet dann, ich komme da jetzt gleich drauf,
auch noch etwas, so technischer zu sprechen.
Das bildet die sogenannte öffentliche Schnittstelle eines solchen,
seines so modellierten Gegenstandes. Also das,
was man mit einem Gegenstand tun kann,
das wird in der öffentlichen Schnittstelle dieses Gegenstandes modelliert
So, jetzt sind wir schon einen Schritt weiter bei der Objektorientierten Modellierung.
Jetzt könnte ich dir die nächste Stufe zünden und sagen,
Zettel raus, Name drauf, modellieren Sie doch mal das,
was Sie unter einem Ordner verstehen, mit dem Instrumentarium,
das ich Ihnen jetzt gerade gegeben habe.
Verändernde Umgangsformen, vielleicht etwas mit dem Ordner tun und Sondierende,
sogenannte Sondierende, Umgangsformen. Was kann man von dem Ordner erfragen?
Das kriege ich wahrscheinlich dann so noch so 20,
30 verschiedene Konzepte des verschiedenen Modelle des Konzepts Ordner.
Und was wir daraus dann erstmal lernen können,
so für den Moment ist, Objektorientiert,
hört sich so im ersten so mindestens,
was sechs von acht Buchstaben anbetrifft, hört sich so an,
als wäre das eine Form der objektiven Modellierung.
Ist es nicht. Es gibt kaum etwas Subjektiveres als ein
objektorientiertes Modell. Denn was sie unter einem Konzept verstehen,
das vergegenständlichen sie in genau solchen Beschreibungen,
das sollte also niemand auf die Idee kommen, zu sagen,
so das ist jetzt für einen für allemal das Konzept eines Ordners.
Nein, das ist ihr Konzept eines Ordners.
Und das können sie mit anderen dann besprechen.
Darüber können sie sich austauschen. Und genau dazu sind
diese Modelle da
Dieses Konzept werden wir jetzt, also dann mal versuchen,
in einer Objektorientierten oder diese Herangehensweise werden wir versuchen,
in einer Objektorientierten Programmiersprache,
das ist in unserem Fall die Sprache Java,
da werden wir versuchen, so weit zu verdichten,
dass sie am Ende dieses Tages dann auch schon erste Java-Programme,
erste Objektorientierte Programme schreiben können.
Jetzt sehen Sie hier ein anderes Konzept realisiert und das ist das Girokonto,
das sehen Sie hier, also jede Klasse, jedes Java-Programm ist erstmal,
und das ist überhaupt nichts, wovor man sich fürchten muss,
nichts Respekt einflößendes, bis ein Stück Text.
Dieser Text fängt irgendwo an und der fängt immer mit demselben Schlüsselwort an,
nämlich mit diesem Schlüsselwort Klaas und dahinter, was wird eigentlich hier beschrieben?
So, und das, was in solchen Klassen beschrieben wird,
ist, was kann man mit dem,
was von dieser Klasse, erzählt er das nachher noch,
was da so an Gegenständen modelliert wird,
was kann man damit tun?
Und jetzt gibt es da so ein paar syntaktische,
genauso wie das bei Carol der Fall ist,
gibt es ein paar syntaktische Feinheiten, da kommen wir später noch im Detail drauf.
So, das, was sie hier für diesen Moment mitnehmen können,
ist, dieses ein ganz besonderes Girokonto,
nämlich in dieses Girokonto kann man nur einzahlen
Das ist, sagen wir mal, für den Alltagsgebrauch eher unheimlich,
aber macht ja nichts. Also das ist ja,
ich habe es ja gerade gesagt, objektorientierte Programmierung heißt nicht,
dass man irgendwas Sinnvolles tut, sondern es heißt erst mal nur,
dass man ein Konzept versucht zu realisieren und dieses Konzept des Girokontos hier,
das beinhaltet die Möglichkeit, man kann etwas einzahlen.
Es ist also ein schlechtes Geschäft, mindestens für denjenigen, dem dieses Konto gehört.
Ich will das jetzt nicht weiter ausführen. So,
das steht hier, so dieses Programm, so wie es hier steht,
könnte man auch übersetzen und was man damit machen könnte,
ist, man könnte Objekte erzeugen, die sich genau so verhalten,
wie diese Klassendefinition es vorgibt.
Nämlich, man kann auf Objekte der Klasse Girokonto etwas einzahlen.
Wie das im Detail funktioniert,
kommt hier in diesem Teil der Vorlesung noch was und Fred
wird es nachher auch live und direkt demonstrieren.
So einen technischen Begriff hier noch. Sie haben das
schon so ansatzweise bei Carol auch schon kennengelernt.
Es gibt ein Werkzeug, mit dem wir diese Texte beschreiben können.
Und dieses Werkzeug nennt man Editor und sie werden einen Editor
kennenlernen im Rahmen der Programmierumumgebung
Blue Jay, Blue Java, mit dem man solche Klassentexte
schreiben kann. Ist auch nichts anderes als Word,
ein bisschen eingeschränkt an der einen Stelle,
ein bisschen ausgeweitet an der anderen Stelle.
Diese und Programmierumgebung, Blue Jay enthält einen Editor,
mit der es ihnen erleichtert, solche Klassentexte zu schreiben.
So, Klassen sind also statische Elemente dessen, womit wir uns beschäftigen.
Sie sind die Basis, um aus diesen,
auf den Begriff gebrachten Konzepten
nachher Objekte zu erzeugen
Also eigentlich ist das so ein zyklischer Prozess. Man überlegt sich,
was ist das für ein Ding, der sich beschreiben will?
Wie kann ich das auf den Begriff bringen? Welche Umgangsformen
soll dieses Ding haben? Und das ist dann das,
was man später als Schnittstelle bezeichnet oder im technischen Sinne als Schnittstelle bezeichnet.
Was kann ich also mit Objekten, die aus einer
solchen Klassenbeschreibung erzeugt werden, was kann ich damit tun?
So, den Begriff der Schnittstelle hatte ich schon kurz erwähnt.
Sie sind ja weiterhin, also sie sind ja weiterhin
ein Ordner, der sie geben vor,
einer zu sein
Wenn man hier mal für den Dienstleister als allgemeine Bezeichnung,
was wir hier gerade beschreiben wollen,
wenn man da jetzt mal Ordner,
wenn Sie sich vorstellen, dass da Ordner steht,
dann bietet dieser Dienstleister verschiedene Dienstleistungen.
Also das, was man damit tun kann, an seiner
öffentlichen Schnittstelle an. Bist du voll? Bist du leer?
Ich füge ein Dokument ein. Das sind diese Dienstleistungen,
die ein Klient dieses Dienstleisters anfordern kann. Also jemand,
der, so das kann man umgangssprachlich,
untechnisch kann man das benutzen,
kann man
dieses Wort dafür verwenden
Der Klient benutzt die öffentlich sichtbaren Dienstleistungen an der Schnittstelle,
um eine Dienstleistung, um eine spezielle Dienstleistung anzufordern.
Und das Spiel kann man also mehrstufig spielen. Wenn Sie
das auf der Ebene betrachten, also das Zusammenspiel dieser beiden Komponenten,
dann ist in diesem Fall, ist also der Klient,
fordert eine Dienstleistung bei Dienst, diesem Dienstleister an.
Und um diese Dienstleistung zu erbringen, kann der Dienstleister dann
selber wieder ein Klient eines weiteren Dienstleisters sein.
Aha. Wie kann ich mir das denn vorstellen?
Also ich gebe, es gibt da meinetwegen eine Autowerkstatt
Und die bietet als Dienstleistung an, reparieren.
Und dann bin ich der Klient dieser Autowerkstatt und sage,
repariert mal mein Auto. Dann ist das Verhältnis zwischen uns völlig eindeutig.
Ich bin der Klient. Und diese Werkstatt ist mein Dienstleister.
Was ich nicht weiß und was mich auch nicht wirklich interessiert,
ist, ob die nicht einen Hinterausgang haben und geben das
Auto einem weiteren Dienstleister und sagen, repariere das mal.
Für weniger Geld und du musst es noch waschen hinterher.
Und geben dann das Auto wieder an mich zurück.
In diesem Fall ist dann der von mir beauftragte Dienstleister
der Klient eines weiteren Dienstlers
Ist das so das Spiel, kann man ziemlich lange spielen.
Und das wird in größeren objektorientierten Programmen auch so gehandhabt.
Und das ist so ein ganz grundsätzliches Verhältnis,
das sich so zwischen verschiedenen,
während der Ausführung eines objektorientierten Programms miteinander kommunizierenden Objekten ergibt,
das Verhältnis zwischen Klienten und Dienstleistungen.
Wir bespielen das jetzt erstmal so mindestens für die ersten vier Wochen.
Dieser Lehrveranstaltung werden wir das nur einstufig spielen.
Also es wird eine Klasse geschrieben,
von dieser Klasse werden Objekte erzeugt und die bieten eine Dienstleistung an,
die von einem Klienten wahrgenommen wird
Wir müssen uns jetzt,
bevor wir uns diese Klassendefinition nochmal etwas genauer anschauen,
müssen wir noch ein Konzept uns kurz vergegenwärtigen,
das so in dieser Form bei Carol auch noch keine Rolle gespielt hat.
Das ist das Konzept der Imperativen, Variablen.
Das kann man sich für den Moment,
das ist also diese Vorlesung, ist so eher überblicksartig.
Wir werden so praktisch jede einzelne Folie,
werden wir im Laufe des Semesters und im Laufe von SE2
auch nochmal auseinandernehmen und etwas genauer hinschauen.
Hier sollen sie jetzt erstmal
nur einen ersten oberflächlichen Überblick bekommen
So eine variable, stellen Sie sich vor,
als eine Art von Behälter, die einen bestimmten Wert haben kann.
Und diese Werte haben also bestimmte Bereiche, also Variablen,
die wir typischerweise, oder sagen wir mal, Werte,
die die annehmen können, sind wahlweise Zahlen oder Texte,
sprich Zeichenketten, und so eine Variable, so eine imperative Variablen.
Deswegen heißt die auch so variable, die kann ihren Wert
verändern in bestimmten Grenzen. Also eine Variable,
die als eine Zahl Variable deklariert worden ist,
die kann halt den Wert Kleinster Integer bis größter Integer beinhaltet,
aber sie kann nicht den Wert, ich bin eine Variable,
sprich eine Zeichenkette enthalten.
So diese Wertemengen bezeichnet man auch als Typen und diese Typen
legen fest, was kann ich mit dem Variablen tun?
Da ist es wieder. Man kann also so über die Festlegung von Umgangsformen,
also sind sie in der Lage, solche Konzepte zu modellieren,
so wie unseren Ordner oder wie das Girokonto.
Es gibt bestimmte Typen, für die ist es
in der Programmiersprache schon festgelegt
Integer, Zahl, Variablen, die kann man addieren.
Oder man kann sich subtrahiert, das, was man halt so mit Integer machen kann.
So, während man mit Bulschen, also Wahrheitswerten,
da macht es keinen Sinn oder es ergibt keinen Sinn,
die zu addieren, die kann man dann zum Beispiel legieren,
was keine sinnvolle Beziehung ist oder keine sinnvolle Operation für Integer.
So, das sind die Variablen und wenn man so Variablen deklariert,
dass er sagt,
ich möchte eine Variable von einem Integer-Typen zum Beispiel haben,
so wie die hier, so schreibt man das in Java hin,
dann stellt sich,
vielleicht ihn nicht,
später vielleicht doch
Stellt sich die Frage, welchen initialen Wert haben die denn?
Meinetwegen, sie wollen ein Konto eröffnen. Wenn sie jetzt
zu einer beliebigen Bank gehen und dieses Konto eröffnen,
dann werden sie ja vielleicht überrascht sein,
wenn der Initiale Konto stand, minus 5 Euro ist.
Dann erklärt ihnen ein freundlicher Mensch, das sind die Kontoeröffnungsgebühren,
die ziehen wir jetzt mal gleich ab.
Das hätten sie mir auch mal vorher sagen können.
Dann hätten sie ja nicht unterschrieben, also irgendwas,
so ein Dialog in der Art und Weise.
Und die Frage ist dann eben,
wenn sie so eine Variable vom Typ Integer deklarieren,
welchen initialen Wert hat die
42, 0, ganz viel, das ist vielleicht kein guter Wert.
So, und da müssen die jetzt jeweils,
also Aussagen drüber getroffen werden müssen, nicht,
aber es ist ganz schön sinnvoll, sich darüber Gedanken zu machen,
wenn man Variablen deklariert, welche initialen Wert die einnehmen sollen.
So, und hier sehen Sie das,
wie man das so in der Programmiersprache Java,
die macht es einem nicht schwer, schlechte Programme zu schreiben,
sie macht es halt einem einfach gute Programme zu schreiben.
Man kann also Variablen gleich so deklarieren,
dass sie einen initialen Wert bekommen
Wir hier die Variable I als initialen Wert 42 bekommt.
Und der Bulien B. bekommt hier nicht gleich einen initialen Wert,
aber sagen wir mal, das ist lexikalisch nahe genug beieinander.
Das ist also miteinander in Beziehung gebracht werden kann.
So, das ist guter Programmierstil, diese Deklaration und Initialisierung
in einem möglichst in einem Schritt zu vollziehen.
Jetzt sind wir so weit, dass wir uns unsere erste Klasse nochmal
etwas genauer anschauen können Und was wir jetzt hier sehen,
was Sie jetzt auch schon lesen können,
ist, dass unsere klasse Girokonto,
also das Erzeugungsmuster für alle im Programmablauf zu erzeugenden Girokontoobjekte,
dass die eine sogenannte Exemplarvariable enthält.
Und das ist die Variable Saldo. Die hat
den Namen Saldo und sie ist vom Typ Integer.
Das heißt, diese Variable kann Integer-Werte enthalten.
Jetzt steht hier noch so ein Schlüsselwursch,
noch so ein Wörtchen davor
Das ist, da steht Private und das bedeutet,
das ist eine variable Saldo gibt,
ist also potenziellen Klienten der Klasse Girokonto wird es verborgen.
Das ist eine private Information. Das geht niemandem was an. Wohingegen die Operation,
die Umgangsform einzahlen, da steht das Schlüsselwort Public davor.
Und das heißt ja nichts anderes als öffentlich und damit wird ausgesagt,
damit hat derjenige, der dieses Programm geschrieben hat,
ausgedrückt, ich möchte, dass die Operation einzahlen,
ein Teil der öffentlichen Schnittstelle der Klasse Girokonto sein soll.
Es soll nicht nur so sein, sondern das ist so.
So, jetzt wissen wir also,
wenn Sie diesen Text da jetzt lesen, ah,
da hat jemand also die Klasse Girokonto implementiert,
was kann ich damit tun mit so einem Girokonto?
Oh, ich kann was einzahlen. Und jetzt stoßen Sie
möglicherweise an einer Stelle noch auf eine kleine Hürde.
Was bedeutet das denn wohl, wenn da steht,
noch in Betrag? Das kann man sich jetzt
fast denken. Da ist auch
kein Geheimnis
Also jetzt folge ich Sie mal auf,
vergessen Sie mal, dass Sie ein Ordner sind.
Stellen Sie sich mal vor, Sie sind ein Girokonto.
Und jetzt rufe ich Ihnen zu, also nachdem ich Ihre
öffentliche Schnittstelle nicht persönlich gemeint, ich möchte etwas einzahlen.
Ja, wie alles verstehe ich, aber du musst mir noch was mitgeben.
Das ist ja sinnvoll, wenn man sagt, ich möchte einzahlen,
dass man sagt, ich möchte dann vielleicht fünf Euro einzahlen.
Dieses Konzept nennt man also Parameter, Parameterübergabe.
Es soll Wenn die öffentlich sichtbare Operationen einzahlen, aufgerufen wird,
sollen noch eine Zahl mitgegeben werden und die wird als Betrag bezeichnet.
Und was dann passiert, das kann man sich so vorstellen.
Es gibt ja so einen Betrag, den man
sich schon gemerkt hat oder den man sich merken kann.
Und das ist dieser Saldo. Und der wird verändert. Und das,
was hier steht, das ist also, da wird jedem,
der so Schulmathematik noch im Hinterkopf hat, fragt sich, was soll das bedeuten?
Der Saldo ist gleich Waldo plus Betrag. Das kann doch
nur falsch sein. Das kann man deswegen falsch sein,
wenn man dieses, wenn man dieses Zeichen hier nicht so interpretiert,
wie es gemeint ist. Was hier nämlich steht, ist,
dies ist eine Anweisung, addiere auf den alten Saldo,
das, was jetzt als Betrag,
als Parameter übergeben worden ist und weise das Ergebnis der Variablen
Saldo zu
So, dann sei also der Saldo mal null.
Es wird aufgerufen vom Klienten und dieser Klasse, wird aufgerufen.
Wir zahlen jetzt mal was ein, meinetwegen 5 Euro und
dann passiert folgendes. Ups, da. Saldo plus Betrag,
0 plus 5, das kann ich gerade noch,
dann ist der neue Wert des Saldos, ist dann 5 Euro.
Und dieses Spiel können wir spielen, also bis es langweilig wird.
Wir können also auf diese Art und Weise
eine verändernde Umgangsform an einem Konto implementieren und den Effekt beobachten.
Jetzt komme ich nochmal zurück zu dem Ordner. Wenn ich
den einen von meinen Ordnern hier frage, bist du voll?
Dann kriege ich als Antwort nein. Sagen wir mal,
ich kriege als Antwort nein. Wenn ich den nochmal frage,
kriege ich dann eine andere Antwort oder direkt hinterher?
Nee, ne? Es wird uns doch überraschen. Ich frage einfach,
oder ist ihr im Alltag, sie rufen bei der,
oder das ist Online-Banking,
ihrer Bank und fragen nach dem Kontostand und sie kriegen eine Antwort,
dann fragen sie gleich nochmal hinterher, dann hoffen sie doch,
dass der Kontostand sich nicht verändert hat.
Das habe ich letztens mal gemacht. Morgens habe ich meinen Kontostand abgefragt,
dann habe ich die Antwort bekommen, x Euro.
Dann bin ich losgefahren und im Auto fiel mir ein,
ich muss noch was überweisen.
Und dann rufe ich an und dann sagt einem dieser Automat,
als erstes den Kontostand und das war halt x-minus 1000 Euro.
Wie kann das denn sein? So, das Erklärungsmodell.
Jetzt geht ja was los
Jemand anders muss an diesem Objekt mein Girokonto, eine verändernde Umgangsform aufgerufen haben.
In diesem Fall, ich hebe mal 1000 Euro ab.
Dann kriege ich die Dame ans Telefon und sagt,
also wer hat denn da in der letzten halben Stunde 1000 Euro abgehoben?
Dann haben die gesagt, das Finanzamt. Sagte ich,
diese Schurken, das holen wir uns zurück.
Und dann sagt die,
habe ich gemacht
Oh, das war ein Scherz. Naja,
sie haben gesagt, das holen wir uns zurück.
Das ist nämlich mit den Mundmitteln jetzt, wo es,
also dieses E-Bike und dieses ganze Zeug gibt, kann man das machen.
Man kann also Geld zurückholen. Ja, der Rest war da nicht so lustig.
Witz hat nicht 10 Euro gekostet. So, also,
das war das Zusammenspiel zwischen verändernden und sondierenden Umgangsformen. Sie sind diejenigen,
die mit den Mitteln der objektorientierten Programmierung erstmal diese Modelle herstellen,
sodass andere Leute sich das erklären können, wie diese Modelle funktionieren.
Und das ist ein ständiges Wechselspiel zwischen, ich frage,
in welchem Zustand befindet sich dieses Objekt und ich richte daraufhin mein nächstes Handeln aus.
Weil es macht keinen Sinn aus einem Ordner,
der erklärt hat, ich bin leer,
an dem noch die Operation entnehmen des Dokumentes X aufzurufen.
Es ist sinnlos. Und wir werden dann
auch noch Methoden und Techniken kennenlernen, die also,
die sie dabei unterstützen, also sinnvolle Modelle zu entwickeln.
So,
für den Moment
Sie sehen hier das,
worüber ich jetzt schon so ein bisschen gesprochen habe,
das Verhalten eines Objektes durch seine Dienstleistungen, auch Methoden genannt,
wird es bestimmt, wie das passiert.
Da habe ich jetzt noch nicht so drüber gesprochen.
Das ist nach außen hin nicht sichtbar und das soll auch
nicht so sein. Und das ist ein ganz fundamentales Prinzip,
also nicht nur der objektorientierten Programmierung der Programmierung überhaupt,
dass man die Art und Weise,
wie eine Dienstleistung erbracht wird,
vor seiner Außenwelt verbirgt,
weil das will niemand wissen
Wie so eine Dienstleistung erbracht wird. Das ist also reduziert,
beziehungsweise macht die Komplexität bei der Programmierung auch in hohem Maße beherrschbarer,
als würden sie alle möglichen Implementationsdetails ihren Klienten gegenüber offenlegen.
So, jetzt kommt nur noch so ein bisschen Begriffsbildung eigentlich.
Jedenfalls an der Stelle. Sie schreiben also ihre Klassen und
oder in diesem Fall eine Klasse und es werden jetzt hier
zwei Bereiche werden in einer Klasse unterschieden, der Kopf der Klasse.
Da steht halt der Name und so was, so was,
diese Klasse eigentlich soll und das wird in einem Schnittstellenkommentar wird das festgehalten.
Diese Sternchen hier, das ist jetzt nicht, dass da jemand versucht hat,
so seine grafischen Fähigkeiten auszuleben, an diesen Zeichen erkennt der Übersetzer,
der Compiler, dass das ein Kommentar sein soll.
Also hier soll kein Code produziert werden, sondern das ist für menschliche Leser, ist das gedacht. So,
nach dem Klassenkopf kommt der Klassenrumpf, sowieso eine weitere Form der Metaphorik,
die hier angewendet wird in dem Klassenrumpf,
stehen halt so die privaten harten Variablen und die öffentlichen,
teilweise auch privaten Methoden, also Operationen, Schrägstrich Umgangsformen,
die eine solche Klasse beinhaltet.
Wenn Sie genau hinschauen, hier gibt es schon einen Begriff,
den Konstruktor, auf dem ich noch nicht weiter eingegangen,
das ist jetzt die Stelle, wenn also eine,
ein Objekt von einer Klasse erzeugt werden soll,
wenn Sie sagen, so ich habe jetzt diesen Klassentext Girokonto,
habe ich jetzt geschrieben,
jetzt will ich aber auch endlich mal ein Objekt oder auch zwei,
zwei Objekte von dieser Klasse erzeugen
Und dann ist ja die Frage, die ich schon aufgeworfen habe,
wie ist denn das jetzt mit dem initialen Werten von Variablen dieser Klasse?
So, und dafür gibt es ein spezielles, eine spezielle Operation in einer Klasse,
die kann da sein, die muss da nicht sein.
Das ist der sogenannte Konstruktor. Und in diesem Konstruktor wird festgelegt,
welchen Wert sollen denn jetzt die initialen, welchen initialen Wert
sollen denn die Variablen, die Exemplarvariablen einer Klasse haben.
So, und das wird ja jetzt hier gesagt für die Objekte der Klasse Girokonto,
speziale Wert, für die einzige vorhandene Exemplarvariable, der soll null sein.
Ja, warum auch nicht? Ich meine, gut,
es könnte ja auch ein Mäusekonto sein und sind ja initial 5 Euro drauf.
So Dinge dieser Art kann man jedenfalls über den Konstruktor festlegen. Das heißt also,
bevor ein Klient in der Lage ist, die Operation,
die öffentlich sichtbaren Operationen aufzurufen, wird vom sogenannten Laufzeitsystem,
wird festgelegt, wenn dieses Objekt erzeugt wird,
dann sollen die Exemplarvariablen Diese Werte,
die eben Konstruktor drinstehen, enthalten.
Sondern noch so, damit der Compiler das auch als diesen Konstruktor erkennt.
Da gibt es eine Regel für. Der Konstruktor muss immer
so heißen wie die Klasse, für die er geschrieben wird.
Dadurch erkennt der Compiler bzw. das Laufzeitsystem, aha,
das ist der Konstruktor. Diese Operation rufe ich mal auf,
bevor jemand anders irgendeine andere Operation aufrufen kann.
Jetzt habe ich schon davon gesprochen. Sie haben also Texte geschrieben,
Klassentexte geschrieben, mit der Absicht, dass die Schablone ist,
um Objekte aus diesen Klassentexten zu erzeugen.
Wie geht das jetzt? Die werden jetzt gleich auch in
dem Teil von Fred, der wird ihnen da,
wird dieser Schritt für Schritt wieder sie da ranführen.
So, hier jetzt erst mal so wie das prinzipiell konzeptionell,
wie das konzeptionell stattfindet. Es sei mal so,
dass es eine klasse Quadrat geben soll,
eine Klasse Dreieck und ja, diese beiden Klassen soll es mal geben.
Und was ich hier jetzt tue, ist, ich sage,
ich möchte ein Quadrat haben, Und dieses Quadrat, das nenne ich Wand.
So. Und was jetzt passiert, durch die Anweisung,
die hier steht, hier wird jetzt tatsächlich ein neues Quadratobjekt geschaffen,
auf das ich über den bezeichne Wand zugreifen kann.
So, und das Nächste, was hier steht,
das ist nach demselben Prinzip. Da wird also ein Dreieck namens Dach,
wird da deklariert und dann wird ein Dreiecksobjekt Nicht,
dass es nachher heißt, ich konnte nicht mehr mitschreiben, weil.
Deswegen habe ich das nicht verstanden. Und dann wird hier
ein Dreiecksobjekt erzeugt, auf das ich über den bezeichne,
da zugreifen kann. Und schon habe ich jetzt zwei Objekte geschaffen.
Jetzt kommt die nächste Frage, was kann ich mit diesen Objekten jetzt tun?
Darauf habe ich ja jetzt fast schon eine Dreiviertelstunde lang rumgeritten.
Wenn ich also solche Objekte erzeugt habe, dann tue ich das,
weil ich damit was tun möchte.
Und die ehrliche Antwort darauf ist, Wir wissen das nicht
so genau, an der Stelle jedenfalls.
Was kann man denn jetzt mit Quadraten oder Dreiecken,
was kann man denn damit tun?
Weil wir die Klassentexte nicht kennen. So,
wenn man jetzt mal sich so, das ist ein...
Das ist so ein Spiel, das ich manchmal spiele während einer mündlichen Prüfung.
Wobei der spielerische Charakter, ich gebe es zu,
ist eher auf meiner Seite.
Das ist so wie Katzen so manchmal mit Mäusenspiel.
Nein, nein, es geht alles gut
Und schreibe ich mal so Klassendefinitionen hin,
beziehungsweise am ersten, die ersten zwei, drei Prüfungen,
mündlichen Prüfungen des Tages, dass ich,
also jemanden wie Sie, Klassentexte hinschreibe oder solche Diagramme malen.
Und später geht das Spiel dann ein bisschen anders.
Dann lege ich also dem fünften oder sechsten Prüfling das hin und sage,
können Sie mir erklären, was das bedeuten soll?
Und das ist eine tückische Situation,
weil das wissen Sie ja dann,
dass das einer von Ihnen vorher gemacht hat und Sie wissen nicht,
steht da jetzt Quatsch oder steht da vielleicht was Sinnvolles?
Da kann man
sich prächtig drüber unterhalten
Ich kann mich da prächtig bei unterhalten. Irgendwie muss man
ja auch überleben. Alles ist gut, alles gut.
So, zurück dazu. Ja, was wir jetzt hier spielen,
ist also genau so eine Art von,
also auf der Folie, was wir jetzt hier spielen,
ist jetzt so eine genauso eine Art von Höhlenforschung.
Ja, wir gucken in diese Höhle rein und dann war halt
so ein Speer und ein Büffel und aha, was machen die da?
Soll der Büffel da drüber springen über den Speer?
So weiß man ja auch nicht. Und an Offensichtlich kann man an diesem Sandobjekt,
und das ist so liest man das jetzt hier,
diesem Objekt wandt, von dem wir wissen,
dass es ein Objekt der Klasse Quadrat ist.
Das steht nämlich hier, kann man die Operation vertikal bewegen,
um 80, was auch immer das ist, um 80 aufrufen.
An dem Objekt Fenster, von dem wir auch wissen,
dass es ein Quadrat ist,
kann man die Operation Farbe ändern, aufregen, aufrufen.
Also das kann man ja interpretieren. Die Farbe soll offensichtlich
in blau geändert werden. Dach, was war Dach?
Dach war ein Dreieck im Dreieck kann man horizontal bewegen,
aufrufen. So, und jetzt erschließt sich so,
jetzt müsste man anfangen, mal tatsächlich in diese Klassenbeschreibung zu schauen,
was kann man alles mit Quadraten beziehungsweise Dreiecken tun.
Wenn ich sie, in dem Fall kann ich auch von mir sprechen,
wenn ich mich aufgefordert hätte, mal zu sagen,
was man mit einem Quadrat tun kann.
Also wäre mir sicherlich nicht eingefallen, vertikal bewegen,
hätte irgendwas gesagt, Fläche berechnet oder sowas.
Und der Art und Weise, wie dem auch sei,
also objektorientierte Modellierung, höchst subjektive Angelegenheit.
Wir schauen uns das jetzt mit der Exemplarerzeugung
nochmal an
Wieder so im Einzelnen, welche Effekte das erzeugt.
So, ist es nicht schön. Ist nicht auf meinem Mist gewachsen,
haben also meine Vorgänger im Amt, haben diese Animation hergestellt.
So, also das Laufzeitsystem durchläuft diese Code-Zeile und was dann
erzeugt wird, ist ein Objekt von der Klasse Quadrat.
Und was dann passiert, jetzt kommt wieder der Bezug zum Konstruktor.
Jetzt wird geguckt innerhalb der Klasse Quadrat. Gibt es einen Konstruktor,
der muss ja dann genauso heißen wie die Klasse Quadrat
und dann werden zunächst mal diese Operationen,
die in dem Konstruktor der Klasse Quadrat aufgeschrieben sind, die werden durchgeführt.
Bevor dann der Code, also der Kontrollfluss,
wieder hierhin zurückkehrt und man mit dem Quadrat etwas tun kann.
So, jetzt haben Sie schon gesehen,
also wie solche Methoden aufgerufen werden und das generelle Prinzip ist,
also das können Sie für heute und für alle Tage,
wie Sie objektorientiert programmieren, können Sie das mitnehmen.
Diese Aufrufe haben immer dieselbe Struktur. Diese Struktur ist,
ich sage, welches Objekt möchte ich aufrufen, dieses Objekt wird bezeichnet.
Das war in unserem Fall zum Beispiel die Wand.
Und dann kommt dieser Punkt, das ist in manchen Programmiersprachen
, ist das auch ein Pfeil.
Also das ist jedenfalls so der Separator zwischen dem Objektnamen und
der öffentlich aufrufbaren Schnittstellenoperation in unserem Fall vertikal bewegen.
Und das, was da noch zukommt, ist,
also manchmal werden Operationen mit Parametern aufgerufen.
Manchmal werden sie ohne Parameter aufgerufen. Das ist halt abhängig davon,
was in der Klassendefinition in der öffentlichen Schnittstelle dieser Operation steht
So, wenn man,
jetzt kommen wir schon so zu Feinheiten, also das Verhältnis,
das ich bisher dargestellt habe, ist ja ein Klient,
ruft eine öffentlich sichtbare Operation an der Schnittstelle eines Dienstleisters auf.
Wenn ich eine Operation an mir selbst aufrufen möchte,
dann kann ich auf diesen Objektbezeichnern verzichten.
Das bringt einige lustige Effekte mit sich, wobei das
lustig zu finden ist, eine spezielle Eigenschaft von Informatikern.
Der Rest der Welt findet es nicht lustig. Und wenn
Sie das nicht lustig finden, will ich nicht sagen,
dass sie mal in sich gehen sollten, ob sie das Richtige studieren.
Aber nein, das muss auch nicht sein. Aber sagen wir mal,
nur Informatiker haben die Chance, das lustig zu finden.
Alle anderen denken, ich finde es nicht lustig.
So. Was soll das? So, jetzt nochmal der Bogen
zum Anfang. Ich habe davon gesprochen,
dass so zwei prinzipiell verschiedene Arten von Umgangsformen mit Gegenständen,
dass wir die unterscheiden.
Die verändernden Methoden, etwas auf ein Konto einzahlen
Ein Dokument in einen Ordner einfügen. Und sondierende Umgangsformen,
also Umgangsformen, in denen wir etwas fragen.
Sag mir mal den Kontostand. Sag mir mal,
wie viele Dokumente in dir enthalten sind. So,
das können wir diese beiden Arten von Umgangsformen,
die können wir auch, also innenobjektorientierten Programmiersprachen,
eins zu eins, können wir die implementieren.
So diese verändernden Methoden heißen Neudeutsch, Neudeutsch Mutators.
Das hört sich ja gleich
viel besser an
Hat sowas von Mutanten, also verändernde, ich glaube,
lateinischwerk gibt es Lateiner hier, Mutare?
Ist das ein lateinisches Verb? Was bedeutet das?
Verändert. Danke. Ja, ist doch schön,
so eine Vermutung dann auch nochmal bestätigt wird. So,
und so verändernde Methoden, da werden sie jetzt so,
wenn sie jetzt so Muster, werden sie sehr schnell,
werden sie die entwickeln.
So, was sie hier sehen,
ist ein Beispiel für eine verändernde Umgangsform,
die von außen hin sichtbar ist
Und nichts zurückkommt, ist ja auch keine sondierende Umgangsform.
Deswegen steht hier Void für nichts. Also da kommt einfach nichts zurück.
Die hat einen Namen und sie bekommt einen Parameter und der ist vom Typ Intager.
So werden verändernde Umgangsformen in Java werden die notiert.
Und die Sondierenden Methoden, die sagen also eben Unterschied,
also die sind auch public, damit sie öffentlich sind,
sonst kann man sie ja nicht aufrufen.
Und die Sondierenden Methoden sagen, welche Art von Ergebnis sie zurückliefern.
Also auf die Frage, gib mir mal den Saldo,
also den Kontostand, kriege ich einen Integer zurück.
Dass das inhaltlich dünn ist, ist, sei mal dahingestellt,
da werden wir auch noch was Besseres kennenlernen,
aber wir können die Welt jetzt hier nicht an einem Tag erschaffen.
Also die Sondierenden Methoden, da steht jetzt halt nicht Void,
sondern da steht Int und das bedeutet, aha,
wenn man das aufruft, kriegt man was zurück.
So, auch die haben einen Namen und, naja gut,
in diesem Fall diese Methode hat keinen Parameter.
Und jetzt bin ich so in einer Dreiviertelstunde mal so durchgegangen von Sie sind Ordner,
sie sind Giro-Konten, bis hin zu,
wie kann man das in Java so für den Moment,
wie kann man das implementieren?
Und jetzt übergebe ich an Fred aka Casey Jr.
An der Reaktion stelle ich fest, die kennen das.
Jedenfalls manche von ihnen. Ich bin ja Casey Senior,
ohne Tatendrang. Und ich wünsche Ihnen jetzt
ein schönes Wochenende
Okay. Dann, wir haben ja ein bisschen Zeit.
Ihr könnt uns noch mal ganz kurz Kerl anschauen.
Der lässt uns ja nicht los. Kind. Ich finde das
immer so toll, wenn wir Studenten-Mails schicken, hallo.
Ich wollte eigentlich erst mal nur die beiden oben zeigen.
Jetzt haben wir so ein paar Studenten-Mails geschickt,
dass ich einen Fehler habe in der Musterlösung von Ed Forst.
Vielleicht trauen sich auch nicht alle so eine Mail zu schreiben,
also vielleicht sind es mehr als zwei Leuten.
Das ist aufgefallen und das wollte ich euch einmal zeigen
Wo ist das Adfast, wo ist das Adfast, hier ist es.
Und jetzt klicke ich mal zwei schöne Zahlen zusammen.
Vier. Und so. Welche Zahlen sind das denn?
Das ist ja 1, 2, 4, 18,
16, 32 und 64, 32 und 64 sind 96,
wenn wir nicht alles täuscht.
Und 4 ist 100. Und welche Zahl ist das hier unten?
Genau. Also ich versuche jetzt 100 und 200 zu addieren.
Und die Hoffnung ist ja, dass dann 300 dabei
rauskommt.
Also die menschliche Hoffnung
Tja, tut es aber nicht, ne?
Was kommt stattdessen raus? So, Herr 4, 8,
12, 44. Also statt 300 kommt 44 dabei raus.
Von beiden. Hm? Ja, es macht im gewissen Sinne Sinn,
also technisch macht es Sinn, wenn ich also sage,
in so einem Rechner haben Bytes immer nur acht Positionen.
Deswegen sind ja auch die Ausgangszahlen so. Deswegen habe ich
für das Ergebnis technisch eben auch nur acht Positionen.
Und die Tatsache, dass jetzt hier ein Diamant liegt,
ist so ein kleines Warnsignal uns uns.
Achtung, Achtung. Das Ergebnis,
was du hier unten siehst, ist vielleicht mathematisch nicht das,
was du erwarten würdest
Wie viel fehlt denn jetzt? Also was ist denn dann
die Differenz zwischen 44 und 300? 256. Das ist genauso,
weil jetzt quasi dieser Diamant, den es sozusagen nicht gibt,
oder diese Position gibt es in allen Wahrheit nicht,
weil dir die Wertigkeit 256 hat.
Ja. Fand ich aber sehr nett, dass mir da also Alternativvorschläge geschickt wurden.
Also warum kann Carrie nicht einfach nochmal das eine Spalte lang
machen und so. Das ist eben so eine Grundsatzdiskussion,
wenn wir das auf 8-Bit beschränken oder nicht.
Und ich zeige euch nachher, dass man auch außerhalb von
Carrie dieses Problem hat mit Überlauf von mathematischen Operationen.
Okay. Das war also das,
ich habe jetzt nicht die Namen dahin getan,
vielleicht wollen die ja nicht, dass ich die meinen Namen nenne.
Und da hatte ich noch eine interessante Mail bekommen
Da hat jemand also aus seiner Lösung für das Edfast
automatisch so einen schönen Graf erzeugt und mit denen geschickt.
Jetzt wollte ich euch einmal diesen Graf zeigen,
weil man kann da so toll die Grundidee sehen,
wie man das Edfast angehen kann.
Was muss das denn überhaupt machen? Vielleicht sage ich euch
das noch einmal ganz kurz. Hallo? Ich hatte dazu
eine eigene, nein, ich will es nicht umbenennen.
Ich hatte dazu ja diese Vogel. Also was muss man
für die schriftliche Addition machen? Man muss sich in
drei Zeilen angucken, wie viele Diamanten da liegen.
Also entweder liegen dann null Diamanten,
dann ist die Summe null oder es liegt da ein Diamant,
dann ist die Summe
Das liegen da zwei, Diamanten, das ist die Summe zwei.
Und es liegen drei, Diamanten, dann ist die Summe drei.
Man muss die Summe eben immer so darstellen, dass niedrige wird,
kommt hier in die Summenzeile und dann in der nächsten Spalte tut man dann das Übertrag bitte.
Genau wie im Dezimalsystem, nur halt mit Diamanten statt zu fahren. Okay,
das heißt also, wenn es jetzt hier drei Positionen gibt,
wo jeweils ein Diamant liegen kann oder nicht,
dann gibt es ja irgendwie acht Möglichkeiten, wieder Diamanten liegen können.
Also 0-0, 0-0,
9-0-1, 0-1-0,
0-1-1, 1-0-0,
1-0-1,
1-1-0, 1-1-
1. Das sind acht Stück, wenn ihr mitgezählt habt.
Okay, und jetzt würde ich ja erwarten,
dass man vielleicht diese acht Möglichkeiten irgendwie wiederfindet in diesem Diagramm.
Wollen wir anschauen, wie der Student das gelöst hat?
Ich fand das echt toll
Also der Student hat erst mal geguckt, ihr seht dieses Tool,
macht so ähnlich wie ich, immer so outen für Bedingungen.
Wir gucken erst mal, ob wir auf dem Bieper stehen,
also die oberste Zeile. Und jetzt spaltet sich schon mal
hier der Kontrollfluss auf in zwei verschiedene mögliche Pfade.
In beiden Fällen gehen wir einen Schritt nach vorne.
Und das heißt jetzt, wenn wir zum Beispiel hier gelandet sind,
wissen wir, hinter uns ist ein Bieper.
Und wenn wir hier gelandet sind, wissen wir,
hinter uns ist kein Bieper.
Das ist ja nichts, was man direkt abfragen könnte.
Ich kann ja nicht sagen, if beeper behind,
das hatte sich sozusagen jetzt hier so zusammengeschummelt.
Ich frage erst mal an der aktuellen Position,
und egal wie das Ergebnis ist, gehe ich anschließend einen Schritt nach vorne.
Okay, ja, dann stellen wir hier wieder
dieselbe Frage und gehen wieder abhängig davon
Entweder in diesen Pfad oder in diesen Pfad und gehen anschließend einen Schritt nach vorne.
Das heißt, wenn wir hier sind, wissen wir,
wir haben einen Biber gefunden und noch einen Biber gefunden.
Wenn wir hier sind, wissen wir, erst hatten wir
einen Biber gefunden und dann keinen. Wenn wir sind,
wissen wir erst, war da keiner,
dann war da einer und wenn wir hier sind, wissen wir,
erst war da keiner und dann in der zweiten Zeit aber auch keiner.
Und jetzt kommen wir nochmal so, solche Abfragen.
Und witzigerweise wird der Baum jetzt nicht größer,
sondern der Student hat erkannt, naja,
am Ende ist mir ja eigentlich egal, in welcher Reihenfolge diese Biber-Diederlagen.
Ich muss ja nur wissen, ich muss ja nur zwischen
den verschiedenen möglichen Summen unterscheiden. Dann gab es eben die Möglichkeit,
dass die Summe null ist, dass die Summe eins ist,
dass die Summe zwei ist und dass die Summe drei ist
Das fand ich irgendwie total super. Also wenn ich
einen Beeper finde und noch einen und dann keinen,
habe ich da zwei zum Beispiel insgesamt gefunden.
Deswegen muss zum Beispiel nur das Carriebit gesetzt werden.
Oder wenn ich am Anfang keinen finde und dann finde ich
einen und dann finde ich wieder keinen.
Habe ich insgesamt einen gefunden, also muss nur das Summen mitgesetzt werden.
Und so kann man sich durch alle möglichen Fahrliche durchgehen.
Und das ist, glaube ich, eine recht kompakte Lösung.
Also die war angeblich unter 100 Zeilen. Also kürzer als
meine Musterlösung. Ja, das fand ich irgendwie ganz nett. Also dieses Tool,
ich weiß nicht, wenn das Internet jetzt hier geht,
könnt ihr vielleicht auch mal mit euren eigenen Carrellösungen ausprobieren und euch davon überzeugen,
dass der Kontrollschuss da genauso durchgeht,
wie euch das vorgestellt habt
Jo. Ihr könnt hier einfach direkt Carol Code reinholen.
Also offenbar ist es so, sowas wie If und Why und so
kennt ihr und was ihr dann wirklich da reinschreibt, ist dann egal.
Also es geht auch offenbar für natürlich sprachliche Probleme.
Wenn ihr irgendwie Zweifel habt, dann drückt ihr den Hilfeknopf.
Ja, okay. Ja, darüber habe ich mich sehr gefreut,
über diese ganzen Mails. Sehr schön. Und dann dachte ich,
nutze ich doch jetzt mal, wir wollen ja eigentlich heute über Java reden.
Ich nutze mal kurz so den Übergang von Carol zu Java,
um über ein paar Konzepte zu reden, die heute eingeführt wurden.
Also Guido hat ja ziemlich am Ende gesagt,
oder vielleicht auch schon ganz am Anfang, da war ich nicht da.
Man unterscheidet zwischen verändernden Umgangsformen und Sondier Umgangsformen.
Jetzt kann ich da mal irgendwas hier hinschreiben, keine Ahnung,
Carols first program, was war das nochmal?
Das war ja irgendwie das hier. Also wenn ich jetzt
irgendwie schreibe, gehe nach vorne und nehme Bieper und so.
Sind das verändernde Umgangsformen? Also ändert sich dadurch irgendeinen Zustand
oder bleibt der Zustand so, wie er ist?
Und ich frage nur, wie der Zustand ist.
Wie ist es zu jemandem? Wer glaubt, dass das
verändernde Umgangsformen sind? Ah ja, und wer glaubt,
dass man damit nur was abfragt? Okay, sehr gut
. Gibt es denn irgendwelche sondierenden Umgangsformen in Carols Welt?
Kann man irgendwie Zustände abfragen? Ja, zum Beispiel ist
von Papier oder? Genau, das sind diese ganzen Die
ganzen F-Tasten ab F, 7, glaube ich, ne?
Genau. On Beeper, Beeper, Ahead. Das sind
die sondierenden Umgangsformen-Kehrer. Das schreibe ich auch noch mal drüber,
dass ihr das mal gesehen habt,
so ein Deal und um da muss vorher,
habe ich das richtig geschrieben?
Ja. Genau. Und die verändern dann, ach Mensch,
das ist immer schlauer, als ich es eigentlich haben will.
Verändern. Während dann die F-Tasten bis inklusive F-6. Jo,
sage ich recht einleuchtend, oder?
Gut. Und jetzt verstehen wir auch hoffentlich vielleicht,
was diese komischen Voids sind. Also,
wir hatten ja irgendwann mal so Hilfsbefehle geschrieben,
so Hilfsbefehle, die zum Beispiel hießen Move to Wall
Und da stand dann irgendwie drin, solange du noch nicht
von der Wand bist, geh doch mal einen Schritt nach vorne.
Und die Tatsache, dass da Void steht, bedeutet,
wenn ich als Programmierer Move-to-Wall aufrufe,
dann verändert sich irgendwie der Zustand der Welt.
Carrie wird bis zur Wand gehen. Aber es wird kein
Ergebnis zurückliefern, mit dem ich jetzt irgendwie rumrechnen könnte.
Also ich könnte zum Beispiel nicht sagen, ist move to wall.
Da wird jetzt keine besonders schöne Fehlermeldung kommen.
Ich habe das ehrlich gesagt noch nie ausprobiert.
Ich hoffe, es kommt eine Fehlermeldung. Okay, das
ist keine besonders sinnvolle Fehlermeldung. Also wenn ihr sowas in einem Java-Programm machen würdest,
dann würde das Java-Programm euch sagen, pass auf,
ich erwarte hier irgendwie einen Wahrheitswert, aber du hast mir hier so ein Nichts reingesteckt.
Das macht irgendwie keinen Sinn
Also Void als Rückgabetyp bei so einer,
in Java nennen wir es ja Methoden, bedeutet immer,
es kommt kein Wert zurück wie eine Zahl oder ein String oder ein Wahrheitswert,
mit dem man dann irgendwie rumrechnen könnte.
Es verändert sich nur irgendwas in der Welt. Das bedeutet
, dieses Void. Okay. Gut, ich glaube,
das ist auch alles, was wir jetzt aus Carrie rausmachen können.
Es sind bis hierhin noch Fragen. Ja. Ja,
man hat gar kein Lebenswert, Mario, wenn man dem ist,
der da außer, dass es gefiel, nicht zu werden lösen.
Ja, also ich kann keine Variablen deckeln und ich kann nicht sagen,
in X oder so, ich kann keine Parameter definieren,
das gibt es alles nicht in Carrie.
Genau, richtig
Das stört immer die fortgeschrittenen Programmierer.
Die wollen immer variabel in einem Fahrradmeter und alles sind.
Es tut mir dann immer so leid,
dass ich denen immer sagen muss, das gibt es gar nicht.
Okay. Gut, dann lernen wir ja jetzt eine neue
Entwicklungsummgebung kennen. Ich habe sie bei mir schon installiert.
Hier ist sie. Übrigens Blue J, ach Mist,
jetzt hat sich das wieder so schnell geschlossen.
Kann man, kann ich das hier nicht irgendwie sehen?
Ja, genau. Das Ding heißt Blue J,
weil dieser Vogel auf Englisch Blue J, also JA Y heißt,
das hat Jahre gedauert, dass ich das verstanden habe.
Also falls ihr euch mal wundert, warum das Blue J heißt,
dieser Vogel ist ein Blue J mit
A Y am Ende.
Okay, das Schöne an Bluejay ist, ihr könnt direkt SIP-Dateien öffnen.
Also wenn ihr irgendwie nicht wisst, wie man SIP-Dateien entpackt,
keine Angst, das macht Bluejay von euch alleine.
Also wir öffnen das Zipp und jetzt entpackt er das.
Gut. Das ist also unser Bluejay, ich mache mal einmal Vollbild. So. Okay,
und ich wollte jetzt einmal noch auf diese komische Sache eingehen,
ob 100 und 200,
300 ist oder 44. Und tatsächlich ist es in Java so,
wenn ihr 100 und 200 addiert, dann dauert es ein bisschen,
Java muss erstmal hochfahren, da sind wir,
kommt tatsächlich 300 aus.
Aber wenn wir das jetzt mit größeren Zahlen machen,
zum Beispiel mit den Tausenden,
ist es auch noch
kein Problem
Versuchen wir es mal mit Millionen. Ist auch noch
kein Problem. Und jetzt versuchst du mal mit Milliarden.
Da würde man jetzt ja erwarten, dass da drei Milliarden rauskommt.
Schauen, was rauskommt. Tja. Minus eine Milliarde,
zwei, ja. Also nicht wirklich das,
was man erwartet hat. Hier ist also dasselbe Problem.
Java hat intern in so einem Int nur 32 Beeper und
wir brauchten jetzt einen 33. und den gibt es leider nicht.
Also dieses Problem gibt es eben auch nicht nur in Kerlenswelt.
Damit solltet ihr so immer im Hinterkopf arbeiten.
Ich das mal wieder weg, dass euch das nicht verwirrt.
Okay, also wir sehen jetzt hier erstmal eine schöne für Anfänger,
schöne, grafische Repräsentation von Klassen. Das sind alles Klassen,
die werden also sowieso gelb oder dunkelorange dargestellt und man kann jetzt
noch nicht besonders viel machen mit diesen Klassen, weil die so komisch gestreift sind.
Also wenn ihr diese Zip-Datei zum ersten Mal öffnen werdet,
wird das bei euch genauso aussehen und ihr müsst jetzt erstmal dafür sorgen,
dass diese ganzen Quelltexte dieser Klassen, also wo drin steht,
irgendwie Klaas-Zeichner und dann irgendwie ganz viel Public Private,
sonst was Zeug, dass das übersetzt wird in eine Form,
die der Computer versteht und dafür muss ihr einmal auf übersetzen wollen.
Bei mir ist es auf Englisch,
ich weiß gar nicht warum, ich dachte,
ich hätte hier das Betriebssystem auf Deutsch installiert.
Klinken wir einmal auf
Und jetzt seht ihr, sind die Streifen weg.
Jetzt kann man anfangen, was Sinnvolles damit zu tun.
Womit fangen wir dann mal an? Vielleicht hiermit. Also,
wenn ich auf die Klasse Kreis raufklicke,
gibt es eine, sage ich mal, sinnvolle Sache,
die ich anklicken kann, dieses New Kreis.
Und alles andere sind so Blue Jave, spezifische Dinge.
Also zeig mir doch mal den Quelltext oder übersetze mal oder so.
Das hat also eigentlich nichts mit Java an sich zu tun.
Das Einzige, was ich jetzt wirklich mit der Klasse machen kann,
ist zu sagen, ich will einen neuen Kreis haben.
Also diese Klasse beschreibt erstmal nur ganz abstrakt,
allgemein die Idee eines Kreises, woraus besteht der so Hassenfragen?
Achso, das sah dazu aus. Woraus besteht der so?
Und wenn ich jetzt tatsächlich mal was mit Kreisen machen will,
muss ich mir welche erzeugen.
Ich erzeuge immer
einen Kreis
Ja, ich kann dem Namen geben, ich nenne den
einfach mal Kreis 1, da muss ich nichts tippen.
Und jetzt seht ihr den Kreis hier unten. Also Kreise sind offenbar
so abgerundete Rechtecke. Wie sieht das mit Quadraten aus?
Sehen genauso aus um Dreiecke. Sehen erstmal genauso aus,
ja. Also lasst euch erstmal nicht von den Namen verwirren.
Alle Objekte, die ihr in Bluejoy erzeugt,
werden hier unten auf dieser Leiste, die nennt sich Objektleiste dargestellt,
als so rote Rechtecke mit abgerundeten Ecken.
Und irgendwann hat sich bei uns der Begriff Bubble durchgesetzt,
weil Rechtecke mit abgerundeten Ecken,
das ist immer so ein unschönes,
langes Wort
Okay, und man kann jetzt zum Beispiel mit der rechten Masse
raufklicken auf so ein Objekt. Nochmal kurz als Kontrast,
wenn ich auf die Klasse raufklicke, kann ich mir nur Objekte erzeugen.
Wenn ich aber jetzt auf die erstellten Objekte raufklicke,
kann ich viel mehr damit machen. Ja,
ich kann also zum Beispiel die Farbe eines Kreises ändern.
Aber ich sehe ihn ja irgendwie noch gar nicht.
Wahrscheinlich ist das nicht so sinnvoll. Ich kann die Größe
ändern, ich kann ihn durch die Gegend schieben.
Und jetzt was Besonderes von diesem Projekt,
ein Projekt für Programmieranfänger, man kann sich sinnvollere,
grafische Repräsentationen dieser geometrischen Fibern anzeigen lassen.
Also wenn ich hier raufklicke, öffnet sich so eine Leinwand
und da sieht man jetzt mal wirklich den Kreis.
Offenbar ist der Kreis also blau und hier irgendwo links am Rand des Bildschirms.
Und wenn ich jetzt nochmal andere Objekte sichtbar mache,
jetzt ist das im Hintergrund
Ja. So. Ich glaube, ich muss das Fenster einfach mal klein machen.
Mein Laptop ist ja so alt, da sind wir wieder.
Genau, und ich kann das Dreieck zum Beispiel auch nochmal
sichtbar machen. Ja, da sind wir. Und wenn
ich jetzt zum Beispiel noch ein weiteres Quadrat mehr erzeuge,
darauf werdet ihr bestimmt auch stoßen.
Und wenn ich das sichtbar mache, sieht man jetzt erstmal keinen Unterschied.
Woran könnt ihr das denn liegen? Die liegen übereinander.
Vielleicht kann ich das ja irgendwie mal durch die Gegend schieben,
wenn ich hier zum Beispiel nach rechts bewege.
A, sieht ihr? Ich schiebe es nochmal nach rechts
. Ja, das sieht doch schon besser aus.
Kann ich vielleicht mal die Farbe ändern?
Welche Farbe warum wir mal nehmen? Ich mache immer
einen beliebten Anfängerfehler, ich sag mal, gelb.
Nicht das Gelb, eine schlechte Farbe wäre.
Aber was ist das Problem? Canon Find Simple Variable Gelb,
das verstehe ich jetzt gar nicht. Es steht doch,
dass ich das eingeben darf. Sieht jemand das Problem?
Ja. Das Programm ist, dass man Screen reingibt.
Genau, man muss die Gänsefüße dahin schreiben. Also Strings,
so wie Hallo oder Welt oder Hallo Welt oder Gelb.
Müsst ihr immer in solche Gänsefüßchen schreiben,
sonst versteht Java nicht, dass das ein String sein soll.
Okay, mal sehen, ob das funktioniert.
Ah ja, da ist es. Kann man das sehen
auf dem Beamer? Ja. Gut. Und alles,
was man hier sieht, diese ganze Matte von Methoden,
Ist die sogenannte Schnittstelle eines Objekts?
Das ist also irgendwie, ja, in der Schnittstelle sind
eben die Methoden, die ich aufhoben kann.
Also so kann ich mit den Objekten reden.
Ich kann den Objekten sagen, bitte ändere mal deine Farbe.
Und da muss ich jetzt zum Beispiel so eine Farbe übergeben.
Ein Parameter muss ich dabei geben. Bei Größe ändern muss
ich auch einen Parameter übergeben. Also zum Beispiel,
ich weiß nicht, wahrscheinlich die Einheit Pixel,
nehmen wir mal 200, sehen, was jetzt passiert.
Ja, das wollte ich haben. Aber es gibt auch
zum Beispiel Methoden, wo man keine Parameter übergeben muss.
Also wenn ich jetzt Sachen dann links bewegen,
dann fragt er mich nicht, um wie viel ich das machen will.
Da gibt es offenbar irgendeinen sinnvollen Defaultwetter
drin in dem System
Aber ihr seht, dass alle diese Methoden, den Rückgabetub Void haben.
Das bedeutet also, sie verändern irgendwie den Zustand der Welt.
Man sieht das dann auf der Leinwand. Sie liefern mir aber
keine Informationen zurück. Also ich kann zum Beispiel nicht fragen,
so ein Kreis, welche Farbe hast du denn gerade?
Eigentlich schade, oder? Ist nicht vorgesehen.
Also der Programmierer fand das wohl nicht sinnvoll,
der diese Klassekreis geschrieben hat oder Rechtecke,
wo ich hier gerade bin, kann man das halt nicht abfragen.
Okay. Gut, bis hierhin erstmal Fragen.
Ne? Okay. Ich wollte euch einmal das aktuelle
Aufgabenplatz sagen
Wie die jetzt aussehen im Unterschied zur Kerre, das habe ich hier.
Was einem vielleicht auffällt, ist, dass die erste Seite,
ich mache vielleicht mal ein Vorbild, ja genau,
auf der ersten Seite ist noch gar keine Aufgabe.
Gut, ich glaube, es war bei Kerre auch so.
Aber der Text, den ihr jetzt hier auf der
ersten Seite seht, der ist ziemlich dicht.
Dass er so ziemlich viele Informationen drin. Und da sind
enorm viele neue Begriffe, die ihr vorher alle noch nicht gehört habt.
Ich kann einmal kurz so rüber ausgehen, ich werde jetzt
nicht alle erwischen. Also zum Beispiel Objekte, Methoden,
Parameter, Felder, Variablen, Objekttypen,
lokale Variablen,
primitive Typen deklarieren
Boah. Also das hört gar nicht mehr auf.
Signatur, formale Parameter, aktuelle Parameter, Rums, Literale.
Und wir erwarten von euch, wenn ihr in der Übung sitzt,
dass ihr irgendwie schon mal diesen Text gelesen habt und so
eine ungefähre Vorstellung davon habt, was diese Begriffe bedeuten.
Also wenn irgendwie die Betreuung mit euch reden werden, über das,
was ihr hier gemacht habt. Und die fragen euch zum Beispiel,
sag mal, wenn ihr mit der rechten Mast,
dass ihr hier unten auf so ein Objekt kriegt, was sieht man denn dann eigentlich?
Und dann wollen die nicht hören, ja,
da sieht man irgendwie so eine Liste von Dingen,
sondern ihr solltet schon sagen, zum Beispiel,
dass das die Schnittstelle ist und dass die Schnittstelle aus Methoden besteht und dass es Methoden gibt,
die formale Parameter haben, dass es Methoden gibt, keine Parameter haben.
Ihr sollt so ein bisschen erklären können, was dieses Void bedeutet.
Also die werden ab jetzt sehr viel strenger irgendwelche Begriffe abfragen,
weil die eben alle wichtig sind, wenn man Java lernen will.
Sonst wird es sehr schwierig, sinnvoll über Java zu diskutieren,
wenn man diese Begriffe alle nicht kann.
Okay. So, die erste Aufgabe ist, ihr sollt
ein eigenes Bild zeichnen und das könnt ihr gerne mal machen.
Genau. Und nachdem wir das jetzt mal so spielerisch erkundet habt,
also mit dem Klick auf eine Klasse, mit dem Rechts,
da kann ich ein Exemplar erzeugen und mit dem Rechtsblick auf ein Exemplar kann ich Methoden daran aufrufen,
dann wird das irgendwann langweilig.
Man macht das so 10 oder 15 Minuten,
hat dann irgendwie lustige Bilder gezeigt.
Wie sieht das gerade bei mir
aus?
Ja gut
Weiß nicht, was das sein könnte, irgendwas Abstraktes.
Aber wenn ich jetzt zum Beispiel mal das Projekt schließe und
dann wieder neu aufmache, ist mein Bild weg.
Das ist ja irgendwie ein bisschen schade. Also du wärst
doch irgendwie ganz nett. Wenn ich diese ganzen Sachen,
die ich hier so interaktiv anklicke,
ich mache mir einen Kreis und ich rufe da auch Methoden auf.
Dass man das irgendwie in einem Programm festhalten kann,
dass das passieren soll. Wie so ein Kochrezept oder wie
ein Carrit-Programm. Ich will erst mal so einen Kreis erzeugen,
dann würde ich dem Kreis sagen, mach dich sichtbar,
dann würde ich den Kreis sagen, änder deine Farbe,
dann würde ich im Kreis sagen, bewege dich nach rechts oder so.
Und das kann man eben in Java programmieren.
Und dafür gibt es zum Beispiel diese vorgegebene Klasse,
die heißt Zeichner.
Da gucken wir mal rein
Und das ist jetzt also das erste Mal,
dass ihr Java-Code seht, zumindest in dieser Veranstaltung.
Okay. Man sieht erstmal hier oben so einen schönen Kommentar,
diesen Kommentar kann man entweder jetzt so lesen in dieser Darstellungsform oder was man auch machen kann,
was ich immer sehr nett finde, ist,
man kann hier oben auf eine Dokumentationssicht klicken und dann wird die ganze Implementation ausgeblendet und man sieht nur noch die Kommentare.
Das ist irgendwie ganz nett, da wird man nicht belästigt
mit irgendwelchen Implementationsdetails, falls sie an dich interessieren.
Also wenn ich mich nur dafür interessiere, welchen Sinn hat die Klasse eigentlich,
ist die irgendwie interessant für mich, will ich die benutzen,
dann liest man meistens erstmal diesen Kommentar,
der über der Kasse steht.
Okay, dann dieses Schlüsselwort Klaas,
gefolgt vom Namen der Klasse, hattet ihr auch schon auf
den Folien gesehen
Und jetzt seht ihr eure erste eigene Methode.
Okay, das ist also eine Public-Methode. Das heißt,
die taucht an der Schnittstelle auf. Ein Klient kann sie
aufrufen. Sie liefert kein Ergebnis zurück. Das heißt,
die wird nur irgendwas machen, wahrscheinlich irgendwas zeichnen oder so.
Und das ist der Name. Zeichende Symbör, eine ganz einfache, simple Zeichnermethode.
Die könnt ihr aber im Prinzip nennen, wie ihr wollt.
Und man muss keine Parameter reinstecken. Das heißt,
ich kann sie einfach aufrufen und dann passiert was,
ohne dass ich noch sagen muss, 5 Euro oder gelb oder so.
Okay, dann sind wir hier erstmal vier Variablendeklarationen. Ich sage also,
ich brauche eine Variablen namens Sonne und der Typ ist Kreis.
Weil eine Sonne ist nun mal ein Kreis. Okay,
dann brauche ich noch eine Variable namens Wand vom Typen Quadrat,
eine Variablen namens Fenster von Typen Quadrat,
also beides Quadrate.
Und das Dach soll
ein Dreieck sein,
Und jetzt kommt all das, was ich vorher interaktiv
in Blu-ray gemacht habe, kommt jetzt in Java-Code.
Ich sage also hiermit, sage ich, ich brauche einen neuen Kreis.
Liebes Java-System, erzeug mir aber bitte einen neuen Kreis,
den will ich haben. Und damit ich anschließend irgendwas damit
machen kann, speichere ich den mal in der Variable Sonne.
Ihr werdet in ein paar Wochen merken,
das Objekt wird nicht direkt in der Variable gespeichert,
aber dieser Unterschied ist jetzt noch nicht so wichtig.
Wir tun jetzt mal so, als würde einfach das Objekt
in der Variable Sonne gespeichert werden.
Für den Anfang reicht das erst mit dieses Weltbild.
Okay, also so erzeuge ich ein Exemplar.
Und jetzt widerrufe ich jetzt die Methode auf,
hatte Guido euch auch schon gesagt,
also erstmal muss ich das Objekt beim Namen nennen,
mit dem ich reden will.
Ich will mit der Sonne reden
Okay, aber guck lieber nicht in die Sonne rein, das ist ungesund.
Dann kommt dieser Punkt. Und dann kommt die Methode,
die ich aufrufen will. Ich will die sichtbar machen, Methode aufrufen.
Okay. Und dann kommt in runden Klammern alle aktuellen Parameter,
die ich übergeben muss, damit diese Methode sichtbar machen,
was Sinnvolles tun kann.
Und die braucht eben keine Parameter. Ich muss nicht sagen,
sichtbar machen 5 Euro oder sichtbar machen gelb, sondern ich sage einfach,
mach dich sichtbar, du brauchst keine weiteren Informationen.
Trotzdem müsst ihr diese Klammern hinschreiben. Gerne wird das am Anfang vergessen,
Leute vergessen diese Klammern. Und dann sagt mir hoffentlich Blueget,
dass das unsinnig ist, not a statement. Tja,
also wenn ihr mal diese Fehler meldet,
sieht not a statement, dann könnt ihr das unter Umständen
daran liegen,
dass ihr
diese Klammern vergessen habt
Aber ich hoffe ja, dass durch eure Vorbildung mit Kerl,
wo ihr ja immer diese runden leeren Klammern schreiben musstet,
dass ihr euch mittlerweile daran gewöhnt habt,
dass es die Klammern da stehen müssen.
Und dass die Mikronern musste in Kerl ja auch immer geschrieben werden.
Was passiert, wenn ich das vergesse?
Das ist auch eine viel nettere Fehlerwendung, Semikonern expected.
Dann schreibe ich das dann mal wieder hin.
Gut. Und wie sieht das jetzt aus,
wenn ich mal tatsächlich einen aktuellen Parameter überleben muss,
zum Beispiel bei Farbe ändern, dann schreibe ich irgendwas in die Rundenklammern.
Und wir können jetzt hier mal genau denselben blöden Fehler machen,
den ich vorher gemacht habe. Was passiert,
wenn ich hier zum Beispiel die Gänsefüßchen vergesse oder die Anführungszeichen halt sozusagen eigentlich,
dann müsstet ihr mir sowas ähnliches sagen,
irgendwie so Unknown-Symbol oder Anti-Kletschimbel
oder so
Genau, also er glaubt, dass es irgendwo eine Variable rot gibt.
Also er schaut jetzt hier irgendwie in dieser Liste in der Variable,
dann gibt es hier eine Variable, die rot heißt.
Nee, gibt es nicht. Okay, was passiert,
wenn ich den Parameter komplett vergesse?
Ich will die Farbe ändern. Mir egal, welche das
ist. Mal gucken, was dann der Compiler sagt.
Okay, da kommt schon eine längere Fehlermeldung.
Okay, Method-Farbe ändern in Glaskreis, cannot be applied to
given types. Das ist dann ein Typ-Fehler.
Irgendwas stimmt da mit den Typen nicht,
irgendwas war mit Zahlen oder Strings und ich habe da irgendwie Unsinn gemacht.
Okay, er sagt mir also, ich brauche einen String.
Das können wir uns noch mal ganz kurz angucken,
wenn ich Farbe ändern auf so einem Objekt aufrufe
Farbe ändern, da ist es, dann seht ihr,
ich muss einen String übergeben. Das sagt mir diese Fehlermeldung.
Du musst einen String übergeben. Und was habe ich stattdessen
gefunden? Nix. Das ist irgendwie blöd, ne?
Okay, Actual and Formel, Argumentless differ in längs.
Also ich habe null Parameter übergeben, ich hätte aber eigentlich einen übergeben müssen.
Okay, dann übergebe ich mal 42. Oh, geht immer
noch nicht. Er hat einen String erwartet und stattdessen
habe ich einen Int-Übergeben. Und dann sagte er sogar,
ich kann aus einem Int nicht einfach so einen String machen.
Tja. Was war es denn ursprünglich mal? Ich glaube,
gelb, oder? So. Es war rot. Ja gut,
das, guck mal, das erkennt ja Compiler gar nicht.
Eigentlich müsste er zur Fehlermeldung kommen. Die Sonne muss rot
sein. Nein, nein, das versteht Java natürlich nicht
, ne
Gut. Okay, hier habe ich ja so einen String übergeben,
hier kann ich Inns übergeben, Inns können auch negativ sein.
Okay, und das ist jetzt dasselbe in Grün beziehungsweise gelb,
das ist dasselbe in Blau und das ist dasselbe ohne Farbe.
Gibt es bis hierhin erstmal Fragen, wie ich in Java,
das, was ich vorher mit Mausklicks und Blu-ray interaktiv zusammengeklickt habe,
in Quelltext festhalten kann?
Ja, man da schon irgendwelche groben Fehler,
wir gehen sozusagen, mit wem man sich irgendwas zerhackt oder so,
da bringt er erstmal alles.
Also in Java ist es ziemlich schwierig, sich irgendwie einen Fuß abzuschießen oder so.
Also irgendwie, dass das System abstürzt oder irgendwie,
das ist nach, das hat glaube ich noch keinen Anfänger
bis jetzt geschafft
Aber mal gucken, vielleicht kommt das ja noch.
Also man kann ja eigentlich nicht großartig was Schlimmes falsch machen.
Also ihr könnt auch keine Objekte frühzeitig löschen oder so.
Das wird ja alles von Java automatisch gemacht. Wir haben
das noch gar nicht ausgeführt, fällt mir gerade auf.
Wir können das mal ausführen. Ich will jetzt also quasi,
dass diese ganze Methode einmal ausgeführt wird.
Wie mache ich das denn? Ich will dieses Zeichen
simpel ausführen. Wenn ich auf die Klasse Zeichen erklicke,
taucht hier nirgendwo auf, zeichne simpel.
Warum denn nicht? Ja. Wenn man erst ein Objekt zeichnet.
Wir müssen erstmal ein Objekt erzeugen. Sehr schön, machen
wir das. Das heißt, es ist mir egal.
Und jetzt müsste an der Schnittstelle dieses Objekts dieses Zeichens
simpel auftauchen.
Da ist es
Wahnsinn. Dann klicke ich das doch jetzt mal an.
Und dann seht ihr das, ihr habt vielleicht sogar gesehen,
dass ihr tatsächlich diese ganzen Methoden aufgerufen wurden und dass
sich hier das so zusammengeklickt hat, oder?
Ich versuche das nochmal kurz neu. Nochmal ein neuer Zeug,
da kann man das wirklich sehen oder ist es dafür zu schnell?
Naja, das sieht man tatsächlich ganz gut. Es wird also
genau wie bei Kerry ganz stumpf von oben nach unten abgearbeitet.
Nicht irgendwie gleichzeitig oder irgendwie intelligenter oder so. Ganz normaler Code,
der Sequenz wäre von oben nach unten abgearbeitet wird.
Okay. Jetzt ist es so, ich habe keine große,
besonders große Schriftart bei mir in Blu-Jay eingestellt.
Ich habe Glück, der Text passt so gerade noch auf
einen Bildschirm
Wir haben ja schon bei Carol gelernt, naja,
allzu lange sollten eure Methoden nicht sein.
Also wir haben hier irgendwie so ein bisschen Quelltext,
der kümmert sich um die Sonne, hier so ein bisschen Quelltext,
der kümmert sich um die Wand.
Hier so ein bisschen Quelltext, der sich ums Fenster kümmert.
Und diese paar Zeilen kümmern sich um das Dach.
Warum stehen die alle in derselben Methode? Das war irgendwie hässlich
, oder? Wäre es nicht sinnvoll, jetzt irgendwas zu tun?
Ja. Du bist noch nicht jemand, der wohnt da beschlagen.
Wir wissen noch nicht, wie man Unterprogramme schreibt.
Richtig. Also es ist so ähnlich wie ein Kerl.
Und man weiß ja immer nicht, ob ihr diese ganze
Lektion aus Carol jetzt noch nach so langer Zeit im Kopf habt.
Wir haben euch mal so ein kleines Beispiel gezeigt.
Wir haben mal angefangen, diese Methode aufzuteilen
Ich habe also den Code für die Sonne genommen, quasi dieser Code.
Und habt ihr für eine eigene Methode geschrieben.
Zeichne Sonne. Wo ist denn diese Methode? Ah,
hier ist sie. Ich sehe, das ist so
fast eins zu eins derselbe Code, der oben stand.
Ich habe ihn in eine eigene Methode gepackt, die ist jetzt privat.
Was bedeutet das, wenn eine Methode privat ist?
Welchen Effekt hat? Das ist ja vielleicht nochmal irgendjemand anderes,
du? Sie kann nur innerhalb der Klasse aufgerufen werden,
genau, und das tun wir ja tatsächlich.
Hier. Also ein Klient von außen kann nicht sagen,
hey, lieber Zeichner, zeichner mal eine Sonne,
das geht nicht,
der sieht ja nur
öffentliche Methoden
Und das ist eigentlich fast immer so,
dass man solche Hilfsmethoden, die man hauptsächlich deswegen macht,
weil der Code sonst irgendwie zu lang wäre von einer Methode,
dass man die gerne privat macht.
Ich will den Klienten gar nicht damit belästigen,
dass ich mich so entschieden habe, das in Untermethoden aufzuteilen.
Den interessiert nur die allgemeine Zeichnermethode. Okay. Jo,
das Einzige, was hier noch anders ist, ist,
das muss ich auch noch mal kurz zeigen,
wir haben hier oben in einer Zeile eine Variable deklariert.
Das ist eine Variableintegration. Typ der Variable, Name der Variable,
das sieht in Shava immer so aus, fast ohne Ausnahmen.
Okay, und in dieser Zeile habe ich ein Objekt erzeugt und dieses Objekt,
in diese Variable reingestopft, das sieht man hier.
Und ich habe jetzt diese beiden Zeilen einfach mal in
eine Zeile zusammengefasst
Ich kann also direkt sagen, ich will eine Variable deklarieren vom Typ Kreis,
ich nenne sie Sonne und ich initialisiere sie mit einem neuen Kreis.
Dann brauche ich das nicht hin, zwei Separatezahlen schreiben.
Kann man also machen. Okay, und der Rest ist exakt der Säbel.
Das ist also, sage ich mal, noch auf Carol-Niveau.
Ich nehme einfach Codezahlen, tue sie in eine Hilfsmethode und
rufe diese Hilfsmethode irgendwo auf. Stellt euch einfach vor,
hier würde ich den Move toball, das würde euch überhaupt nicht irritieren.
Das würdet ihr sofort verstehen, würdet ihr sagen,
alles klar, wo ist denn dieses Move toball aus,
ist ja hier, das führt Carol aus,
wenn ich sage Move toball.
Jetzt kommen wir aber zu dieser Sache mit den Parametern.
Das ist immer etwas, was den Studenten klassisch
sehr viele Probleme am Anfang bereitet.
Deswegen haben wir dafür auch mal
ein Beispiel gebaut
Okay, also dieses Zeichnen strukturiert, nimmt im Gegensatz zum
Zeichen simpel, wo ihr die Parameterliste leer war,
nimmt es einen formalen Parameter entgegen.
Ich sage also dem Klienten, lieber Klient,
wenn du mich benutzen willst, musst du mir einen String übergeben.
Und was ist der Sinn dieses Strings, es soll die Wandfarbe sein?
Also sag doch mal gelb oder grün oder rot oder was auch immer.
Das kannst du dir jetzt querend überlegen, welche Wandfarbe du haben willst.
Okay, was mache ich denn jetzt mit dieser Wandfarbe?
Diese Wandfarbe taucht hier wieder auf, wo ich meine zweite Hilfsmethode aufrufe.
Also ich habe das Zeichen der Wand,
habe ich jetzt mal eine Hilfsmethode getan und ich wollte irgendwie,
dass man die Wandfarbe interaktiv begeben kann
Ist das Zeichen der Band, das seht ihr hier,
ihr passt auch noch auf denselben Bildschirm, das ist ja spannend.
Ihr seht also, das Zeichen, wann zieht recht ähnlich aus.
Es sagt hier an dieser Stelle, zeichne Wand,
kann man nur aufrufen, wenn man einen String übergibt.
Übergeben wir einen String beim Aufruf?
Ja. Denn Wandfarbe ist ja hier dieser String.
Der wird hier einfach nur so durchgereicht, sozusagen.
Okay. Und was machen wir jetzt intern mit diesem String Farbe?
Sieht das irgendjemand? In welcher Zeilennummer wird das benutzt?
Ruft es einfach in den Raum. 98, ne?
Richtig, hier. Das ist ja spannend. Also,
wenn ich jetzt zum Beispiel sage,
ich will das Zeichen strukturiert aufrufen und ich übergebe zum Beispiel
rot,
dann hat Wandfarbe
den Wert rot
Okay, was mache ich jetzt mit diesem Rot?
Ich rufe zeichne Wand auf und übergebe dieses Rot. Okay,
das heißt also, dieser formale Paar mit der Farbe ist jetzt auch rot.
Okay, und was mache ich jetzt mit diesem Rot?
Das wird hier wieder weitergereicht. Ich rufe mir das Farbe
ändern an der Wand auf und dann hat der Parameter dann wieder den Wert rot.
Es gibt jetzt also schon drei Parameter, die den Wert rot haben.
Einmal der Parameter von Zeichen strukturiert. Einmal der Fahrrameter von
Zeichenwand und einmal der Parameter von Farbe ändern.
Wir können ja mal gucken, wie der heißt.
Ich weiß es gar nicht auswendig und es ist auch,
glaube ich, egal.
Wenn ich die Farbe von etwas ändern will,
wie heißt dann der Parameter?
Neue Farbe oder einfach eine Farbe
Ah, das ist tatsächlich neue Farbe.
Da würde ich das Rot dann einfach nur durchreichen.
Und dieses Durchreichen von Parametern, das ist nicht ganz so trivial.
Also habt ihr dazu irgendwelche Fragen? Pommes lang ausprobieren sonst.
Also du hast eine Frage, die ist wahrscheinlich wieder fortgeschritten.
Vielleicht. Gleich wirst du das sicherlich. Alle unter Programme
vereinheitlicht sein, wie da. Das werde ich nicht machen,
weil die doch alle immer so ein bisschen anders sind.
Also hier wird zum Beispiel die Farbe geändert hier nicht.
Diese ganzen Zahlen sind anders. Man könnte das bestimmt
irgendwie vereinheitlichen. Aber das ist mir jetzt zu fortgeschritten,
das will ich jetzt nicht machen.
Das kannst du gerne mal zu Hause ausprobieren
Was wir mal versuchen könnten, ist,
in Carol sieht man ja immer so schön,
wie irgendwas Zeile für Zeile ausgeführt wird.
Das kann man in Blue Jay ja auch machen.
Ich versuche das jetzt einfach mal. Ich klicke hier mal hin.
Dann erscheint da so ein Stockzeichen. Und dieses Stockzeichen sagt,
wenn der Kontrollfluss in dieser Zeile ankommt,
ab dann will ich es so schön durchsteppen.
Ich habe das ewig nicht gemacht in Blue Jay.
Ich hoffe mal, das funktioniert noch.
Also ich mache mir jetzt mal diesen Zeichnungen.
Und rufe jetzt mal dieses Zeichen strukturiert auf.
Ihr erinnert euch, als ich Zeichen simpel gesagt habe,
kam sofort dieses Bild, was gezeichnet wurde.
Das kann jetzt unmöglich passieren, denn ich muss mich
jetzt ja erstmal für einen Parameter für die Wandfarbe entscheiden.
Welche wollen wir nehmen
Lila, ich weiß gar nicht, ob das unterstützt wird.
Sondern ich hoffe jetzt, dass der kontrollflos anhält.
Mal gucken. Ah, Tatsache. Das hat also funktioniert.
Wir stehen jetzt also hier im Programm. Okay. Und ihr seht jetzt,
dass Parameter hier unter lokalen Variablen geführt werden,
das ist schon ein kleines Implementationsdetail vom Bujer,
lasst euch davon bitte nicht irritieren.
Ihr seht jetzt, dass dieser Parameter Wandfarbe den Wert lila hat,
weil ich habe den ja reingestopft als Klient.
Ich habe ja beim Aufruf gesagt, welchen Parameter will ich haben, lila.
Okay, also hat jetzt diese variable Wandfarbe, hat jetzt den Wert.
Lila, das ist doch schön. So, zeichne Sonne
. Da mache ich jetzt mal ein Ich vermute mal,
dass das das Step... Nee, das ist nicht das Step-Over.
Ich glaube, ein Step-Over gibt es hier gar nicht.
Vielleicht ist das das Step-Over. Okay. Sehr schön.
Er hat die Sonne komplett gezeichnet. Da wollte ich auch
gar nicht reingehen. Ich will ja in das Zeichen eine Wand reingehen.
Das ist wahrscheinlich das Step-Into. Das heißt ja zum Glück
genauso wie Kerl. Jetzt gehen wir da mal rein.
Und was müsste jetzt passieren? Jetzt müsste ja diese Wandfarbe
in unserem Fall, also das lila,
müsste jetzt ja der Wert sein für dieses Farbe.
Schauen wir doch mal, ob das passiert,
wenn ich da reinsteppe. Tatsache, seht ihr das?
Farbe hat jetzt auch den Wert lila. Weil ich ja
wirklich aktiv dieses Lieder reingestopft habe in diesen Parameterfarbe.
Okay. So, und dann würde ich gerne nochmal
In dieses Farbe ändern, reinsteppen. Das heißt,
das übersteppe ich jetzt mal. Ihr seht diese Wandvariable,
sieht man jetzt hier auch, das sichtbar machen kann, auch gerne machen.
Und wenn ich jetzt mal in das Farbe in deine reinsteppe, das ist Code,
den wir gar nicht selber geschrieben haben, dann müsstet ihr sehen,
dass dieses lila dann der Wert von dem Parameter neue Farbe ist.
Ich springe da jetzt mal rein. Seht ihr das?
Neue Farbe ist jetzt auch Lieder. Und das ist jetzt
ganz viel quältiges, den ihr gar nicht verstehen könnt,
weil da schon ganz viel Zeug ist,
was wir gar nicht kennen.
Okay. Jo. Haben wir eine Lieder, eine Wand?
Das ist doch nett. Gut. Also,
noch Fragen dazu, wie man Parameter in Blue Jay übergibt
Keine Fragen? Ja, das ist eine Frage.
Aber man muss die erste Licht bauen, ich weiß
gar nicht, was du mir jetzt mal ausgezahlt hast.
Also du fändest es irgendwie logischer, das sichtbare auch noch
am Ende zu machen, dann sieht man hier nicht diese Gezucke.
Ja. Ja, eigentlich keine schlechte Idee. Ja,
guter Vorschlag, finde ich gut. Aber ich ändere das
jetzt nicht. Okay, noch was, ja?
Mehrere Parameter. Ja, das könnte man machen.
Also wir können ja einfach mal so tun,
als würden wir zum Beispiel bei Zeichen der Sonne,
da gibt es ja zum Beispiel
Das hier ist ja so eine Art Positionsangabe. Das ist so
eine Art X-Position, das ist so eine Art Y-Position.
Wir könnten das jetzt so programmieren, dass man die auch übergeben kann.
Das können wir mal machen. Also ich sage,
ich will zwei formale Parameter haben für die X-Position und für die X-Position jeweils ein.
Dann mache ich das doch mal. Also erstmal muss man
den Typ hinschreiben. Dann, wie das Ding heizt.
Komma, vom Halle Parameter werden wir Kommator getrennt und dann
die Y-Position soll auch übergeben werden.
Und dann ersetze ich hier entsprechend die konkreten Werte durch dieses Parameter.
Also Ex-Position und Y-Position. Und wenn ich jetzt versuche,
den Code zu übersetzen, dann müsste es knallen an
dieser Stelle.
Warum müsste es jetzt
hier knallen
Immer dieselben Leute, die sich sofort melden.
Eigentlich müssen das so jetzt alle wissen, ja. Richtig,
es fehlen ja einfach die aktuellen Parameter. Also zeichne Sonne,
definiert zwei formale Parameter. Das sind einfach so Platzhalter,
hey, bitte stopp hier irgendwann mal Zahlen rein.
Und hier fehlen einfach die entsprechenden aktuellen Parameter. Jetzt kann ich mir hier entscheiden,
die Sonne soll sein, weil ich weiß gar nicht mehr,
was die Wette war, nehmen wir einfach mal 250.
Wahrscheinlich ist das jetzt eher so ein Sonnenuntergang.
Es war vorher minus 10. Das heißt,
die Sonne müsste jetzt deutlich tiefer unten stehen.
Dann schauen wir doch mal,
wie jetzt
das Bild aussieht
Die Wandfarbe kann von mir aus wieder gelb sein,
das finde ich ganz geil.
Ja. Jetzt ist die Sonne ein bisschen weiter unten,
ne? Jetzt konnte ich aber gar nicht an dieser Stelle
den Parameter übergeben. Ich konnte hier nur die Wandfarbe übergeben.
Wie könnte ich das denn erreichen, dass ich auch tatsächlich
die Position der Sonne noch hier übergeben kann?
Was müsste ich dafür ändern? Hat das schon so oft
? Du hattest, glaube ich, noch nichts heute?
Ja, das muss man
wahrscheinlich wieder sagen
Kannst du mir mal ganz konkret sagen,
in welcher Zeile ich jetzt was ändern muss im Quelltext?
In Zeile 64, weil momentan sagt ja die Zeile 64 aus,
wenn ein Klient, die Methode zeichnet strukturiert Aufruf,
muss er ein Stringen übergeben, mehr nicht.
Wenn ich jetzt will, dass er noch weitere Informationen übergeben
muss, dann muss ich das so hinschreiben.
Also ein weiterer formaler Parameter, nennen wir den vielleicht Sonne
X und noch im dritten Parameter Sonne Plups, Sonne Y.
Und was mache ich jetzt mit diesen Parametern?
Momentan werden die ja völlig ignoriert. Ich mache ja gar
nichts mit denen, ja. Wir sind jetzt in Zeile
37.30 Uhr, äh, 67,
bei mir von Welt
Zeichne Sonne hier. Richtig. Ich will mich
ja nicht hier an dieser Stelle schon festlegen,
dass die Sonnenposition von 250 sein soll,
sondern ich will die Werte nehmen, die mir von außen reingesteckt wurden.
So, ups, habe ich mich vertippt. Okay.
Schauen wir noch mal kurz, ob das jetzt noch funktioniert.
Seht ihr? Jetzt muss ich nicht nur die Wandfarbe übergeben,
sondern auch ein Int für seine X und den für Sonne Y.
Und das wollte ich ja. Okay. Und ihr seht,
jetzt ist dieser Dialog einfach ein bisschen größer,
also Wandfarbe von mir aus, vielleicht mal zur Abwechslung blau.
Sonne vielleicht mal ein bisschen weiter links im Bild,
sagen wir mal, keine Ahnung, 20 und dann hier wieder,
weiß ich, 150, dann ist sie noch weiter unten.
Ja, da ist die Sonne jetzt.
Ja. Auch in die Wand hat dieselbe Farbe dieses Fenster,
das ist ja auch ein bisschen blöd künstlerisch, ne?
Sieht fast aus wie so ein Haus mit Rädern.
Okay. Okay, und was ich euch auch noch zeigen wollte,
ist folgendes. Diese Wandfarbe, die hier definiert ist,
hat hier so einen schönen Kommentar. Ja,
es gibt also so eine Besonderheit in solchen Kommentaren,
man kann Parameter nochmal eigens dokumentieren. Das Format ist folgendes,
erst kommt so ein Klammeraffe, dann kommt das spezielle Wort Para für Parameter,
dann kommt der Name des Parameters und dann kommt eine deutsche Beschreibung dieses Parameters.
Ich zeige euch das mal ganz kurz
In dieser schönen Dokumentationsansicht. Für Zeichne strukturiert. Seht ihr das hier?
Hier gibt es also eine eigene Sektion für die Parameter,
wo jetzt hier gesagt wird, Wandfarbe, da wird hier
so ein Minuszeichen generiert und das ist so ein schöner Code-Found.
Die Farbe der Wand, zum Beispiel gelbe oder grün. Und ich würde gerne,
dass wir das für diese beiden anderen Parameter auch dahin schreiben,
also zum Beispiel Sonne X, die X-Position der Sonne,
falls das vielleicht nicht aus dem Namen so 100 Prozent
klar wird und Sonne Y ist die Y-Position der Sonne.
Da sage ich noch, in Pixeln. Und wenn man das macht,
Und wieder auf diese Dokumentationsansicht zurückschaltet, dann muss man das jetzt hoffentlich sehen.
Ja, genau, seht ihr das jetzt hier?
Hier ist jetzt also nicht nur die Wandfarbe dokumentiert,
sondern auch, was so eine X bedeutet,
nämlich der Text, den wir da hingeschrieben haben.
Und was Sonne Y bedeutet. Und das solltet ihr eigentlich immer machen,
also für öffentliche Methoden müsst ihr es auf jeden Fall machen.
Sonst hat ein Client möglicherweise Schwierigkeiten zu verstehen,
welchen Sinn haben diese Parameter, was sind da gültige Werte?
Vielleicht hätte ich auch noch sagen sollen, vielleicht nicht
so sinnvoll, da negative Zahlen zu übergeben oder so.
Also Dokumentation ist ziemlich wichtig, sobald mehr als ein Programmierer an einem Quelltext arbeitet.
Ja. Für die Gartendarstellung, wie ist das entschieden sozusagen,
was da unser Nein. Ich glaube, die geometrische Figur,
die du als letztes änderst, liegt immer ganz oben.
Das ist so ein Last Come, First, ist egal.
Also das, was uns letztes ändert, ist immer ganz oben,
ja. Okay, gibt es sonst noch Fragen?
Sonst ist es jetzt schon wieder Viertel vor.
Eine Frage ist noch da. Ich glaube,
du musst deine Frage gleich privat mehr bestellen.
Ich verstehe gar nichts mehr.
Wir sehen uns nächste Woche.
Vielen Dank