Ja, hi,
zum zweiten Video des praktischen Teils zur SE2-Vorlesung 1,
nachdem ich mich jetzt das letzte Mal im ersten Video ziemlich dadurch blamiert habe,
indem ich am Anfang ganz großspurig gesagt habe,
ich nehme jetzt mal das Bild von mir weg,
damit man den Code besser sieht und am Ende gesagt habe,
hey, jetzt seht ihr mich wieder und ich war irgendwie die ganze Zeit da,
weil das Umschalten nicht geklappt hat, wie jetzt halt Video 2,
ich werde das irgendwann im Laufe dieses Videos nochmal versuchen wegzumachen und hinzumachen,
wenn es dann nicht geht,
müsste mich halt die ganze Zeit irgendwie ein Bild ertragen.
Ich habe gesehen, das Bild hat so ein ganz klein bisschen verdeckt,
wenn ich Apply and Close geklickt habe,
aber ich glaube Apply and Close findet ihr noch ganz alleine.
Inhaltlich soll es in diesem Video darum gehen,
wieso die UML-Pfeile für Klassendiagramme gesetzt werden,
welche wir denn als Erinnerung noch aus SE1 noch kennen,
wie wir die benutzen und wie wir dann eben aus dem vorhandenen Code von dem Projekt,
das wir jetzt gerade neben dieser Mediathek So,
nach und nach dieses UML-Klassendiagramm bauen können.
Und eventuell werde ich dann auch noch mal was zu
dieser Finde, die Testklassenaufgabe von dem Aufgabenblatt machen.
Ziemlich wahrscheinlich werde ich, würde die Zeit dann zu knapp sein,
um sinnvoll noch auf SE1-Wiederholung einzugehen. Aber wie gesagt,
wir haben fünfmal die Woche eine Fragestunde und dann könnt ihr
ja alles mögliche fragen.
Auch SE1-Stoff. Zu den UML-Pfeilarten, da kennen wir
im Prinzip drei
Wir jetzt mal so ein Malprogramm aufgemacht. Ich habe auch festgestellt,
dass es ganz fürchterlich ist, mit dieser Maus zu malen,
aber ich probiere es halt trotzdem.
Die erste Pfeilart ist ein, wow, ist ja scheiße.
Entschuldigung, schlecht meine ich. Gestrichelter Pfeil, mit offener
Pfeilspitze. Das sieht so aus. Die zweite Pfeilart,
das hier ist eine allgemeine Abhängigkeit. Die zweite Pfeilart symbolisiert
eine strukturelle Abhängigkeit. Das ist eine durchgezogene Linie mit offener Pfeilspitze.
Und die dritte Pfeilart, die wir noch aus SE1 kennen,
ist wieder so ein gestrichelter Pfeil
Mit einer geschlossenen Pfeilspitze. Und das symbolisiert Implements,
das heißt also, wenn eine Klasse ein Interface implementiert,
geht von dieser Klasse zu diesem Interface diese Art von Pfeil.
Ganz pragmatisch nehmen wir die Pfeilarten oder benutzen wir die Pfeilarten
wie folgt. Angenommen, wir haben zwei Klassen,
A und B und in Klasse A gibt es eine Exemplarvariable vom Typ B,
dann hätten wir eine strukturelle Abhängigkeit und würden von Klasse A zu Klasse
B ein Pfeil mit einer durchgezogenen Linie und offener Spitze ziehen.
Angenommen, wir hätten in Klasse A eine Methode mit einem
formalen Parameter zum Typ B oder eine Methode,
die einen Rückgabetyp von Typ B hat,
dann hätten wir eine allgemeine Abhängigkeit und würden halt so eine Art von Pfeil nehmen und wie gesagt,
das hier ist einfach, wenn im Klassenkopf Implements steht.
Das ist im Prinzip unsere pragmatische Herangehensweise daran Und jetzt
würde ich eigentlich ganz gerne das an einem konkreten Beispiel,
wie es halt auch auf dem Aufgabenblatt gefordert ist, zeigen.
Ich gehe dazu wieder in meinen Eclipse und unternehme einen weiteren,
hoffentlich diesmal erfolgreichen Versuch, mich aus dem Bild zu nehmen.
Vielleicht ist es jetzt gelungen, ansonsten lacht ihr wahrscheinlich jetzt schon.
Muss ich mit leben. Genau,
ich würde das im konkreten Beispiel hier machen,
ich mache die hier mal
Close all, ich mache hier mal alle zu,
weil ich hier was speichere, nein, die Select All, sex selected.
Und ich würde da mit dem Interface-Verleihservice anfangen. Man sieht hier,
das wollte ich kurz nochmal erwähnen, an der Benahmung,
dass wir Klassen,
die ein Interface implementieren,
so nennen wie das Interface mit Impel hinten dran und
das Interface an sich hat keine Erweiterung
Das ist eine Art, das zu machen. Üblicher ist wahrscheinlich draußen,
zumindest in den Firmen, in denen ich bisher Werkstudent war,
dass man ein Interface dadurch kennzeichnet,
dass vorne ein großes I ist, also sowas wie Ei,
Final Service, das implementierende Klasse dann, keinen Zusatz bekommt.
Bei uns in SE2 ist es eben so rum.
Ich klicke jetzt hier zweimal drauf und habe
dieses Interface und Hier oben sehen wir gleich zwei Schlüsselwarte.
Implements. Achso, ich habe auch für Live-Service-Implement geklickt.
Deswegen wundert es mich auch, warum der Implement bei einem Interface steht.
Okay, jetzt sind wir in dem richtigen.
Hier haben wir Extense Observible Service. Extense ist ein Vererbungsfeil.
Der sieht so aus wie der Implementationsfall nur mit einer durchgezogenen Linie.
Vererbung bekommt ihr erst später. Müsst ihr euch jetzt nicht
darum kümmern
Und dann gucken wir uns mal an, was so in
dem Interface drin ist. Da sind ja Operationen drin,
also Methoden, Köpfe, ohne Rümpfe, die nennen wir Operationen.
Und wir haben hier einen formalen Parameter vom Typ Kunde.
Wir haben eine Liste mit Elementtyp Medium und wir haben einen
weiteren formalen Parameter vom Typ Datum. Also wissen wir schon,
dass wir Ein Kästchen malen für Verleihservice und markieren dieses Kästchen durch,
also Feist, Verleihservice und wir markieren, dass es ein Interface ist.
Und wir müssen schon mal drei weitere Kästchen malen.
Kunde, Medium und Datum. Und weil wir hier ja
formale Parameter von diesen Typen haben, würde von Verleihservice,
zu den drei Kästchen Kunde,
Medium und Datum eine gestrichelte Linie mit offener Feilspitze gehen
Und normalerweise, wenn man systematisch davor geht, würden wir
einfach weiter scrollen, mache ich jetzt auch mit euch.
Okay, hier ist wieder Kunden und Medium, haben wir schon.
Hier ist Medium, haben wir auch schon Rückgabetyp Kunde.
Kunde haben wir aber auch schon. Hier wieder
formaler Parameter-Kunde, Rückgabetyp, eine Liste von Medien.
Und hier haben wir jetzt als Rückgabetyp eine Liste von Verleihkarten
oder eine Liste mit Element-Typ Verleihkarte.
Das bedeutet, dass wir jetzt noch ein viertes Kästchen
malen müssen
Ähm, Verleihkarte und dann würde eine gestrichelte Linie ebenfalls von Verleihservice zu Verleihkarte gehen.
Jetzt gucken wir hier weiter durch. Nichts Neues, Medium und Atum,
wieder Medium, Medium, wieder Medium, Kunde, Medium.
Okay, Verleihkarte. Also haben wir alles,
was wir hieraus ablesen können, äh, gefunden.
Das heißt also, die vier Klassenkunde, Medium,
Verleihkarte und ich glaube, das war Datum oder irgendwie sowas.
Datum, genau. Diese Klassen haben wir als Gästchen gemalt und haben
eine Strichwürfellinie mit offener Pfeilspitze gemacht. Und die übliche Vorgehensweise ist,
wir suchen uns jetzt eine von diesen Klassen aus,
gucken uns die näher an und gucken,
was finden wir denn da so.
Generell gilt die Java vorgefertigten Klassen, zum Beispiel String,
ist ja auch eine Klasse.
Die braucht ihr nicht zu betrachten. Also ihr müsst jetzt
nicht das gesamte Java-Objektgeflecht da aufmalen,
das würde auch
echt groß werden
Sondern ihr nehmt eigentlich nur Klassen und Interfaces,
die ihr hier auch in diesem Package-Out-Explorer drin habt.
Das Beispiel noch ein ganz klein bisschen weiterzuführen,
würde ich jetzt mir, was haben wir da unten gehabt?
Verleihkarte vornehmen und da dann noch mal kurz sagen,
was man da macht. Und dann habt ihr das Prinzip
verstanden und so, könnt ihr euer UML-Diagramm relativ leicht malen.
Jetzt sind wir hier bei Verleihkarte.
Wir haben hier
drei Exemplarvariablen
Von einem Typ, der hier im Package Explorer auch als Klasse existiert.
Nämlich Datum, Kunde und Medium. Das heißt,
wir wissen, wir müssen von Verleihkarte zu den Kästchen,
zum Pästchendatum durchgezogene Linie mit offener Pfeilspitze malen,
mit Kunde und Medium machen wir das Gleiche.
Und dann gucken wir mal, was uns Verleihkarte sonst noch
so bietet, was da noch so drin ist.
Wir haben hier wieder Kunde, Medium, Datum.
Das heißt also, wir haben hier oben Drei Exemplarvariablen von dem Typ.
Und hier unten drei formale Parameter von dem Typ. Und ich hatte ja am Anfang gesagt,
wenn es ein formaler Parameter ist, eine gestrichelte Linie mit offener Fallspitze,
wenn es eine Exemplarvariable ist, eine durchgezogene Linie mit offener Pfeilspitze,
wenn ihr beides habt, dann overruled die Exemplarvariable,
mit der durchgezogenen Linie, die den formalen Parameter,
mit der gestrichelten Linie.
Das heißt,
ihr müsst dann nicht noch irgendwie zwei Linien malen oder so,
sondern wenn ihr den Typ schon als Exemplarvariabler habt,
dann zieht ihr das Ding mit einer durchgezogenen Linie
auf einer Pfeilspitze
Und seid dann mit der Klasse fertig. Und dann gucken
wir mal, was es hier sonst noch so gibt.
Hier sind wir wieder bei Datum, Kunde, Medium,
Geldbetrag. Das hatten wir bisher noch nicht.
Das ist der Rückgabetyp dieser Methode. Und dementsprechend malen wir
ein Kästchen als Symbol für die Klasse Geldbetrag.
Und weil es ja der Rückgabetyp ist,
da ist die Pfeilsorte im Prinzip die gleiche wie bei einem
formalen Parameter
Malen wir von Verleihkarte eine gestrichelte Linie mit offener Pfeilspitze zu Geldbetrag hin.
Und kommt sonst noch was und ist sowieso ein primitiver Datentyp.
Das war es hier im Prinzip mit Verleihkarte.
Vielleicht ganz kurz noch mal zu Verleihservice, Impel,
damit wir noch die dritte Pfeile hat,
ein einziges Mal gesehen haben.
Hier oben dieses Extense ignoriert ihr erst mal,
weil ihr das noch gar nicht wirklich kennt
Oben steht Implements Verleihservice und dementsprechend würde von Live-Service Imple
zu Verleihservice eine gestrichene Linie mit geschlossener Feilspitze gehen.
Und nach dem Prinzip würde man eigentlich an irgendeiner Stelle anfangen.
Ich habe jetzt bei einem Interface Verleihservice angefangen,
ihr könnt auch irgendwo anders anfangen,
aber ich fand den Einstiegspunkt ganz gut und arbeitet euch dann von den Klassen,
die ihr da findet, immer weiter zu den Klassen,
die dann in diesen Klassen gefunden werden und so weiter und so fort.
Und dann habt ihr
irgendwann dieses OML-Klassendiagramm
Gemalt. Das wäre es eigentlich auch tatsächlich zum UML-Klassendiagramm, was ich erzählen wollte.
Ich würde jetzt noch ganz kurz in der Zeit,
die noch ist, was zu der Aufgabe erzählen,
in der es darum geht, dass ihr irgendwelche Testklassen finden solltet.
Ich hoffe, ich spoilere die jetzt nicht zu sehr,
aber es ist jetzt auch nicht wirklich ein allgemeineres Beispiel zu finden,
bei dem ihr Das Prinzip lernt,
ohne dass ich jetzt genau diese Aufgabe gesagt habe,
aber wahrscheinlich wird es euch nicht stören,
wenn ich jetzt genau diese Aufgabe sage.
Also, Teil dieser Aufgabe ist es,
oder die Aufgabe besteht darin, dass ihr Testklassen finden solltet.
Da gibt es die simpelste Methode, ganz offensichtlich gibt es
hier einige Klassen, in denen das Wort Test vorkommt.
Den wundert es, wenn man da draufklickt,
dann seht ihr hier auch eine Annotation,
at test und das sind Testklassen.
Ihr könntet also jetzt einfach ganz trivialerweise hingehen und sagen,
wir gucken hier überall mal durch,
wo denn so Test steht
Und zählen. Und macht euch irgendwie eine Strichliste,
weil ihr nicht genug Finger habt oder irgendwie sowas.
Das geht, das beantwortet die Aufgabe auch, weil da ja,
glaube ich, eine Zahl gefragt ist, ist aber einigermaßen unbequem.
Stattdessen sehen wir hier oben im Kopf ja auch schon das Wort Search,
das könnte uns ja irgendwie einen Hinweis geben,
dass wir damit weiterkommen
Das, was man dann trivialerweise,
also was man dann vielleicht als ersten Schuss aus der Hüfte probieren könnte,
wäre, wenn man hier auf Search geht,
dass man hier oben Test eingibt.
Und wenn wir dann sagen, Search... Ah ja,
ich gehe hier nochmal auf Search.
Hier könnt ihr auch noch anhaken, Case Sensitive.
Das heißt also, ob es auf große Kleinschreibung achten soll.
Wenn wir uns dieses Search-Ergebnis jetzt angucken,
dann sehen wir hier
75 Referenzen, das kommt einem jetzt ziemlich viel vor,
liegt daran, dass es auch viel ist.
Jetzt könnte man natürlich da durchgehen und also es liegt einfach daran,
dass hier ganz oft das Wort Test drin vorkommt und dass
die IDE dann einfach nach dem Schlüsselwort Test sucht.
Ein bisschen schlauere Vorgehensweise wäre, wenn man sich in Erinnerung ruft,
dass ich mache jetzt mal,
ich schließe mal
alle anderen
Dass wir hierfür Imports brauchen. Hintergrund von diesen Imports ist,
es gibt ganz, ganz, ganz viele Java-vorgefertigte Klassen oder
jetzt hier von J. Unit vorgefertigte, für J. Unit vorgefertigte Stückklassen.
Wenn man sich die alle gleichzeitig in Rechner laden würde,
wäre das Ding platt und man hätte überhaupt nichts mehr,
was man damit machen könnte.
Deswegen werden nur die allerwichtigsten vorgefertigten Klassen importiert in das Projekt und für andere,
die man braucht, Würde man dann so einen Import machen?
Ja, und wir haben mal so ein kleines Plus,
das heißt, es sind mehrere Imports, wenn wir draufklicken,
dann sehen wir, dass hier sehr viel von J. Unit importiert wird.
Einzelne Dinge, aber auch J. Unit an sich.
Und wenn wir jetzt dadurch sehen, dass offensichtlich Testklassen diesen Import brauchen,
dann können wir uns hier den einfach mal markieren.
Und das dann hier in Search eingeben. Und wenn wir
uns markiert haben, ist es offensichtlich schon drin.
Umso besser. Und wenn wir jetzt hier Search klicken,
dann sehen wir gar nichts.
Und das macht mich jetzt gerade ein ganz klein bisschen nervös,
weil wir sollten was sehen, weil offensichtlich ist Import vorhanden.
Ich gehe nochmal auf.
Gib das hier ein. Wundere mich gerade, warum das
Ganze nicht funktioniert. Jetzt funktioniert es aus irgendeinem Grund.
Offensichtlich war das, es stand vorher schon drin,
hat aus irgendeinem Grund nicht richtig geklappt.
Keine Ahnung, warum. Und hier sehen wir jetzt 17
Matches. Und dann können wir uns ja mal angucken,
ob jetzt hier unten zum Beispiel bei hier unten irgendwo was
doppelt ist.
Hier stehen zwei Matches
Dann kann man ja aus den 17 und einem Duplikat schon relativ gut absehen,
was da am Ende für eine Zahl rauskommen soll.
Genau, das war das Letzte,
was ich euch für heute noch zeigen wollte.
Ich hoffe, jetzt könnte ich mal versuchen,
mich wieder einzublenden, falls ich mich vorher ausgeblendet habe.
Ich hoffe, das war heute so einigermaßen okay.
Wie gesagt, mit der Technik, das ist mir alles
neu und ich habe das erst seit gestern mal ausprobieren können.
Ja, das war es von meiner Seite aus
und dann bleibt gesund und noch eine schöne Übungswoche