Ja, hallo zum, herzlich willkommen zum zweiten Tutorium.
Letzte Woche war es sehr einsam. Heute ist es kuschelig. Genau. So,
jetzt noch mal kurz vom letzten Mal die Orga-Folie,
vielleicht für die, die es interessiert,
weil fast ja niemand da war gestern, letztes Mal.
Genau. Es wird tatsächlich jeden Mittwoch während des Semesters,
ein Tutorium geben. Weil es jeder so beteiligt hat.
Also ich meine, ich habe kein Problem damit
Mal schauen. Genau. Also an jeden Nicht-Feiertag im Semester,
wo regulär Universität ist, gibt es das Tutorium. Genau,
es wird, da kümmere ich mich gerade noch drum,
höchstwahrscheinlich ein sogenanntes Repetitorium vor der Klausur geben.
Vom Erstversuch und vom Verzweifelversuch. Ich weiß nur noch nicht
, wie lange die jeweils sein werden.
Also wahrscheinlich wird es dann so einen Vier-Stunden-Slot mit einer Pause zwischendrin,
damit wir den Stoff auch irgendwie durchkriegen.
Genau. Ja, ich bin Michael Stressberger
Falls ihr das noch nicht gewusstet. Und ich habe so
eine E-Mail-Adresse. Wenn ihr Fragen habt,
dann könnt ihr mir an diese E-Mail-Adresse diese Fragen stellen.
Und wenn das Fragen sind, wo ich glaube,
dass das mehr als zwei Leuten die Antwort interessiert,
dann werdet ihr auf dem darunter liegenden Link-Webseite,
werdet ihr dann die Antwort darauf finden.
Das heißt, da gibt es doch halt so eine
schöne Webseite, da wird alles hochgeladen.
Sämtliche Slide, sämtliche PDFs, die ich mache.
Die Links zu Lexure to Go
Also das Ganze wird ja auch aufgezeichnet,
falls ihr aus gesundheitlichen Gründen mal nicht teilnehmen könnt,
dass ihr trotzdem die Chance dazu habt.
Genau. Programmcodes und alles, was wir hier machen,
wird dort alles landen. Das heißt, im Umkehrschluss für euch,
ihr müsst euch nur das in euren neuen Notizen ausschreiben,
was euch interessiert.
Das heißt, ihr müsst jetzt nicht irgendwie anfangen,
programmen, Java-Programmcode abzuschreiben, weil das macht den wenigsten Spaß.
Genau. Gibt es erstmal dahin Fragen zum Organisatorischen noch
Okay, ich sehe da, da werden noch ein paar Fotos gemacht.
Genau. Also ihr findet auf der Webseite eigentlich so gut
wie alles. Ihr findet da sogar auch noch so
ein paar vereinzelte Materialien aus den vorhergegangenen Durchgang,
der leider nicht ganz so durchgehend gemacht worden ist.
Aber das sind auch eventuell noch interessante Sachen für euch.
Gut. Genau. Für euch nochmal so ein bisschen Delecture
to Go ist noch nicht hochgeladen von letzter Woche,
aber damit ihr schon mal so wisst, worum es letzte Woche ging.
Das heißt, letzte Woche haben wir einen kurzen Roundup gemacht.
Was sollte die eigentlich aus SE1 alles hättet mitnehmen sollen
Ja, das heißt, da habe ich noch mal drüber gesprochen,
was kam an ich dran,
was ist interessant, was sollte man für SE2 mitnehmen?
Das waren dann hier so diese drei Sachen,
die wir dann hier besprochen hatten. Und das werdet ihr
höchstwahrscheinlich im Laufe des Donnerstags auf Lecture to Go finden,
die Aufnahme. Und wahrscheinlich die Aufnahme von heute auch.
Genau. Okay, das kommen wir, glaube ich,
zum eher schöneren Foliensatz.
Genau,
die Vorbereitung ist fast Programmierdiktat
Die Folien sind recht stark komprimiert, aber ihr könnt sie
auch wunderbar benutzen, um... Kann ich dir helfen?
Okay. Er ist übrigens mein Betreuer gewesen, als ich ersten war.
Das weiß ich nicht, ich kann das irgendwie nicht verantworten.
Fuck. Okay. Gut. Genau, also. Dann
... Genau, die Folien sind so aufgebaut,
dass ich immer so beispielhaft in einem Satz beschrieben habe,
wieso vielleicht so ein Diktatsatz aussehen könnte
Für das jeweilige Thema und dann, wie man
das umsetzen würde im Java sind tags. Das heißt,
wenn wir uns das jetzt einfach mal zum Beispiel angucken,
wie definiere ich eigentlich so eine Klasse und so ein Interface?
Dann haben wir, dann schauen wir uns das halt immer so an,
okay, wir haben halt immer eine, wie man das sieht,
sehr schön sehen kann.
Haben wir halt immer hier, darf ich, genau.
Okay, haben halt immer hier dieses Keyword Class
Das steht da halt, das muss,
dass es sozusagen, das musst du dort immer stehen,
wenn er steht, definieren sie eine Klasse.
Dann haben wir hier unseren Bezeichner und das Ganze zusammen,
davon spricht man meistens auch immer von dem sogenannten Klassenkopf.
Ja, und alles, was dann in den geschweiften Klammern folgt, ist der Klassenrumpf.
Das heißt, mit diesen Wörtern, mit diesen,
sage ich mal, Begrifflichkeiten wird dann auch gerne mal in die Taten rumgespielt.
Das heißt, ihr solltet schon verstanden haben, Was Klassenkopf,
was Klassenrumpf ist oder wenn wir uns jetzt hier zum Beispiel die nächste Folge angucken,
was ist der, was ist der Interface-Kopf,
was ist der Interface-Rumpf, aber es kommt,
baut halt alles auf einen ähnlichen Prinzip auf.
Das ist halt immer dasselbe Muster. Und das Einzige,
was du halt beim Interface anders ist,
wir haben halt hier das Keyword, ja,
wunderschön durchstreichen, das Keyword-Interface, was immer,
was zwangsläufig immer davor stehen muss und dann wieder unseren Bezeichner.
Was ihr jetzt vielleicht schon aus dem Übungsbetrieb so ein bisschen gesehen habt,
ist, dass eventuell hier vor,
Klaas und The Face noch irgendwas stehe zum Beispiel,
Public, Private, Was gibt es noch projected?
Also es gibt da halt noch so die sogenannten Sichtbarkeitsmodifikatoren, die halt interessant sind.
Aber die sind halt nicht zwingend. Also das heißt,
ich kann eine Klasse definieren, ohne vorher zu sagen,
ob es Public Private oder sonst eine,
irgendwas von diesen Sichtbarkeitsmultipfähigkeit so an ist.
Genau. Und ah, genau, das habe ich vergessen zu sagen.
Falls ihr Fragen habt, einfach direkt rein. Ja?
Wenn man nichts angeht, gibt es da eine Lieferweltwerte?
Hast du da seine Marken abnehmen lassen? Ja,
es gibt ein Default, aber das ist nicht,
das ist kein, das ist nicht Public,
sondern das ist eine Mischung aus Private und Public
Hattet ihr, ihr müsstet, glaube ich,
jetzt schon Packages gehabt haben in der Vorlesung.
Hatten sie noch nicht, okay. Okay. Genau,
also in Woche 5, da geht es dann noch,
wird man dann irgendwann sein Java-Projekt in kleinere Teil-Pakete,
was halt von Package schon kommt, zusammenfassen können.
Und dieser Default-Sichtbarkeit heißt dann nichts anderes als,
es ist Public in diesem Packpete.
Das heißt, aber mehr braucht jetzt erstmal dazu,
noch nicht zu wissen, das wird dann halt in Woche
5 alles kommen
Das heißt, das ist jetzt für das Programmierdigital erstmal
vollkommen irrelevant, wieder die Frau als Sichtbarkeit aussieht.
Okay. Gut. Und dann habt ihr ja auch schon aus SE1 kennengelernt,
dass man ja zwischen Interfaces und Klassen eine gewisse Beziehung herstellen kann.
Und wenn wir jetzt uns zum Beispiel anschauen könntest und Diktat
direkt als allerersten Satz heißen, deklarieren sie doch immer die Klasse Buch,
welche das Interface Medium implementiert.
Wer hat da jetzt ad hoc direkt die Idee,
wie das denn aussehen würde
Ja. Das wäre dann ein Glas Buch, Intimentsmedium.
Jemand Einwender? Nee, okay, wunderbar, genau.
Das würde dann halt folgendermaßen aussehen. Das heißt,
wir haben hier wieder, wir haben es halt hier wieder mit,
wir haben hier, ich möchte gerne Notizen hinzufügen.
Dankeschön. Wir haben hier wieder unsere, unser Keyword Class.
Das kommt halt daher, weil wir hier Glas benutzen,
weil wir sagen, okay, es soll klasse sein.
Darf ich
auch andere Firmen benutzen
Ah, und aber, ja, und dann habe ich halt hier mein Bezeichnerbuch.
Und dann geht's. Und dann hier durch dieses Interface implementiert,
diese beiden Wörter sagen halt einfach nur aus, okay,
ich muss dann hinter meiner Klassendefinition im Klassenkopf dieses Implements
reinpacken und dann halt zum Schluss natürlich noch,
um welches Interface handelt es sich,
um das Interface-Medium
Ja. Das heißt, es schadet vielleicht auch nicht,
wenn ihr so ein bisschen Probleme damit erstmal habt,
wenn ihr das direkt programmierlich habt, merkt,
euch sollt diese ganzen wichtigen Begriffe,
diese wichtigen Keywords vielleicht zu unterstreichen und an euch das Scheinen vielleicht daraus aufbauen zu können.
Das sehen wir überhaupt erstmal versteht, was will dieser Satz eigentlich gerade von mir.
Okay. Und dann das nächste Wichtige, was so häufig
im Programmierdiktat vorkommt, ist, erstmal grundsätzlich die variablen Deklaration
Wie würde ich das denn jetzt bei dem Satz, was da stehen, machen?
Also deklariere ein Variable mit dem Bezeichner Nummer und dem primitiven Typen Intager.
Wer kann das übersetzen? Keine Angst, es gibt keine
falschen Antworten. Es gibt nur wenige richtige Antworten,
die wir dann gemeinsam korrigieren, aber ist nicht schlimm?
Ja. Weil warum einfach nur in die Nummer, das kommt jetzt daher,
weil wir Weil wir hier jetzt noch nicht gesagt haben,
okay, in welchem Kontext befinden wir uns eigentlich.
Das heißt, da werden wir auch gleich auf jeden Fall
drauf fangen, wenn Folien drauf kommt.
Also je nachdem, wo ich diese variablen Degeneration mache,
heißt das Ding dann halt auch entsprechend ein bisschen anders.
Und wie initialisiere ich beispielsweise so eine Variable dann?
Ja. Dann würden einfach gleich, und wenn nehmen,
einen Wert. Also man kann entweder, ja,
wichtig ist, man kann dieses Intereer, das kann man auch
Das kann man weglassen. Und zwar,
es geht darum, ich kann einerseits,
wie es halt in der ersten Zeile jetzt hier ist,
sagen, okay, ich mache die Variablen-Deklaration und dann im nächsten,
in der nächsten Zeile mache ich die Initialisierung.
Und die Initialisierung ist eigentlich nichts anderes, als dass ich sage,
die Initialisierung passiert einer Variable, passiert genau da,
wo ich das allererste Mal ihr einen Wert zuweise.
Das heißt, die Initialisierung und das Zuweisen von Werten zu Variablen
sind taktisch dasselbe
Nur, dass es halt beim Initialisieren halt darum geht,
dass es das erste Mal, dass ich überhaupt einen Wert hinzuführe.
Und wenn wir uns das,
und man kann natürlich auch beides zusammen machen, das ist,
wenn ich jetzt... Soll ich das direkt machen wohnen?
Aber das heißt, wenn ich jetzt beides zusammen mache,
dann sieht das folgende außen aus. Ich kann halt auch einfach
direkt Variablen, Seklaration und die Industrialisierung in eine Zeile reinschreiben.
Das ist dann halt alles immer sozusagen nach Geschmack dahin.
Wir dürfen aber noch nicht den Nummern dann nochmal in den
43, 43 letztendlich stehen haben.
Da wäre das, würde es uns keinen Fehler geben.
Doch, das würde einen Fehler geben. Also ihr dürft nicht,
also ihr dürft entweder das, was gelb unterstrichen ist, machen.
Das heißt, ihr seklariert erst mit ins Nummer und
dann in irgendeiner nachfolgenden Zeit Nummer gleich 42. Oder das,
was orange unterstrichen ist. Das heißt, ins Nummer gleich 42.
Weil ansonsten sagt euch nämlich der Compiler, okay,
ihr versucht da jetzt gerade eine Variable neu zu seklarieren.
Was ein bisschen fies und gemein ist,
der Compiler kann in manchen Momenten
das sogar zulassen
Und zwar, genau, es kann, lässt es genau dann zu,
wenn ich zum Beispiel sage, also wenn jetzt zum Beispiel,
da habe ich mir eine Frage, genau.
Ja, wenn ich jetzt zum Beispiel das irgendwie so habe,
ich habe hier ein Inch und dann Nummer.
Und wenn ich jetzt irgendwo im Code solche geschweiften Klammern habe
und damit eine neue, sozusagen einen neuen Sichtbarkeitsbereich aufmache,
der dann halt irgendwann hier wieder endet,
dann kann ich in diesem neuen Sichtbarkeitsbereich
diesen Variablen bezeichnen,
Vergeben. Und was dann passiert ist, dass nachdem ich
diese Zeile hier geschrieben habe, in Nummer gleich 42,
kann ich innerhalb dieses Blockes nicht mehr auf die obere Variable zugreifen.
Das heißt, wenn wir uns das dann anschauen, ist,
das hier ist eine eigene Variable und die gilt in den Degils,
die oberhalb des Blockes und dann hier Unterhalt des Blockes wieder.
Und wenn ich, und nach der Zeile hier,
die grün unterstrichen ist, alles,
was danach folgt und ich benutze diese variable Nummer,
wird fortan nur noch mit sozusagen der höher gestellten variablen Seklaration arbeiten.
Das heißt, es wird halt, man kann,
das nennt sich dann variablen Verdeckung, wenn ich mich noch richtig erinnere.
Genau, also da müsst ihr halt so ein bisschen aufpassen.
Ja. Ich hätte nochmal eine Frage wegen dem Integer.
Es gibt ja auch die Rapper-Klasse, die heißt ja auch wirklich Integer.
Und woran erkenne ich jetzt, dass ich hier dann
nur inschreibe oder nicht die Rapper-Klasse Integer benutzen müsste?
Das Krimitiventypen, genau. Also wir haben ja,
wir unterscheiden ja zwischen den Exemplar-Typen. Ja,
das ist halt alles, was irgendwie ein Exemplar von irgendeiner Klasse ist,
was halt irgendwie mit New erstellt worden ist und zwischen den primitiven Typen wie halt Infloat und so weiter und so fort.
Na, also da müsst ihr halt wirklich aufpassen,
sobald da irgendwie in den Satz steht,
irgendwas mit primitiven Typen, immer gucken, okay,
um welchen Primitiven-Typen handelt es sich jetzt und ihr müsst halt direkt wissen,
okay, ich darf jetzt nicht einfach machen sehen,
okay, er soll hier vom Typ Inwitcher sein,
das heißt,
ich schreibe da jetzt einfach vorne Inwitcher hin
Sondern da müsst ihr dann halt diese Übersetzungsleistung machen von,
das ist ein Insel-Jays, primitiver Typ halt einfach inselst.
Okay. So. Nee, das will ich nicht.
Dankeschön. Genau. Okay. Ja, jetzt kommt,
jetzt kommt's direkt in dem Paaren, wo es dann interessant wird.
Und zwar, jetzt steht da,
sie klarieren sie ein Feld vom Typ in Tritcher
mit dem Bezeichner Seiten.
Das ist natürlich leider
Echt? Primitiver Typ. Was ist denn da jetzt anders?
Wenn ich das erst mal so lese. Also sieht das
jetzt großartig anders aus, als eine normale Variablen-Segioneration?
Ja. Also wir haben ja frei so lange gelernt,
dass Telda noch bei Gibt sagen sollten.
Ansonsten ist es das neue. Genau. Genau, das,
was wir, genau, das ist so eine SEC,
SE2-Konvention, die wir hier haben,
dass wir sagen,
alle Felder sollen immer
Private sein
Aber wenn man jetzt wirklich ganz strikt sagen würde,
okay, ich dekariere wirklich nur ein Feld vom Typ Incicer
mit dem Bezeichnerseiten, dann würde das so aussehen.
Aber wichtig für, also das ist halt wichtig,
dass ihr diesen Unterschied habt. Also das eine ist halt,
ja, war Grundsinntax und das, was ihr an Techniken damit lernt,
also objektorientierte Programmierung und all sowas,
was da halt unabhängig von der JavaSinntax ist.
Und dann gibt es halt noch diesen dritten Punkt,
dass es dann halt diese Konvention, die wir hier haben,
Dass es sozusagen halt über dem All.
Also wir haben erstmal ein Grundkonzepte, die das irgendwie bestimmen,
wie wir programmieren. Dann haben wir die Konzepte,
die halt Java mitbringt und wie es die Grundkonzepte umsetzt.
Ja, und jetzt hier würde man natürlich sagen,
laut unserer Konvention müsste natürlich ein Private-Turn. Aber ich sag mal,
so solltet ihr dieses Private jetzt im Programmierdiktat vergessen,
dann wird euch da deswegen niemand den Kopf umdrehen.
Also das ist jetzt nicht der Hauptgrund,
warum ihr das Programmierdiktat nicht schafft,
wenn man Private vergisst
Wichtig ist, dass ihr verstanden habt, okay, da steht das Keyword-Feld.
Also ich habe das Keyword. Ich habe hier das Keyword-Feld
und deswegen muss ich das hier Klassen rum im Klassen rumschreiben.
Ja, klasse. Klassen geworden. Das ist halt sozusagen,
worauf ihr achten müsst, wenn da steht, irgendwie fällt.
Es kann natürlich auch sein,
dass das irgendwie eine Kombination aus dem,
was hier oben steht, ist,
also das sind halt alles ganz viele Wörter,
aber die beschreiben eigentlich alles dasselbe
Ob es jetzt ein Zustandsfeld ist,
einfach nur ein Feld und ein Exemplar variable, bezeichnet halt alles,
dass es eine variablen Signoration innerhalb des Klassenhumpfes ist.
Ja. Okay. So. Genau. Und jetzt,
wenn man jetzt die Konvention aus der Ast lassen würde,
dann würde man jetzt sagen, müsste halt zum Beispiel sowas drin stehen.
Was alles deklarieren sie, das Feld,
seid mit dem Beziehungsweisen der Seiten und der privaten Sichtbarkeit.
Und dann würde es halt darauf hinauslaufen. Ja,
also das ist der einzige Unterschied zu dem davor,
ist halt einfach nur,
dass es hier explizit gefordert ist,
dass das mirialste Sichtbarkeit hat
Okay. Genau. Jetzt könnte es natürlich auch kommen,
sein, dass einfach so ein relativ, so ein Satz
geschrieben wird, der irgendwie ganz viel nach sich zieht.
Zum Beispiel hier steht, jetzt schreiben Sie ein Konstrukt,
da welcher das Feld Seiten auf dem Wert 52, äh, 42 initialisiert.
Was, also das ist ein sehr kurzer Satz,
aber was muss eigentlich jetzt alles passieren?
So was wäre vielleicht der erste Step, den ich machen müsste. Ja,
ein Konstruktor ist ja dann, Entweder den Namen, der hat Klasse,
also in dem Fall wäre das dann jetzt einfach ein Buch,
dann leere Klammern und dann eben geschweifte Klammer, dann müsste man dann Seiten,
ist gleich 42, Semikolon und dann liegen Klammer wieder schließen.
Genau. Hat da jemand Einwände? Ja. Vor
dem Buch, wie das klappt. So,
jetzt kommt direkt die Frage,
muss da
ein Public hin
Ich kann ja eigentlich auch die Standardsichtbarkeit nehmen.
Also tatsächlich ist es so, dass ihr das Konstruktoren sind
eigentlich nichts anderes als auch Methoden in diesem Sinne.
Das heißt, auch ein Konstruktor kann die sogenannte Standardsichtbarkeit haben, also diese Default-Sichtbarkeit.
Sie kann Public sein oder sie kann auch Private sein.
Also es gibt nachher so spezielle Design-Pattern, also halt,
wie man Software designt, die eventuell es erfordern,
dass man die Konstrukte auf Private setzt
Weil man die Objekte halt irgendwie anders erstellt. Aber grundsätzlich,
also ihr könnt ein Paptik davor schreiben, müsst ihr aber nicht.
Zumindest jetzt im Kontext von dem, was ihr bisher gehabt habt,
und da ihr noch keine Packages hattet, arbeitet ihr sowieso alle im sogenannten Standard-Package.
Das heißt, es ist eigentlich egal,
ob ihr es Public setzt oder auf Package-Public setzt,
weil das ist derzeit noch dasselbe für euch. Das heißt,
also maximal würde ich da vielleicht sagen, okay, wenn alles anders,
also wenn jetzt irgendwie überall Das Programmieriktat voll mit Fehlern ist,
dann wäre das jetzt das wenigste Schlimme.
Also da wäre es halt schlimmer, wenn ihr jetzt nicht
verstanden habt, wie die Variablenzuweisung innerhalb des Konstruktes passiert.
Wenn ihr halt diese Konventionen, die wir halt irgendwie haben, weglässt. Aber eigentlich ist halt das,
was ihr euch so verinnerlichen müsst,
ist in der Stehkonstruktur, da muss ich halt,
dann habe ich halt hier, also das Wort Konstruktor,
das führt halt immer dazu, okay,
das ist halt, ich schreibe einen Methodenkopf,
wenn er nichts in dem Satz steht mit irgendwelchen Parametern,
dann lasse ich die Klammern einfach da leer
Aber ein Konstrukt, der kann theoretisch auch Parameter übernehmen.
Also das heißt, da müsstet ihr auch ein bisschen vorsichtig sein,
ob da vielleicht noch dieses Wort Parameter drin ist.
Und der Rest der Aufgabe ist dann halt, ist halt dieses,
welcher das Feld, Seiten auf dem Pferd initialisiert.
Und das ist dann dieser Part.
Das heißt halt immer schönen Scan und gucken, okay,
was muss ich jetzt eigentlich immer als erstes machen?
Und hier sehen wir auch nochmal die Musterlösung, das heißt,
genau. Oh, hier habe ich das sogar mit Public
gemacht.
Aber bisher, bisher in den Programmierdiktaten, die ich gesehen habe,
war eigentlich der Zuges-Munipalkat, war eigentlich immer angegeben.
Also ich war der Meinung, ich habe irgendwie auch mal Programmierdiktate gesehen,
wo es dann vereinzelt nicht angegeben worden ist.
Also schreibt einfach immer nur das, was da wirklich explizit steht.
Also falls euch dann nachher eventuell jemand einen Strick draus drehen wollt,
will, weil ihr irgendwie da ein Public nicht hingeschrieben habt,
weil es nicht explizit im Satz erwähnt worden ist
Zur Not übernehme ich dann gerne die Diskussion mit denjenigen.
Wenn das der Fehler war, der dazu geführt hat,
dass das Programmierlicht gerade nicht bestanden worden ist natürlich.
Also wenn er jetzt noch natürlich gravierende Fehler sind,
dann kann ich dann auch einmal nichts mehr retten.
Ja, aber also solche kleinen Details sollten euch nicht aufhalten beim Programmiergetanen.
Also wichtig ist halt wirklich, dass ihr verstanden habt,
okay, ja, ich muss einen Konstruktor schreiben.
Das heißt, ein Konstrukt, der sollte schon,
also wenn der Konstruktor schon denselben Namen hat, wie der Klasse,
dann ist schon mal die halbe Miete geworden für diesen Satz.
Weil dann habt ihr verstanden,
der Konstruktor sollte immer genauso heißen
wie die Klasse
Okay. Genau, jetzt,
da wir ja immer irgendwie alles bei uns Private setzen,
laut unserer Konvention, muss es ja dann irgendwie auch eine Möglichkeit geben,
wie wir jetzt von unserem Buch die Seitenanfall zurückbekommen.
Und deswegen sollt ihr eine sondierende Methode,
also einfach nichts anderes als eine Methode,
die den Wert eines Feldes zurückgibt, halt schreiben.
Das heißt, sie würde erstmal
so eine Tode aussehen.
Zumindest der Methodenkopf
Was ist so das Wichtigste an den Methodenkopf? Ich hatte hinten links.
Achso, ja. Muss die Richtung umdrehen, sorry.
Der Zug ist wohl... Moificara? Ja. Ah,
okay. Der wäre dann... Hablick wahrscheinlich. Ja,
könnte, also ich kann jetzt sagen, okay,
vielleicht findet so eine Sierende Methode, die mir angibt,
was das eigentlich mit dem Objekt los,
wäre es vielleicht nicht schlecht, wenn es public ist,
aber es muss nicht.
Also wichtig ist hier wieder, Deswegen schreibe ich es in Klammern,
weil hier, hier in diesem Text steht nirgendwo,
dass ich einen speziellen Zugriffsmodifikator benutzen soll. Das heißt,
na, natürlich, ich kann ihn auf Public setzen,
aber sollte euch das im Zitat passieren,
dann entweder fragen oder halt einfach den Zugriffsmotivat-Krifikator weglassen.
Okay, was ist das nächste Wichtige bei der Deklaration?
Jetzt habe ich irgendwie den Zugriffsmodifikator beachtet.
Was mache ich als nächstes? Ja, wieder?
Ja,
der Rückgabeschub wäre
Ins? Okay. Woher kommt das jetzt? Ja,
ich gucke halt, okay,
ich soll den vom Feld von Seiten, das zurückgeben,
Seiten hat, den Typen Ins und dadurch kommt zustande,
dass der Rückgabewert dieser Methode in sein muss.
Okay. Ja, was kommt denn jetzt? Ein Bezeichner,
in dem Fall wäre es am besten irgendwie, gibt wert.
Ja, gibt wert oder es bietet sich an,
immer zu sagen, Mach entweder Deep Seiten,
weil wir dann halt sozusagen weitergeben, um was es sich handelt.
Oder wenn wir jetzt eher im englischen Bereich gehen,
ist es dann halt ein sogenannter Ghetter.
Aber wie ihr das Ganze jetzt,
also ihr solltet euch zumindest einen der beiden Sachen halten.
Einfach damit es halt so ein bisschen einheitlich ist,
damit man direkt weiß,
okay, ich kann anhand des Bezeichners ablesen,
was diese Methode eigentlich
schon machen soll
Wenn das nicht explizit angegeben ist, meistens halt einfach
Geep oder Gets und dann in den Felden haben.
Okay. Genau, kommt jetzt noch irgendwie irgendwas hinter dem Bezeichner?
Also jetzt fangen ja hier die Parameter an, braucht so eine Methode,
die irgendwie mir den Zustand zurückgibt, ein Parameter.
Ja, nein, nein. Okay. Noch jemand,
eine abweichende Meinung als Nein?
Okay, gut
Genau. Das heißt,
da ist sich ja um eine Methode handeln soll,
die einfach mir nur den Zustand zurückgibt und nicht irgendwie den Zustand manipuliert,
brauche ich auch halt auch keine Parameter.
Genau. Okay, was passiert denn jetzt? Methoden Rumpf
von dieser Methode. Ja. Da ganz hin.
Ja. Genau, Return. Und dann dieses Unterstrich-Sei.
So. Fällt jemandem ein riesengroßer Fehler auf,
den wir gerade gemacht haben
Ja, wenn wir da ganzen... Ja, die schweifen da an. Genau. Das ist etwas,
das ist tatsächlich ein Flüchtigkeitsfehler, der wird euch eventuell,
sollte er vermehrt, also sollte dieser Fehler mehrfach vorkommen,
dann ist sie mehrfach immer wieder die geschweiften Klammern vergesst,
dann kann man euch daraus sehr schnell den Schuh drehen,
dass ihr nicht verstanden habt,
dass man diese Bereiche halt immer abtrennen muss,
damit man halt weiß, was eine Methodenrumpf ist und was nicht.
Das heißt, es bietet sich auf jeden Fall sehr gut an,
dass wir in hier zu sagen, alles fertig geschrieben habt,
dass ihr vielleicht nochmal durchscannen und guckt, ist,
habe ich irgendwo vielleicht geschweifelt, Klammern vergessen,
weil das sind Dinge, die geben euch sehr schnell fiesen Punktabzug.
Ja. Ja. Okay. Ja, aber das wäre zum Beispiel
ein Fehler, der wird jetzt nicht so scharf gesehen. Also,
ja, das heißt, dieses Fehlen, Simikolon,
das ist weniger, das ist tatsächlich gar nicht mal so schlimm,
weil man sagt, okay, gut, ne,
wenn man da jetzt, das kann man sagen,
ja,
es war ein Flüchtlingsheilsfehler,
das ist jetzt nicht
so schlimm
Aber der hat ja grundsätzlich verstanden, wie die Javas im Tax funktioniert.
Aber wenn halt diese Klammern fehlen, dann kann das eventuell schwierig werden.
Übrigens, es wäre cool, wenn ihr eure Privatgespräche danach verlagern könnt.
Ja, nein, vielleicht. Ich werde bezahlt,
ob ich euch was beibringe oder nicht. Okay, gut
. Genau, und hier ist dann auch Ja,
hier habe ich sogar noch mehr ausgeschmückt.
Hier habe ich den Kontext bemerkt und mir gedacht,
ja, vielleicht kann man die Methode auch einfach die Seitenanzahl.
Aber was, aber was ihr jetzt letztendlich hier als Bezeichner benutzt, ist egal.
Es sei denn, es steht natürlich explizit im Satz,
in diesem Satz hier oben. Und dieser Satz hier explizit drin,
benutzen sie den Bezeichner so und so als Methodenname.
Ja. Okay. Ah, jetzt mal eine kurze Frage.
Hattet ihr schon Klassenvariablen in der Vorlesung gehabt?
Ja. Okay, wunderbar
Boah. Dann erinnere ich mich noch gut genug. Okay,
hier sind direkt, zwar gleich zwei Aufgaben,
und zwar einmal die Disklaration von einem Klassentyp,
von einem Klassenfeld, von Tüt Inchicer.
Vom primitiven Typ? Vom primitiven Typentwitcher,
mit den Bezeichneranzahl Büchern unter privaten Sichtbarkeit.
Das heißt,
wie sieht das aus
Ähm, freundet Tenning bin. Und dann hast du halt du.
Genau. Also einmal, wie das Private, private Sichtbarkeit,
daher kommt das Private. Ja, dann habe ich hier Klassenfeld.
Das ist das Keyword dafür, dass ich, ähm,
sagen muss, okay, das muss Static sein.
Das heißt, wenn irgendwie von Klassenfeld oder Klassenfeld,
oder Klassenzustandsfeld oder Klassenexemplarvariable, nicht Exemplarvariable, Klassenvariable,
Da steht, und dann muss dann Statican.
Ja. Jenseitscher, danke, dass auf Ernst.
Okay, genau. Ja, wer kann denn schon das Nieste,
die nächste Aufgabe? Schreiben wir einen statischen Konstrukte, der
das Kassenfeld initialisiert. Okay, erstmal die allgemeinere Frage.
Wisst ihr denn schon, was ein statischer Konstruktor ist
Nein. Wirklich nicht. Okay, interessant. Gut,
dann machen wir das noch einfach mal. Okay,
genau, wenn ich mich, wenn ich jetzt sage,
okay, ich möchte einen statischen Konstruktor haben,
dann mache ich das eigentlich relativ einfach.
Und zwar, ich sage,
wenn ich das jetzt noch, ich muss kurz luschern.
Ja, okay, ich habe es noch richtig,
ich habe es richtig in Erinnerung.
Gut. Genau, das heißt,
ich sage dann halt einfach,
okay,
meine Kunst statischer Konstruktor
Ist einfach Static. Und dann kommen hier die schönen geschweiften Klammern.
Und hier steht dann, zum Beispiel in diesem Fall, Anzahlbücher.
Anzahlbücher gleich, zum Beispiel neu in diesem Fall.
Okay. Jetzt kommt natürlich direkt die, oder erst mal deine Frage?
Nein, dürfte man noch in dem Fall schreiben,
Pappel-Expect-Deckboot, das wird dann auch 10?
Man muss nur Slaffic schreiben, genau. Weil Public-Slatic-Buch,
damit würdest du eine öffentliche Methode mit dem Bezeichner-Buch als Klassenmethode deklarieren.
Ihr könnt ja auch, also Methoden können ja auch den sogenannten Static-Modifier haben,
das heißt, das sind dann die sogenannten Klassenmethoden. Ja,
also es muss, man muss ja jetzt wirklich sagen,
einfach nur Static und jetzt ist natürlich direkt die nächste interessante Frage,
jetzt vielleicht wieder wie die Übung,
wann wird denn dieser Static-Konstrukt rausgeführt,
da jemand vielleicht eine Idee?
Ja? Wenn man jetzt nicht sagen kann,
als wenn die Antwort an mich ja,
hat die ganze Zeit keinen Schlafstall, also gar nichts mehr.
Ja, nee. Also wann wird dieser Konstrukt eigentlich ausgeführt?
Was könnt ihr euch vorstellen? Ja. Ja,
ich bin das Programm, so sechs wird.
Nicht übersetzt, tausche übersetzt zu gestartet aus.
Das heißt, der statische Konstruktor wird immer dann ausgeführt,
wenn das Programm gestartet wird
Beziehungsweise, wenn man es technisch ganz, ganz genau nehmen will,
dann muss man halt in den jeweiligen Java-Source-Code seines verwendeten Java-Runtime Virtual Machine gucken.
Und da findet man eventuell Hinweise drauf, wie der das handelt.
Aber es ist so, dass die Prämisse ist da wirklich,
bevor ich das allererste Mal irgendeine Methode an dieser Klasse
aufrufe oder irgendwie ein Exemplar erstelle,
wird sichergestellt, dass dieser statische Konstrukte ausgeführt worden ist.
Wann das in dem Prozess passiert, ist halt nicht
näher spezifiziert
Ja. In dem Fall ist es ja einfach nur Static,
aber wenn wir jetzt in den Text dann auch noch
den Namen der Klasse gehabt hätten,
dann wäre das einfach Static und dann der Name der Klasse gewesen.
Oder einfach nur Static trotzdem. Und wie meinst du jetzt genau?
Der Konstruktor heißt ja in dem Fall einfach nur Static.
Aber in dem Text oben ist ja der Name von der Klasse
nicht gegeben. Wenn der Name der Klasse gegeben werde,
oder sehe ich, das ist gerade falsch.
Achso. Ah, ja, okay. Ja,
nee, das geht jetzt davon schon aus,
dass sie schon die Aufgabe hattet,
ihr solltet Klassen in der Klassendeklaration machen
Also es ist halt von dem Punkt aus gesehen,
wo wir jetzt, was halt hier schon direkt steht.
Also ich werde jetzt nicht immer alle Steps,
die bis dahin gemacht worden sind, immer aufschreiben,
weil dann kann ich den Text nicht so schön groß machen
aus der Folie und dann würden mich alle Leute,
die da hinten sitzen, sehr hassen.
Wenn der Sex nicht so groß wäre.
Okay. So. Ja. Wir haben es sogar richtig gemacht
. Alles klar. Okay
Buch? Spannend. Ich habe eine Folie nicht überarbeitet.
Okay, wir tun jetzt mal so,
als würde das dann nicht schon stehen, die Lösung dazu.
Genau. Jetzt kommt natürlich das Interessante am Bild,
wenn ich Operation bzw. Methoden definieren möchte.
Also das Wichtige ist ja halt, euch immer schauen müsst,
okay, wenn das Keyword Methode oder Operation fällt,
man kann beides dafür benutzen
Wobei Methode eher das Wort ist, was man tatsächlich verwendet und
Operation ist so ein bisschen das Übergeordnete davon von der Methode.
Genau. Das heißt, ich habe,
ich sage jetzt erst immer erst mal schön, okay,
ich habe mir irgendwie, ich soll eine Methode definieren.
Ja, das heißt, ich habe drei,
ich sollte direkt schon mal im Kopf haben, okay,
es wird sich um so ein Konstrukt handeln mit,
ich habe hier einen Kopf.
Und dann hier noch in den Rumpf von
so einer Methode
So, und jetzt, das, was dann als nächstes kommt,
ist dann halt hier in diesem Fall,
okay, es handelt sich um eine Exemplarmethode.
Das heißt, hier an diesem Punkt,
wo ich theoretisch noch das Staticam packen könnte, kommt es nicht hin,
weil es sich ja um eine Methode handeln soll,
die ich am Exemplar aufrufe und nicht an der Klasse selber.
Genau, und dann haben wir... Ja,
und das ist es dann eigentlich schon. Das,
was dann halt hier irgendwie so drinsteht,
Das ist dann halt wie bei allen anderen Sachen halt auch wieder.
Da kann dann sagen, okay,
initialisieren sie wie eine Variable oder weisen sie sie irgendeiner Variable,
einen Wert zu oder sonst was.
Es kann natürlich auch noch sein, dass ihr noch etwas Zusätzliches bekommt,
wenn da zum Beispiel stehen würde, mit Parameter Baumeter.
Was weiß ich
Ja, mit Parameter, bla, vom Typ.
Club. Dann wäre das halt etwas,
was hier zwischen diesen beiden Klammern rein müsste.
Wie wäre das jetzt in diesem Beispiel? Was müsste ich
dann da reinschreiben, wenn ich sage, okay,
der Parameter soll vom Typ Club sein mit dem Bezeichner bla.
Ja, Club, dann bla. Genau, ne?
Genau, klar. Und sollte es sein,
dass ich irgendwie vielleicht mehr als ein Parameter habe,
dann trenne ich die halt einfach immer nur mit in Komma
Ja, und dann halt. Punkt, Punkt, Punkt. Und dann,
je nachdem, wie viele Parameter ihr da benutzen sollt.
Okay. Genau, und wie halt schon gesagt,
beim... Das ist verkehrt.
Gut. So. Was kommt jetzt, genau. Genau,
das ist, das wollen wir uns jetzt nicht mehr
angucken.
Dann haben wir ja jetzt noch das andere. Wir hatten jetzt
erstmal Exemplarmethoden gehabt, die am Exemplar direkt ausgeführt werden.
Dann haben wir ja jetzt noch Klassenmethoden. Ja,
das heißt, wenn wir unser Beispiel von vorn wieder nehmen,
ich habe ja hier schon meine,
klasse Buch mit dem Klassenfeld, Anzahl Bücher und dem Klassenkonstruktor,
der das Feld auf null initialisiert.
Und jetzt sollen wir eine statische, sondierende Methode schreiben,
die die Anzahl der Bücher zurückgibt.
Wie würde ich
sowas realisieren
Fällt euch da was ein? Also was ist vielleicht
erst mal das Allerwichtigste, was da mindestens stehen muss?
Ja. Genau. Wir haben lieber Friday bis dahin
nicht angegeben, deswegen was anderes. Das erste Zettel,
als schlaf ich im Tode und bin dann ins Kind,
als Rückgabe hier.
So, die Anzahl der Bücher zurückgeht,
das kommt halt daher,
weil hier
Da muss man halt immer so ein bisschen gucken. Es kann eventuell nicht unbedingt,
steht da immer wirklich explizit, welcher Typ das ist,
sondern einfach nur so, ja,
gib das dann halt einfach aus,
dass sie aus dem Kontext Teller ausmerken müsste, okay,
es handelt sich hier um diese statische,
um diese Variable hier in Anzahl Bücher.
Und dadurch ist halt auch der Rückgabetyp.
Jens. Okay. Ja, magst du weitermachen? Ja
, übel ist aus der Methode, die dir zeigt.
Das könnte ja wieder sowas sein wie die Bücher,
die Anzahl Bücher. Genau. Danach Klamaten dazu,
die Karameter
In dem er war, der mir keinen. Aha.
Ich schleife jetzt aber auch. Genau. Und dann,
ja, Return, Anzahl Bücher, so ein Programm.
Genau. Und dann kommt das Return. Ja,
und das kommt halt dadurch, dass er hier sagt,
okay, zurückgibt und es soll, es ist eine sondierende Methode.
Ja. Mehr sagt man uns das dann halt nicht.
Okay. Okay,
alles klar
Wir haben sogar alles richtig gemacht. Gut, wunderbar. Ja,
jetzt noch mal eine kurze Zusammenfassung von dem,
was wir jetzt gerade gemacht haben,
damit ihr noch mal diese Begriffe Begrifflichkeiten gehört habt,
die eventuell im Text vorkommen können.
Das heißt, wir haben hier um unseren Klassenkopf.
Das Ganze ist dann hier
unser Klassenrumpf
Dann haben wir unseren Methodenkopf. Und dementsprechend unser Mentor und
Rumpf. Ja, der eventuell halt noch weitergehen könnte,
wenn die Methode ganz viele Anweisungen hat. Okay. Genau,
das haben wir, genau, jetzt geht es um die Paarmeter,
das haben wir ja schon so ein bisschen zum Teil gemacht.
Ja, deswegen gehe ich da jetzt ein bisschen,
er verschnellt wird gerade durch diese Paarfolien hier durch.
Das heißt, Ich könnte zum Beispiel, vorher hatten wir
ja immer, gib mir, als zonsierende Methoden benutzt.
Geht natürlich auch genau andersrum. Das sind dann die zustandsverändernden Methoden.
Hier die Zustandsverändernde Methoden zeichnen sich meistens immer dadurch aus,
dass sie keinen Rückgabewert haben. Also sie, ich habe bisher,
glaube ich, noch keine Definition gelesen, wo explizit drinsteht,
dass es verboten ist, dass sie einen Rückgabewert haben dürfen.
Aber in den, keine Ahnung,
wie viele Jahren ich das hier schon gemacht,
die Übung irgendwie betreut habe,
ist mir das
noch nie vorgekommen
Zumindest in dem Kontext von SE2. Genau. Ja, das heißt,
Zustandsverändern, Zustandsverändernde Methoden, die arbeiten meistens mit einem Rückgabetypen Void.
Das muss man auch immer explizit hinschreiben,
damit der Compiler auch weiß, okay, er meint wirklich,
dass die Methode keinen Rückgabewert haben soll und er hat die nicht einfach nur vergessen.
Genau. Und das, was dann halt hier passiert ist,
dass ich in dem Methodenkopf Deklariere ich meine Variable.
Das heißt, da sage ich, von welchem Typ
die Variable sein sollen, welchen Bezeichner sie haben soll.
Und dann kann ich sie halt, das Verwenden,
das passiert dann halt hier in unseren Methoden Rumpf.
Das heißt, ich habe hier oben im Methoden Kopf,
habe ich sie den Parameter deklariert und dann nachher mit Huhn Rumpf
kann ich mit der Variable machen, was ich will.
Beispielsweise in diesem Beispiel setze ich halt einfach den Wert von dem Parameter auf,
nehme ich einfach den Wert von Parameter und billige damit Meine Exemplare war in Iable.
So. Genau. Es könnte auch vorkommen, dass ihr gebeten
werdet im Diktat, eine sogenannte Main-Methode zu schreiben.
Die ihr bereits auf dem letzten Aufgabenplatz letzte Aufgabe,
das Hallo-Weltprogramm schreiben solltet. Wer kam mir dann direkt sofort
aus dem FF aus dem Kopf sagen,
wie sieht denn der Methodenkopf der Main-Methode aus
Ja. Hab nix, der Dick Royd, Men,
immer auf Swing, Arry.
Ist zum ersten Mal? Das, was jemand konnte.
Okay, ja. Also das ist,
da muss ich jetzt mal so ganz, ganz gemein einfach sagen,
das ist etwas,
das muss man
auswendig lernen
Aber das muss man auch nur deswegen auswendig lernen wegen diesem Programmierdektat. Weil,
also nachher eure Entwicklungsumgebung hat dann solche tollen Shortcuts,
wie dass man einfach sagt,
einfach eingibt Main und dann kann man so Steuerung leertaste machen
und dann vervollständigt einen Clips das alles automatisch.
Aber man sollte es schon verstehen, man sollte vielleicht schon verstehen,
warum eigentlich dieser Methodenkopf jetzt so aussieht. Also erstmal dieses Static,
Ja, das kommt ja daher, weil das ist mein Programmeinstiegspunkt.
Das heißt, an diesem Punkt gibt es noch gar keine Objekte.
Das heißt, ich kann auch anderen kein Objekt um was aufrufen.
Das heißt, es muss eine statische Methode sein,
die mein Programmeinstieg darstellt. Ein Rückgabewert ist jetzt so,
ja, das ist jetzt, ich würde,
ich würde jetzt schon fast sagen, das ist sehr Java-spezifisch,
weil in anderen Programmiersprachen macht es durchaus Sinn,
wenn die Main-Methode auch einen Rückgabewährt hat.
Aber das nächste, was man sich behalten sollte,
ist dieses Okay, die Methode, diese Main-Methode oder
diese Einstiegspunkte des Programms, muss halt immer Main heißen.
Und das nächste ist dann dieses tolle Konstrukt. Ja,
wo wir einfach sagen, okay, dieser Main-Methode beteilt ein Rail von Argumenten übergeben.
Das heißt... Okay, ähm... Ja, ich nehme
ihn wieder auf. Okay, wunderbar. Genau,
aber das ist einfach auswendig, lernen jetzt fürs Programmierte-Tat.
Ich würde tatsächlich nicht darauf pokern,
dass man das Programmieriktat erwischt, Nicht fordert,
eine Main-Methode zu schreiben, weil wenn man genau das tut,
dann kriegt man genau das Programmierdektat.
Deswegen, ja, da fällt mir nichts anderes ein,
außer auswendig lernen. Am besten vielleicht eine Kartellkarte machen und
jeden Morgen in der U-Bahn sich das irgendwie angucken,
Main-Methode, wie das aussieht.
Okay. So, fast geschafft. Wir sind auch vor
ihr 15 von 23, keine Sorge.
Wir nähern uns irgendwann in den Ende.
Okay. Jetzt kommt natürlich das, was einem zu interessantesten
Und zwar, es könnte sein, dass ihr in eurem Diktat,
das von euch irgendwie gefordert wird, dass ihr ein Objekt von der Klasse erzeugen sollt.
Ja, das heißt, wenn ich mir das zum Beispiel,
wenn ich das zum Beispiel darauf beziehe,
dass ich irgendwie so ein Buch,
also das ist jetzt erstmal komplett unabhängig von irgendwas,
das Einzige, was uns jetzt an dieser Folie gerade interessiert,
ist eigentlich nur das hier.
Das heißt, wenn ich halt irgendwie in irgendeiner Art und Weise steht,
deklarieren sie die Variable Buch mit dem Bezeichner Blue Jay.
Und, ähm, weisen sie ihn, ein neues Exemplar von Typ Buch zu. Ja,
denn wenn diese Wort, also Wortkombination in einen Satz auftaucht,
dann müsst ihr euch einfach daran erinnern, okay,
ich muss jetzt variablen Seklaration vom Typ,
das ist alles super, wunderbar Butter.
Ich musste das zuweisen, dann kommt das jetzt gleich. Und das,
was dann so ein bisschen anders ist als mit primitiven Datentypen,
ist, dass ich hier sagen muss, okay,
ich muss,
ich hab das Keyword New
Was kombiniere ich nochmal? Mit dem Typen. In diesem Fall
. Ja. Ihr werdet im Laufe von SE2 auch,
ich glaube auch schon in SE1, hattet ihr jetzt auch schon teilweise kennenlernen,
dass ich theoretisch dort jetzt auf der ganz linken Seite,
also hier da, wo...
Auf dieser Seite, wo das hier das Buch ist.
Da könnte ich theoretisch jetzt auch irgendwie das Interface benutzen,
zum Beispiel Interface Medien. Und dadurch, dass,
also wenn ich jetzt halt irgendwo in meinem Source Good
halt zum Beispiel so ein Interface hätte, Face-Medien.
Ja, und irgendwo innerhalb meines Kurdes habe ich noch die Klasse Buch.
Na, mit dem Keyword Implements. Dann ist es mir auch erlaubt zu sagen,
okay, anstatt dass ich jetzt hier bei Buch,
bei dieser Deklaration, mich festlege, dass es ein Buch sein muss,
Bei der Generation dieser Variable kann ich auch noch sagen,
okay, ist so ein Medium-Medium vielleicht sein.
Medium. Statt also dann hier statt Buch, schreibe ich
dann hier Medium mal hin. Und kann halt trotzdem sagen,
Medium Blue J ist gleich ein New Buch.
Weil das halt dadurch, dass ich da ins Stande kommt,
weil bucht es das Interface implementiert.
Aber so eine Aufgabe hatte ich tatsächlich noch nie im Programmierdiktat
Aber es könnte vorkommen. Weil es ja eigentlich schon zu einem Skill,
weil es ja eigentlich schon zu einer Kenntnis gehört,
die ja nach SE1 haben solltet.
Wie das funktioniert. Genau, zur Hinternahme.
Da ist man dann quasi, da bist du aufgewacht.
Ähm, super, das ist jetzt genau ein Platz.
Ich sag mal so, man ruft nicht direkt den Konstrukt
so auf. Aber man stößt an, dass der Konstrukt
da aufgerufen wird.
Also es ist ein bisschen
Es ist kein, es ist nicht explizit ein Methodenaufruf,
was da passiert, wenn man dieses New-Buch und dann macht.
Sondern das, was passiert ist, es wird dieses Objekt erstellt.
Also es wird ein neues Objekt vom Typ-Buch erstellt, mit diesem New-Buch.
Und dann wird an diesem Objekt dieser Konstruktor aufgerufen.
Also das heißt, es ist nicht ein direkter Aufruf des Konstruktors,
aber ja, es passiert halt einfach.
Also es ist sozusagen eine Kombination aus,
das Objekt wird erstellt und der Konstruktor wird dann aufgerufen
Ja. Okay. Noch Fragen lässt du erstmal.
Gut. Genau. Jetzt kommt natürlich die Reaktion,
die nächste Frage, aber ja,
wenn ich denn jetzt schon so eine schöne Referenz variable,
wie man das dann nennt,
weil es ist ja jetzt keine normale Variable mehr,
sondern sie hält eine Referenz auf ein Objekt,
dann möchte ich mit dieser Referenz variabler auch irgendwie Sachen machen können.
Und euch sollte allen die Punktnotation ein Begriff sein und wenn
ja jetzt zum Beispiel die Jetzt mache ich mal kurz,
schauen wir mal, wer ist.
Ah, okay. Das hat niemand gesehen, ne?
Okay, gut. Genau, wenn ich jetzt zum Beispiel sage,
okay, als Aufgabe steht dann,
rufen Sie an der Referenzvariable Blue J. die Methode,
gibt Seiten auf.
Wie würde ich das schreiben? Was müsste ich dann machen
? Ja. Winter, Punkt, Gips Seiten.
Und dann weiß ich es noch, ein Parameter gibt,
kommt ja noch nie in Klammern
Genau. Das heißt... Und ein Semi-Problem. Ja. Genau,
falls es Parameter gibt, kommen die dann in die Klammern rein,
falls es keine gibt, lässt man in die Klammern einfach leer.
Und dann zum Schluss ist Simikole. Das kann man natürlich jetzt auch,
wie hier in diesem Fall,
kann man das auch direkt mit,
können sie auch die Aufgabe heißen,
okay,
seklarieren sie
eine lokale Variable vom primitiven Typen ins
Mit dem Bezeichner BlueJ-Seiten und weisen sie ihm den Wert,
der Rück, der, äh, weisen die ihn,
dem Rückgabewert des Methodenaufrufeskettseitenanzahl am, äh,
an der Referenzvariable BlueJ. Na, um mal so einen richtig langen,
fiesen Satz gehabt zu haben.
Na, aber das kann durchaus passieren und da müsst ihr,
also, ähm, ihr müsst dann halt immer wirklich,
wie wir es auch vorher immer gemacht haben, so vorgehen,
einfach erst mal scannen, okay,
welche Keyworder sind das und in welcher,
in welcher Reihenfolge muss ich da jetzt
Handlungen machen
Also es ist nichts anderes als auswendig lernen, auf Wort
kommt ein anderes. Also wenn das Wort gefunden ist,
dann muss ich was Bestimmtes schreiben. Oder halt auch,
genau, nie nochmal dasselbe. Dann mit,
wenn ich eine Zustandsverändernde Methode aufrufe, die einen Parameter übergibt,
da kann ich dann halt irgendwas reinschreiben, was dann halt erfüllt.
Ja, also wenn jetzt,
hier ist jetzt zum Beispiel Sätze,
Seitenanzahl und da nehme ich jetzt einfach
die Buje-Seiten plus eins
Da müsst ihr halt einfach gucken. Also ein Beispielsatz würde da dann zum Beispiel lauten,
rufen Sie an der Referenzvariable Blue Jay, die verändernde Methode,
setzte Seitenanzahl auf und mit dem Parameter Blue Jay-Seiten plus 1. Oder mit dem Parameter 42.
Also sowas könnte sein als Satz stehen und dann müsst ihr
halt schauen, dass ihr das so ersetzt.
Aber die grundlegende Mechanik ist dahinter halt immer, okay,
wenn ich, wenn da irgendwie steht,
ich soll an der Referenzvariable eine Methode aufrufen
Dann muss ich halt immer dran denken, okay,
Referenz variable, Punkt, unseren Methodenname.
Und falls es Parameter gibt, Parameter gänzen. Okay.
Genau. Jetzt sind wir wieder mit dir einfach und fertig.
Gibt es noch Fragen zu dem Paar erstmal?
Ja, nein, vielleicht. Okay. Gut. Ja
, gut
Genau, vielleicht nochmal so in Erinnerung gerufen,
welche verschiedenen Basisdatentypen oder auch primitiven Datentypen es gibt,
damit ihr so ein bisschen die Übersetzung habt.
Das heißt, ich habe zwar noch nie andere Basistypen als Inwitcher gesehen,
aber... Aber das ist halt einfach alle normal.
Und so weiter und so fort.
Ja, ich glaube, Inwitcher long ist jetzt nicht
Ja, nee. Okay. Ja,
aber das solltet ihr euch auch nochmal vielleicht so ganz kurz machen,
dass nicht irgendwie auf einmal versucht, wenn da steht,
ja, deklarieren sie doch mal eine Variable vom Typen Byte.
Dass ihr dann nicht denkt, so, oh,
das ist eine Klasse, sondern das ist noch ein primitiver Datentyp ist.
Aber, okay. Jetzt kommt das etwas Interessantere.
Ja, das habe ich heute schon versprochen.
Jetzt kommt das Schwere
Okay. Deklaration, Deklaration ist tatsächlich noch das Einfachste.
Das heißt, das Deklarieren, das ist ja,
das ist einfach wieder getan. Damit getan,
dass wir sagen, okay, das, worauf ich,
das, worauf, das, was sozusagen das Keyword ist,
ist, okay, es sollen Ray sein, das heißt,
ich muss da irgendwas mit diesen eckigen Klammern schon mal machen.
Und diese eckigen Klammern, ohne was da reinzuschreiben,
reicht für die Deklaration erstmal schon vollkommen aus
So, das wird's ein bisschen spannender. Na,
wenn ich jetzt sage, okay, ich möchte das initialisieren.
Dann denkt man sich erst mal noch so,
okay, Insutscher ist ja ein primitiver Datentyp.
Aber primitiver Datentyp und dieses New machen jetzt irgendwie jetzt nicht so viel.
Macht jetzt erst im ersten Moment erst mal noch nicht
so Klick, wenn man sich das anschaut.
Weil man ja eigentlich gewöhnt ist, wenn man vom primitiven Datentypen spricht,
ja, das kann ich einfach zuweisen.
Da muss ich jetzt nicht ein neues Exemplar stellen.
Das liegt so ein bisschen daran,
dass Arrays in Yara damit gelöst sind,
dass es halt einfach
auch nur Objekte sind
Das heißt, am besten euch so ein bisschen verinnerlichen,
wenn es nachher darum geht, irgendwie race zu erstellen,
race zu initialisieren, dann müsst ihr halt,
dürft ihr halt dieses New nicht vergessen.
Und das baut sich dann immer daraus zusammen, okay, initialisieren. Das heißt,
ich muss das New benutzen und dann habe ich hier den Typen,
den schreibe ich auch trotzdem noch klein,
also nicht auf die Idee kommen,
irgendwie groß in Twitcher zu schreiben oder so,
sondern wirklich,
ihr wollt ja
in Array von dem primitiven Datentyp haben
In diesem Fall. Das heißt, das bleibt gleich.
Und jetzt kommt's, das hier. Was sagt denn das
jetzt eigentlich aus, wenn ich sage, okay,
new ins und dann in den eckigen Klammern, 42.
Was erstelle ich damit? Ja? Ja, in Every,
dass der Intecher beinhaltet, also die Kapazität des Wortfels.
Genau. Das heißt, er hat auch schon
direkt das richtige gute T-Wort gesagt.
Es wird höchstwahrscheinlich so was sagen wie deklarieren und initialisieren
Ähm, eine Intoacher-Alray mit dem Bezeichner Zahlenkette, mit der Kapazität 42. Ja.
Und dann diese Kapazität 42, das ist halt das,
was bei euch als Keyword-Klick machen muss, okay,
diese 42, die muss ich in die eckigen Klammern reinschreiben.
Also das, was hier drinsteht, ist dann die Kapazität.
Okay. Ja, jetzt kommt, genau,
und jetzt hab ich so ein Array und wenn
ich mit diesem Array auch noch sinnvolle Dinge machen möchte,
Dann fehlt da eine Folie.
Okay. Genau. Ja, wie schreibe ich da,
also wie schreibe ich denn in so eine Array rein?
Was ist da so eure Idee? Ja. Könnte mit Zahlenkette
. Und dann, dass Array und an welcher Stelle.
Also die eckigen Klamaten. Wenn er jetzt der Satz lauten
würde, schreiben sie
den Wert
42 an der Stelle 2 ein, dann wäre halt,
würde man jetzt jetzt die 2 dahin setzen.
Und das ist dann unser Index. Also das kann dann
durchaus auch geschrieben werden in den Satz,
schreiben Sie den WR 42 in das Array am Index 2. Ja.
Also wenn eine Stunde Stelle gefragt ist,
wird das direkt gerade eigentlich nicht irgendwie minus 1 rechnen,
weil man schon bei null anfängt zu zählen.
Ja, also wenn da explizit drin steht in der Aufgabe an Index 2
, dann macht man das so. Für den sehr,
sehr gemeinen Satzbau, das da steht,
setzen sie den zweiten Wert im Array auf 42,
wo man dann selber im Kopf checken muss, okay,
das ist am Index 1,
weil wir ja bei null anfangen zu zählen.
Ich glaube, dass es kein Fehlerpunkt,
wenn die dann auf einmal eine 2 dahin schreibt.
Also es geht ja bei diesem Programmierdektat nicht darum,
dass ihr funktionierenden JavaCode schreibt,
der dann,
also logisch funktionierenden JavaCode schreibt
Es geht ja darum, dass wir es in taktisch korrekten,
ja, aber kurz schreibt. Und da ist jetzt nicht interessant,
ob ihr euch irgendwie ein bisschen verrechnet, weil man irgendwie
da lustig am Index rumrechnen sollte. Das Wichtige ist,
einfach nur dadurch, dass ihr bewiesen habt mit diesem hier,
ihr habt verstanden, wenn ich auf ein bestimmtes Index... Ah,
wenn ich an einem bestimmten Index an was schreiben möchte,
dass ich dann den Variablenbezeichner von dem Array nehmen muss und
dann in der eckigen Klammern sagen muss,
an welcher Stelle
Und dann das Gleiche, dann das Gleichheitszeichen kommt.
Und damit habt ihr eigentlich schon gewonnen. Und habt ihr
bewiesen, ihr verstanden, wie eine Javason sagst du,
ein Array zum Schreiben funktioniert.
Genau. Einmal dahin. Ja, das Wegtarien und Initialisieren von Array.
Ich darf nicht in einer Zeile passieren oder ein ganz düster.
Das darf auch. Also man könnte theoretisch auch sagen,
jetzt in dem Fall einfach sagen, okay,
ich lasse das Ganze hier weg hier oben und mache direkt
hier ins
Das darf ich auch. Also, ein Array,
also wenn ich ein Array deklariere oder initialisiere, ist das nichts,
ist das nichts anderes als eine ganz normale Variable.
Nur, dass durch diesen Zusatz Array halt diese Ecking-Klammern noch dazukommen. Okay. Genau,
wie greife ich jetzt lesend auf so eine Array zu,
wenn ich jetzt zum Beispiel sage, okay,
ich habe jetzt hier irgendwie eine Variable ins Blub und im
Text steht jetzt so,
weisen Sie,
der Variable Blub
Den, äh, den vierten,
den vierten wert des Arrays, Zahlenkette zu.
Wie würde ich das schreiben? Zahlenkette, Ecke, Klammern
und dann drei. Was jetzt der dritte Wert ist?
Der vierse Wert. Bei NS3, richtig. Ja.
Genau. Wir haben jetzt hier überall wieder Simikolons vergessen,
aber... Also ich glaube, ich habe schon,
also ich habe ja,
ich habe schon mal Programmier-Diktate korrigiert gesehen und selbst wenn man
alle Simikolons vergisst,
besteht man
Okay. Das ist jetzt mittlerweile ein halber Fehlerpool-Prophet, Semikolon,
wie man da auch auf die Fehlerbunker haben, also abends.
Ja, also. Ich sag mal so viel. Ich
habe noch nie jemanden wegen Fehlern in Simikolans Durchfallen gesehen.
Wenn ihr jetzt natürlich überall Flüchtigkeitsfehler habt, das heißt,
fehlende geschweifte Klammern, fehlende Klammern,
fehlende eckige Klammern bei Arrays und dann auch noch die Simikolans fehlen,
dann könnt ihr nicht mehr großartig rumdiskutieren.
Ja, aber die Simikolans sind doch gar nicht
so schlimm
Also man muss sich das immer als Gesamtbild angucken,
aber wenn man halt sieht, okay,
er hat konsistent überall die Simikolans vergessen, aber sonst alles richtig.
Wie gesagt, ihr habt mal eine E-Mail-Adresse notfalls,
habe ich dann auch nochmal ein Wörtchen.
Aber ich habe noch nie jemanden wegen Fehlen in den Simikolans
Durchfallen gesehen. Also versucht euch einfach daran zu erinnern,
aber macht euch jetzt nicht verrückt, wenn ihr ein Simiko,
wenn ihr mich nachher merkt, ein Simikolan fehlt.
Okay, gut. Ja, es könnte vorkommen,
dass ihr auch eventuell mit Listen und Mengen
arbeiten müsst
Das heißt, also das, was euch,
wenn halt das Wort irgendwie Listen und Mengen vorkommt,
was erstmal so ein bisschen fies ist, auf den ersten Blick.
Das einzige, was euch eigentlich dazu einfallen müsst,
ist, es ist wie eine Referenzvariable im ersten Moment,
weil eine Liste ist auch noch, ist dann letztendlich auch nur ein Objekt,
nur dass hier etwas, das Wichtige ist halt,
bei Listen und Mengen ist halt das hier,
dieses in den Krokodilklammern, wie man die auch immer nennt.
Genau, das ist das,
was euch im Umgang mit Listen und Mengen, was halt wichtig ist,
bei der Deklaration, dass sie das nicht vergesst.
Das heißt, wenn da als Aufgabe steht,
deklarieren sie eine Liste mit Element, Typ Intacher.
Also das hier ist dann der Elementtyp. Dass sie dann
diese Krokodieklammer mit Intacher nicht vergisst. Und hier ist genau
diese Das, was hier jemand schon gesagt hat,
es gibt ja irgendwie auch noch diese Rapper-Klassen von Inns.
Das ist dann der Moment, wo,
obwohl in der Aufgabe drinsteht, ihr sollt zum Beispiel Innswitcher benutzen.
Dass ihr dann da nicht Inns rein schreibt,
sondern wirklich das komplett ausgeschrieben mit einem großen E-Schreiben.
Weil das hat ein paar technische Gründe,
warum die Syntax dafür so ist.
Okay, genau.
Und... Genau
Es wird höchstwahrscheinlich auch immer in der Aufgabe direkt mit drinstehen.
Das eine, also das Urmerer war jetzt hier unsere Deklaration.
Und jetzt haben wir hier in unseren, sagen wir,
okay, ich möchte jetzt dieser,
ich möchte jetzt dieser Liste etwas zuweisen.
Und List ist ja eigentlich ein Interface, was einfach nur sagt,
so, ja, so soll eine Liste funktionieren.
Und dann in der Regel,
im Regelfall steht dann sowas wie, ja,
und initialisieren sie ihre Zahlenlüste mit einer Arrayliste
Da kommt dann halt, das hier zustande. Ja,
und dieses New Arailers, das ist jetzt auch,
ja, das machen wir so.
Warum kommen nach New Arailers keine Reputierten? Genau,
das ist eine sehr gute Frage. Das kommt daher,
dass irgendwann mal in der Java sind,
Saxman gesagt hat,
das ist ja
irgendwie recht stumpfsinnig
Das immer wieder zu wiederholen zu müssen.
Weil es ist ja eigentlich schon von der Deklaration klar,
dass der Element Typ in Twitcher sein soll.
Aber theoretisch, ja, könnte ich auch, nicht,
das ist jetzt hier. Könnte ich auch hier zwischen
der Arrailist und den Klammern auch nochmal in Twitcher schreiben.
Es ist aber ab irgendeiner Java-Version nicht mehr
zwingend erforderlich
Das kann uns der Linie, der hier drin sitzt, flössern.
Ich weiß nicht, wie fimi, aber du bist da angestellt.
Und dein Name steht auf dem Vorlesungsfolien. Also ich bin mir nicht sicher,
auf dem Spitzen kann man wirklich komplett weg, was du darfst.
Ich glaube, du warst einfach nur gelehrlasten.
Ich glaube, du durftest schreien nur hin oder reden.
Du stellst die Klammern auf und zu.
Und dann kommt eine Klammer auf und so.
Ohnehin hinter das hin. Aber ich glaube nicht,
dass die ganz viel mehr da aktuell sind.
Ich ziehe mal da drauf.
Das ist jetzt natürlich
erstmal spannend
Aber es wäre auf jeden Fall kein einer der 90er Abendshower, oder?
Also ich sage mal so, Dinge hinzuschreiben ist nie,
ist nie, also wenn man zu viel hinschreibt,
ist nicht schlimm, nur wenn man zu wenig hinschreibt,
ist schlimm,
deswegen gucke ich das jetzt explizit nochmal nach.
Spannend,
ich möchte gerne bitte... Nein,
bitte nicht
Esst, genau, oder was? Das war Lust.
Dann geht es da und dann gleich. Salon hätte.
Boah, das ist ja eine, boah,
Deutsche Taste, glaube ich.
Zahlenkette. Gleich. Raidlist
Ja, ich muss das jetzt... Ich lasse das jetzt
einfach mal weg. Mal gucken, was er dann sagt.
Das ist verrückt. Was zur Hölle?
Bitte? Vielleicht
Ja, dann lässt es mich machen.
Spannend. Also es ist nicht explizit ein Compiler-Fehler,
aber wir einigen uns jetzt einfach mal lieber da drauf,
dass das immer explizit hier hin muss.
Ja, also lernen Sie es lieber so. Wie gesagt,
ihr könnt den Elementen zwar auswerfen, aber sonst besonders vielleicht.
Ja. Genau. Ah ja, jetzt verschwinden auch
die Notifications dafür.
Spannend. Also ich weiß, dass ich schon mehrfach
so programmiert habe und es hat immer funktioniert deswegen.
Aber okay, gut. Aber ich sag mal so,
wir gehen lieber auf Nummer sicher und ich sage explizit,
schreibt es einfach hin, weil die Zeit hat bisher immer ausgereicht.
Also ihr habt keinen Zeitdruck, dass ihr irgendwie an Buchstaben
sparen müsst beim Schreiben. Deswegen, genau,
das werde ich dann nochmal in den Folien korrigieren.
Ja. Genau. Und das wären dann nochmal so Sachen,
die euch, falls in eurem Programmierdiktat, es vorkommt,
dass ihr tatsächlich mit einer Liste oder einem Set oder einem Stack interagieren müsst,
dann könnt ihr euch,
dann war es zumindest bisher immer so,
dass ihr diese Java-Doc von der Liste ausgedruckt mit dazu bekommt.
Das heißt, ihr müsst euch jetzt nicht auswendig lernen,
wie die Methoden heißen,
um jetzt einen Wert hinzuzufügen,
einen Wert auslesen zu können oder sonst was
Das heißt, das muss man zum Glück nicht auswendig lernen. Ja,
aber wichtig ist halt, dass wir,
dass bei euch halt der Unterschied halt drin ist,
okay, wenn es sich um eine Liste,
um eine Menge oder um irgendwelche anderen komplexeren Datenstrukturen handelt,
dass sie die genauso behandelt, wie als wären es Referenzvariablen.
Das heißt, Race sind tatsächlich die einzigen, die einzige Datenstruktur,
die mit diesen eckigen Klammern ihre eigene Notation haben.
Ansonsten Mengen und Listen verhalten sich wie normale Objekte.
Die Initialisierung darf ich aber auch In derselben Teile machen die die Generation.
Ja. Genau, also das kann ich ja auch.
Ja. Das darf ich halt auch machen. Das ist
vollkommen in Ordnung. Genau. So. Ich weiß,
in drei Minuten ist regulär Schluss, aber je länger,
also je lauter ihr seid, umso länger mache ich.
Ach, perfekt. Ja. Immer mal kurz ein Telement
von der Situation
Es ist nicht gut. Oh. Dabei ist ich jetzt tatsächlich nicht auswendig,
wie die... Ed, ich glaube, das ist...
Es war nicht schade. Genau. Eine bestimmte Stelle an
diesem Gebäude. Es ist Ed ist ein paar Daten,
wenn du zwei Kanalbieter anbietest. Der erste, der war,
wie gesagt, in der Position, ist das neu.
Und ich hatte nie einen Klipplehrer, einen auf dem Klo.
Der hat schon Runde, Klammer
Klammern, noch eines, 1,100 wäre eine B-Mail-Position 1,
die Zahl würden entscheiden. Wenn du keinen B-Mail-Position rüber,
ein einfacher, ein Einblick, da gibt es,
da wird einfach hinten eine angehängt.
Genau. Dann haben wir dich wieder erledigt an dem Bruder.
Genau. Woher weiß man denn, wer keiner hinsetzt?
Der Hund. Das ist eine sehr gute Frage.
Das habe ich echt noch nie bedacht. Also okay,
ich sage mal so, das ist eine,
das ist eine Frage
Die kann man, die kann man sehr gut zu Hause,
bei sich in den Clips einfach mal rumprobieren, aber die ist jetzt nicht,
ich sag mal so, nicht relevant fürs Programmierdegrad.
Also da müsst ihr euch keine Sorgen machen,
dass ihr jetzt da irgendwie so richtig,
dass ihr da irgendwie so richtig trickreichst rausfinden müsst,
ja, wie sorge ich denn dafür, dass ihr merkt,
dass ich jetzt Index meine oder ob ich jetzt denen sage,
ja, Remove mal, dass diesen Wert aus der Liste.
Aber gut. Also wenn ihr merkt, so ah,
das ist so kompliziert, dass das noch nicht mal zwei Leute,
die schon länger Apol treuen müssen, dann könnt ihr davon ausgehen,
dass das nicht im Programmierik-Tat als Falle gestellt wird.
Genau. So, jetzt kommt noch die allerletzte Konstrollstruktur.
Ah ne, nicht die allerletzte. Sondern es kommen noch
um so ein paar Kontrollstrukturen, die ihr wissen solltet.
Und zwar, es könnte dran sein, dass ihr eventuell einen Switch machen sollt.
Beim Switch müsst ihr ja immer so ein bisschen,
müsst ihr halt immer gucken, okay,
da wird meistens sowas stehen wie,
Schreiben Sie eine Switch-Anweisung mit der Variable Zahl und den folgenden Cases bei Case Isle,
bei Case 10, mach X bei Case 20,
mach Y und bei Case 30 mach Z.
Und es könnte eventuell noch als Zusatz kommen und sorgen Sie dafür,
wenn ein Case, wenn ein Case zutrifft,
dass auch nur diese ausgeführt wird.
Das heißt, wenn so eine zusätzliche Anweisung kommt,
dass Ja, wirklich nur immer das ausführen soll,
was für diesen Case wichtig ist. Da müsst ihr halt immer,
dass es dann sozusagen das Keyword für euch, dass ihr wisst,
okay, immer wenn ich einen Case schreibe und dann die weilige Zahl.
Das ist schon vorbei, tut mir leid. Genau. Das heißt,
wenn ich diesen Case 10 habe und er sagt,
es soll wirklich immer nur der jeweilige Case ausgeführt werden,
das ist der Moment, wo ich,
wenn ich das lese,
okay,
ich muss in jedem Case Statement auch immer dieses Break reinmachen
In der Karte wegschreiben? Nö, dann einfach nicht. Oder im Zweifel,
vielleicht nochmal nachfragen und wenn sie einen das nicht explizit sagen,
dann einfach das machen, was da dasteht.
Also wenn es keine glasklare Antwort gibt, dann ist das wohl schon so gewollt.
Genau, ja. Wenn wir jetzt aus Gründen einen Return haben,
dass sie dir dort entscheiden müssen, mir danach nochmal ein Break schreiben oder so.
Nein, nein. Also ein Return sorgt ja dafür,
dass der, dass die Ausführung sozusagen nicht abgebrochen wird,
aber halt dort beendet wird und dann der, der zurückgegeben wird.
Das heißt, danach muss ich nicht mehr einen Break schreiben,
weil alles, was nach dem Return kommt,
in derselben Ebene ist dann nicht mehr erreichbarer gut.
Wäre das dann ein Fehler, wenn man nach dem Return
noch einen Break schreiben würde oder nicht?
Ich weiß es nicht. Also da weiß ich wirklich nicht,
ob das eventuell, ob sie das ein Böse ankreiden oder nicht.
Im Endeffekt wird es dann ja,
wenn es dann beim Return dann schon rausspringt,
ja eigentlich dann noch keinen Unterschied machen,
ob das... Ja, aber das Problem ist,
das Problem ist, der Java-Compiler wird sagen,
das ist falscher Code,
weil er sagt,
diese Zeile Break ist nicht
erreichbarer Code
Deswegen, da muss man,
da weiß ich es tatsächlich nicht, inwiefern das gewertet wird.
Aber ich muss ganz ehrlich gestehen, ich glaube,
ich habe noch nie eine Switch-Anweisung gesehen.
Das ist nur die Verbreitung. Ja. Frankeschön.
Wir sind die Kohle
Ja. Und ich bin gefallen. Ich habe ein,
zwei Tage, was trotzdem Musik geholfen hat,
an dem Play. Nein. Dann nicht. Also,
also Simmy Colon ist wirklich nur als Abschluss für dieses Break.
Für dieses Case 10 Doppelpunkt, du brauchst keinen Semikolern,
weil nämlich dieser Doppelpunkt-Operator schon sagt,
das ist jetzt die Ende der Zeit,
das ist jetzt das Ende der Zeile,
das Ende des Ausdrucks
Ja. Okay, weitere Fragen? Ja. Zürcher Weise ein Jahr,
wir brauchen ja keinen Default der, ja, der beiden Konventionen.
Das heißt, muss ich denn überhaupt nicht schreiben,
wenn es nur schreibt, mir das so zu anwalten?
Also, wenn es nicht explizit drinsteht, brauchst du es
nicht zu schreiben. Ich habe es hier nur aufgeführt,
damit ihr, falls da irgendwie als im Text drinsteht,
ja, uns, falls keiner der Cases zutrifft,
macht das und das, dass ihr wisst,
okay,
das ist das Keyword dafür,
ist dann Default Doppelpunkt
Genau. Okay. Weitere Vergetanheiten? Ja,
also hinter die 10 Doppelpunkte muss ja kein Silikon ran.
Aber wenn wir jetzt eine Anweisung da drin stehen hätten,
im Nachtelfen stehen und aber keinen Rake hätten.
Nein, da wirst du dann noch wohlsinnig. Ja,
genau, genau. Also nimmter jeder Anweisung muss immer ein Simikola.
Egal wo es steht. Okay. Weitere Fragen dazu.
Ich sehe nicht, okay. Ja, gibt es noch
Fragen? Beziehungsweise Armin fällt jetzt gerade auf.
Das ist eine sehr
Das ist sehr gut aufgepasst. Okay, und zwar,
weil es mir, glaube ich,
weil es früher halt nie Probleme damit gab.
Es könnte sein, dass sie noch konfrontiert werdet mit einem einfachen If.
Das heißt, es könnte sein, dass gesagt wird,
okay, schreiben Sie ein If-Statement. Das heißt, okay,
ich weiß, okay, es soll ein If-Statement sein,
warum ist das nicht so dick?
Okay. Ich schreibe einfach groß genug,
wenn man es mal sieht
Das heißt, okay, wenn ich ein If-Statement schreiben soll,
dann ist immer das Erste, was ich schon mal schreiben soll,
okay, ein If. Und dann öffne ich die Klammern
. Und dann habe ich halt hier meine Bedingung.
Und einen Textkonzern zum Beispiel stehen, ja,
und die Bedingungen für dieses If-Statement soll sein,
sei es Seitenanzahl, soll die Seitenanzahl,
soll kleiner sein als vier
Ja. Dass man halt sowas entsteht. Da muss man halt einfach aufpassen,
okay, man muss die Übersetzungsleistung,
die man da halt machen muss, okay, If-Statement heißt,
ich muss, ich fange die Zeile an mit dem If,
Klammer auf.
Und dann muss da eine Bedingung stehen.
Und die Bedingungen bestehen in der Regel da draus,
irgendwas soll kleiner sein, gleich sein, größer sein.
Da müsst ihr dann halt einfach nur die weilige,
das jeweilige Kryogudilmaul finden, was dann halt,
was sie aber auch aus der Mathematik kennt
Ihr habt ja hoffentlich alle irgendwie DM bestanden,
dann solltet ihr euch ein kleiner, gleich, größer,
gleich nicht so viele Probleme bereiten.
Ja? Meine Herrschmüll. Das ist eine Hashmap.
In programmiere die Daten? Also das ist das Südbasnetbekommen.
Das ist einfach psychisch müßig. Das ist spannend. In der Vorlesung sollte ich dir,
ja gut, also was ist eine,
also eine Hashmap und Hashset ist,
wenn man jetzt einfach mal komplett außer Acht lässt,
wie das intern funktioniert, nichts anderes als auch eine Eine Liste.
Nur, dass man jetzt zum Beispiel sagt, okay,
wenn ich jetzt habe eine Hashmap habe,
dann ist der einzige Unterschied zu einer Liste,
dass ich in diesen Krokodile-Klammern zwei Werte drin stehen habe.
Zum Beispiel in diesem Fall sage ich es jetzt okay,
dass das erste Element, das ist der Schlüssel,
das zweite, was könnten wir machen,
wenn Switch auf hier rechts
Und das ist das Element. So, und der einzige Unterschied ist damit,
ist jetzt bei einer Hashmap oder bei einer Hash-Tabelle,
ist einfach nur, dass wir jetzt sagen, da explizit angeben,
dass wir nicht irgendwie mit einer Zahl das durchindexieren wollen.
Bei einer Liste ist ja einfach gesagt, okay,
ich indexiere das durch mit, also wenn wir uns das hier,
bei List ist es ja so, dass ich einfach nur sage,
okay, Am Index 1 ist jetzt, ist jetzt etwas an der Index,
äh, an der NX0 ist etwas, nichts.
Eins ist etwas, so. Und das,
was ich jetzt bei der Hashmap mache, machen kann,
ist, wenn ich jetzt zum Beispiel diese Hashmap mache und dann sage ich zum Beispiel,
okay, füg mal was an dieser Hashmap zu,
dann kann ich jetzt sagen, okay,
ich möchte als Schlüssel nehmen, Klar, und sagt dann,
okay, ich möchte die Zahl 2 speichern.
Also das Einzige, was sich unterscheidet bei Hashmaps,
ist, dass ich sozusagen den Schlüssel,
mit denen ich auch die Elemente in dieser Datenstruktur darauf zugreife,
dass ich das verändern kann.
Ansonsten fällt sich das eigentlich genauso gleich wie eine Liste.
Und wenn ihr ein Ashmap,
und wenn ihr in der Hashmap irgendwie im Diktat verwendet,
verwenden sollt, dann sollte es eigentlich eine Java-Doc davon geben.
Oh, man ignoriert das auch wie eine Liste,
nur dass man dann halt Dass man da halt zwar auch zwei Werte drin hat.
Das heißt, eine Dekaration würde dann halt so aussehen.
Hashmap. Also wenn das jetzt hier unsere Zeile ist,
Hashmap und dann String.
Komm mal, Inhitcher. Map. Und dann gleich.
Erfahren gleich.
New. Hashmap
Danke. Also, kann man mal von Klapper zu, ja.
Aber es ist jetzt nicht großartig schwieriger als wie eine Liste. Also,
es ist mal wieder so ein schönes, großes Wort,
was einen erstmal verängstigt, weil man nicht weiß,
hä, was ist ein Hashmap?
Aber ihr müsst ja auch gar nicht verstehen,
was das ist, sondern nur einfach,
wie sie funktioniert.
Kannst du vielleicht nochmal
das so rufen
Keine Sorge. Auch das hier kommt, wird hochgeladen,
falls sie das nochmal nicht in Fotoqualität haben wollen.
Okay. Genau. Ich würde jetzt einfach mal sagen,
wir machen jetzt hier Schluss und ich werde mich drum kümmern,
als auf der Webseite normalen PDF hochzuladen,
wo es dann um die Vorschleife und eine weitere Vorschleife geht.
Das werde ich diesen Abend noch machen.
Und da ist hier das dann euch nochmal anschauen könnt,
weil ich glaube, jetzt ist es langsam auch die Luft raus,
weil alle schon gehen wollen