So, einen schönen guten Tag. Ich begrüße Sie alle.
Ich freue mich, dass Sie da sind, trotz des schönen Wetters.
Ich bin hier der Erste in der Reihe, die in SE1,
konnten Sie mich im letzten Semester schon zwei, drei Termine sehen.
Wir werden in diesem Semester,
werde ich ungefähr die Hälfte der Veranstaltungen hier halten,
den nächsten Block, glaube ich, bis auf einen Termin.
Wir sind jetzt die nächsten fünf Termine, dann wechseln.
Ich wechsle mich immer so ein bisschen mit Guido Kritzern ab.
Fred wird heute auch noch kommen, der hat noch eine
Besprechung, ein paar Minuten später da sein.
Ansonsten ist alles wie immer
Außer das Thema ist neu und das schöne Wetter ist neu. Aber leider,
wie Sie schon wissen, vielleicht wird es ja über Pfingsten das übliche,
kalte, graue, keine Ahnung, Frühlingswetter. Ja,
wir haben heute, vertiefen uns heute in das Thema Wamm,
Werkzeugmaterialansatz und fangen damit an oder machen damit weiter,
was so der Kern von SE2 ist.
Der Kern ist ja der,
ihnen das Wissen zu vermitteln, wie strukturiere ich Systeme,
wie denke ich Entwurf, wie schaffe ich eine Lösung,
die am Ende eine technische Lösung darstellt für ein fachliches Problem.
Hallo Fred, ich habe dich schön angekündigt, lass es dir schmecken.
Ja, wir machen solche Systeme oder finden solche Systeme
fast überall an. Wir finden solche Systeme an,
weil Software fast überall ist, vom ABS unseres Autos,
über die Kamera, die wir haben,
ja natürlich im Computer,
in einer Bank,
in einer Werkzeugmaschine
fast überall
Aber die Methoden unterscheiden sich, je nachdem, was für uns wichtig ist.
Und deswegen sucht man von den Methoden her etwas,
versucht man das ein bisschen einzuschränken. Eine ganze allgemeine,
was ist Methode? Methode ist ein strukturiertes Vorgehen,
wie man auf eine gute Weise zu einer Lösung kommt.
Natürlich kann jeder von uns irgendwie sich hinsetzen und etwas ein
Einfaches bauen ohne eine Methode. Ja, zum Beispiel,
ich sag mal, ich möchte mir ein Gewächshaus bauen.
Ich denke mir, okay,
für Tomaten ist es in Hamburg nicht lang genug warm,
dass die richtig, dass sich da zwei Generationen machen kann.
Ich baue mir da irgendwas und denke mir, klar,
so oder Folie, irgendwie muss das zu sein, die Sonne muss durchkommen.
Ich kriege das hin, auch ohne eine besondere Vorgehensweise
zu machen. Es wird schon ein bisschen schwieriger,
wenn ich einen Flieger bauen will, der tatsächlich fliegt.
Daher brauche ich schon ein bisschen mehr Wissen,
dass das nicht nur ein Ding ist, was abstürzt.
Das merkt man schon beim Papierflieger, dass das so
ein bisschen trickierst. Und je komplizierter was ist,
desto wichtiger ist es, eine Methode zu haben.
Ein Vorgehen, was erprobt ist. Und dieses Vorgehen geht
immer nur für bestimmte Ziele. Und deswegen steht hier
dran,
interaktives Anwendungssysteme
Diese Methode, über die wir hier sprechen,
die Methode mit den Abkürzungen WAM-Werkzeugautomatmaterial,
ist gedacht für oder hat besonders ihre Stärken für Systeme,
mit denen Menschen arbeiten.
Interaktiv heißt, der Mensch arbeitet mit der Technik.
Das ist nicht der Fall, zum Beispiel beim ABS ihres Autos.
Bei der Waschmaschine, da ist natürlich irgendwo der Mensch dran,
aber die Beschniedung ist schon sehr eingeschränkt.
So ein paar Knöpfchen in den Drehschalter, eine Stadtknopf.
Beim Fahrstuhl ist auch ein Computer drin,
aber davon merken wir nicht
so sehr viel
Aber ein interaktives System ist so etwas wie ein Terminal für
ein Busticket beim HVV. Das, was Sie am Handy haben,
ein System, um eine Reise zu buchen,
an einem Bildschirm, eine App, ein webbasiertes System.
Alles, das sind interaktive Systeme. Wir konzentrieren uns jetzt
in dieser Veranstaltung auf solche interaktiven Systeme.
Dafür, es gibt keine allgemeine Methode, eine Methode,
die alles kann, ist keine Methode mehr.
Die ist einfach nur, schaltet dein Gehirn ein und mach.
Wir wollen eine Methode haben, die uns hilft,
solche Systeme zu gestalten
Und zwar so zugestalten, dass der Mensch damit gut arbeiten kann. Das heißt,
es hat etwas mit den Menschen zu tun und wir werden auch heute merken,
und die nächsten vier, fünf Veranstaltungen,
was der Mensch damit zu tun hat und der Kern ist eigentlich,
wir wollen strukturieren,
wie denken wir die Aufgabe von Seiten des Menschen,
um die Technik daran anzupassen.
Dass unser System soll sich auszeichnen von der Walde- und Wiesenlösung,
die jeder entwerfen kann,
der einfach nur schlau nachgedacht hat und sein Köpfchen eingeschaltet hat.
Unsere Motivation steht hier, Softwarequalität, darüber werden wir
heute kurz sprechen, Qualität, was ist das?
Das gehört zur heutigen Gliederung und wir wollen Einen ersten Einstieg machen in Konstruktionsregeln.
Diese Konstruktionsregeln werden wir heute erst so im Groben,
die ersten ein bisschen besprechen.
Dann wird uns Fred zeigen, wie das konkret aussieht.
Interaktion, interaktiv heißt Benutzer plus Technik. Und deswegen spielt
der Mensch eben eine Rolle. Die meisten solcher Systeme,
natürlich werden sie sagen, auch beim ABS gibt es irgendwie
eine Interaktion mit den Menschen.
Es muss ja jemand da sein, der die Bremse tritt,
sonst würde das ABS nicht funktionieren.
Und es muss irgendwie Eis sein,
damit das rutscht und wie auch immer das ABS funktioniert
Wir konzentrieren uns auf Systeme, die eine grafische Benutzerschnittstelle haben.
Grafisch im Sinne von, wir haben ein Display,
das zeigt uns etwas. Vielleicht fällt Ihnen bei der Gelegenheit,
fangen Sie an zu überlegen, was gibt es denn noch für Benutzerschnittstellen?
Tatsächlich gibt es noch anderes. Für das Auto erprobt man
zum Beispiel solche Sachen, die Spurführung, dass man,
wenn man aus der Spur kommt, dass dann das Lenkrad ein bisschen fribriert.
So als wäre da eine Markierung auf dem Boden.
Sie kennen das vom Handy her, dass es auch in
ihrer Tasche fribriert. Das ist auch eine Form der Interaktion
, um die geht es nicht
Weil wir uns bei dieser Methode auch damit beschäftigen wollen,
wie die grafische Benutzerschnittstelle aussieht. Ja, so,
hier sind noch ein paar Sachen,
die unten angezielt angewählt, wo es darum geht,
wie sind Videodateien aus, wenn die verarbeitet werden,
das spielt erstmal nicht so eine große Rolle.
Wir können mal hier das zeigen,
dass die Leute im Video das auch sehen. Also,
wenn es wirklich nur um die Verarbeitung geht oder eine komplizierte Simulation,
die am Ende eine Wetterkarte auswirft, da steht kein Mensch davor.
Es gibt zwar auch eine Schnittstelle,
aber es steht kein Mensch davor,
der mit dem System
in der Aktion tritt
Das ist der erste Punkt. Wir kümmern uns um interaktive
Systeme. Der zweite Punkt ist, wir müssen unterscheiden,
was sind fette oder reiche Systeme im Englischen Rich?
Und was sind die Schlanken, die leichten Systeme?
Slim, ja, die Unterscheidung ist deswegen wichtig,
weil wir daran nachher entscheiden, wer tut etwas?
Wir tun, wir verarbeiten, wir teilen die Verarbeitung ein.
Und zwar, die ersten Systeme sind die,
die man typischerweise auf seinem Computer installiert
Das, wie bezeichnet man als Rich Clients oder auch Desktop-Systeme,
Desktop, weil sie auf dem Schreibtisch stehen, typischerweise alles,
was ich dort habe, ist da und was dort passiert ist,
die Datenverarbeitung passiert auf dem Rechner.
Also alles, zum Beispiel bei mir ist das hier so,
was hier gerade läuft, ist PowerPoint und alles,
was ich habe, die Dateien, die Darstellung,
vielleicht auch ein bisschen Animation, passiert alles hier drauf.
Der Gegensatz dazu ist,
wenn die Verarbeitung woanders passiert und der Client,
das heißt das Ding,
was am Nutzer nahe des Nutzers ist,
wenn das
nur ganz wenig enthält
Das ist zum Beispiel der Fall, wenn sie eine App haben,
wo sie auf ihrem Smartphone etwas mit der Bank machen.
Sie machen eine Überweisung oder sie kaufen ein Musikstück oder was auch immer.
Die eigentliche Verarbeitung findet woanders statt. Und sie haben hier
nur eine kleine Schnittstelle. Es wird ihr nur etwas gezeigt.
Die Verarbeitung ist woanders. Und deswegen heißt das auch dünn
oder schlank, weil dieser Sin-Client eigentlich nicht viel Verarbeitung macht.
Ich will nicht sagen, er macht gar nichts,
aber er macht wenig. Als Beispiel steht jetzt hier auf
der Folie etwas, dass wir das im Browser haben
Auf der Webseite zum Beispiel, das würde das Gleiche passieren,
Sie kaufen ein Musikstück auf Ihrem Computer, im Browser,
in Firefox oder was auch immer Sie benutzen und laden das von irgendwo her.
Netflix, Spotify, wo auch immer.
Die Verarbeitung findet woanders statt, die Rechnungslegung findet woanders statt.
Sie kriegen nur die Darstellung. Für die Interaktion,
was wir auf der vorhergehenden Fuljahr hatten, macht es eigentlich keinen Unterschied.
Aber es macht einen Unterschied, dahingehend,
wie wir die technische Lösung der Verarbeitung machen.
Und es geht uns ja bei dieser Methode,
die wir besprechen wollen, darum,
wie wir Interaktionen machen
Hier noch ein paar Beispiele auf der linken Seite,
die fetten Systeme, Rich Clients, wo etwas auf dem Platz läuft,
auf dem gleichen Rechner, bei dem wir sind.
MS Office steht hier auf Photoshop, das sind typischerweise die Sachen,
die man dort macht, wenn man etwas im Web macht,
wenn man auf etwas auf dem Smartphone macht,
dann ist es häufig, nicht immer, aber häufig,
wenn es irgendwo aus dem Netz kommt.
Nicht immer, also zum Beispiel,
ich habe auf meinem Smartphone fürs Ausland Navigationskarten heruntergeladen,
dann ist mein Smartphone der Fettclient, weil alles darauf passiert,
die Navigationen funktionieren darauf, dass ja,
aber wenn ich Google Maps aufmache und ich bin in Deutschland und habe guten Netzzugang,
dann ist das Wäre mein Würde das gleiche Smartphone als Sclim-Client funktionieren?
Und dann ist die Verarbeitung eigentlich bei Google irgendwo.
Dass Google nebenbei mit meinen Daten Geld verdient, stört mich ein bisschen,
deswegen bevorzuge ich persönlich das lieber offline zu machen.
Google muss nicht immer gleich wissen, wo ich bin und
diese Daten zu Geld machen oder andere dazu zu bringen,
Geld an Google zu bezahlen für potenziell verfügbare Daten.
Wir funkussieren uns jetzt in dieser Veranstaltung auf die linke Seite.
Wir fokussieren uns auf solche Sachen,
wo wir uns über diese Aufteilung keine Gedanken machen wollen
Das haben wir so Sachen schön ein bisschen vereinfacht.
Wir wollen es noch weiter vereinfachen. Diese Folie sagt uns,
was wir jetzt nicht berücksichtigen. Wir lassen noch zwei weitere
wichtige Aspekte weg. Der erste Aspekt, den wir weglassen,
heißt hier Persistenz. Persistenz ist wieder so ein nettes Fremdwort,
was wir alles schon mal gehört haben.
Was ist denn Persistenz? Ich mache das gerne so.
Fremdwort des Tages, Sachen, die man schon mal gehört hat.
Und wir versuchen uns gemeinsam an so einen Begriff anzunähern.
Deswegen würde ich doch gerne mal eine kleine Umfrage machen oder
nicht Umfrage, sondern ihrer Wortmeldung erbitten.
Was heißt Persistenz? Versuchen Sie es einfach, es muss nicht
gleich richtig sein, wir versuchen es drittfrischerweise anzunähern, bitte.
Bleibend, ja, das hat etwas mit Bleiben zu tun,
aber wir sind ja jetzt bei Computersystemen.
Was ist denn bleibend? Okay, ich wiederhole es mal für die,
die das nicht so ganz genau gehört haben,
wenn ich etwas zumache, wieder aufmache, ist es noch da.
Also ich habe etwas gemerkt, Zustand.
Sie hatten gesagt, bleibend, das wäre auch noch so.
Was heißt das denn vielleicht hier in diesem Zusammenhang mit Softwaresystemen?
Klar, da bleibt auch der Computer stehen,
wenn ich kurz aus dem Raum gehe,
Super, Daten, Speichern oder Nichtspeichern. Das ist der Begriff,
wie wir die sind, wie wir das hier nützen.
Tatsächlich heißt es persistieren, das Bleiben, das länger andauernde.
Und hier heißt es, für uns heißt es, dass wir Daten speichern.
In der Tat kümmern wir uns jetzt nicht so stark um die Datenspeicherung.
Das ist, Sie mögen jetzt sagen, das ist doch
ein bisschen weltfremd. Wenn ich ein Konto habe,
natürlich möchte ich da was einzahlen und ich möchte bitteschön auch,
dass das Geld da drauf bleibt.
Wenn ich eine Bibliothek habe und verleihe meine Bücher,
die ich mir teuer angeschafft habe,
dann möchte ich doch bitteschön wissen,
wer hat welches Buch und wann bringt er es zurück
Wir blenden das jetzt mal aus, weil diese Datenspeicherung,
die behandeln sie, wenn es um Speichdatensysteme geht, die blenden wir einfach mal aus.
Wir kümmern uns um die Gestaltung der Sachen,
die man nicht speichern muss, wie gestalten wir das?
Der zweite Punkt ja hier, blau gezeichnet ist, keine Verteilung.
Typischerweise haben wir Systeme, die auf mehreren Computern laufen. Auf mehreren Computern heißt,
nicht nur der Client und der Server, wo die Daten herkommen,
sondern da gibt es vielleicht noch den Webserver,
da gibt es ein Firewall-System, da gibt es eine Lastverteilung,
etwas liegt in der Cloud,
um solche Sachen kümmern wir uns nicht.
Diese Einschränkung hatten wir aber auch schon ein bisschen gemacht,
als wir über die Desktop-Systeme gesprochen haben
Soweit zur Einschränkungen. Und sie kennen diesen Spruch,
der Albert Einstein nachgesagt wird. Wir sollten die Dinge
so einfach machen wie möglich, aber nicht einfacher.
Also wir sollten es nicht so einfach machen, denn wenn es
ganz einfach ist, ist es eigentlich nur noch Wegwerfsachen.
Also dieses kleine, nette Zitat soll uns sagen,
wenn das so klein ist,
dass sie das alleine in kurzer Zeit machen können,
dass sie nicht lange drüber nachdenken müssen.
Und das ist dann eigentlich auch wegwerfen kann.
Dann ist es ganz,
ganz einfach
Für solche einfachen Systeme brauchen wir keine Methoden.
Also wenn ich tatsächlich mir irgendwie nur mal,
ja, ich hatte natürlich eine nette Feier,
da macht man irgendwie ein kleines Gag-Geschenk,
das muss nur die Feier überhalten,
schön aussehen und das werden sich die Leute nicht dieses Geschenk gekriegt haben, nicht aufheben.
Dann muss ich mir nicht so viele Gedanken reinmachen in die Dauerhaftigkeit,
in die Stabilität, die Feuersicherheit und was auch nicht alles,
dann muss es nur einfach schön aussehen.
Dann ist es etwas zum Wegwerfen, dann brauche ich keine Methode.
Also wir brauchen es auch nicht zu einfach machen.
Ja, also dieses ganz einfache spielt jetzt für uns auch
keine Rolle
Wir hatten vorhin auf der Gliederung die ersten drei Punkte,
da war der zweite Punkt Qualität.
Lassen Sie mich kurz etwas zur Qualität sagen.
Wir hatten eben gesagt, es soll einfach sein,
das waren die Einschränkungen, in welchem Gebiet bewegen wir uns.
Trotzdem brauchen wir weitere Ziele. Wenn wir eine Methode anwenden wollen,
dann sollte diese Methode uns helfen, reproduzierbare Ergebnisse zu erreichen.
Reproduzierbar im Sinne von Eigenschaften, die Eigenschaften,
die jemand möchte, sollen bitte erfüllt sein.
Und Eigenschaften, das hat mit Qualität zu tun.
Natürlich wollten wir
möglichst hohe Qualität
Aber nur so viel, wie man auch zu bezahlen bereit ist.
Manchmal muss es besonders schnell gehen. Vielleicht kennen Sie alle
dieses böse Wort von der Bananensoftware, die beim Kunden reift.
Ja, die Firmen sind gezwungen durch den Konkurrenzdruck,
möglichst die ersten am Markt zu sein.
Sie verkaufen etwas und bringen uns das mit tollem Marketing,
die Marketingmaschine läuft auf Hochtouren. Wir sind bereit dafür,
irgendwie 300 Euro zu bezahlen für ein tolles Gerät und dann
haben wir es zu Hause und dann müssen wir als die dritte Version der Software abwarten,
bevor es so halbwegs funktioniert.
Das ist nicht das, was wir uns mit Qualität erhoffen,
aber es ist ein Kompromiss,
weil wenn die Firma erst das toll gemacht hätte und hätte
es dann an den Kunden gebracht,
waren dummerweise die Kunden alle schon mit der Konkurrenz versorgt gewesen
Ja, die Menschen wollen immer alles sofort und keiner wartet,
dann müssen wir auch so ein bisschen dafür bluten.
Wenn wir Qualität uns einteilen,
und das machen wir mit dieser und der nächsten Folie,
sollen wir zunächst, das gibt es zunächst mal die Möglichkeit,
zu sagen, es gibt Qualitätsmerkmale, sie sieht man als Benutzer.
Die sind von außen zu sehen, deswegen gibt es
den Begriff externe Qualitätsmerkmale. Und dazu gehören hier die,
die drunter stehen. Und dann gibt es noch welche,
die sieht der Entwickler erst mal nicht.
Die werden als Ethesie-Date benutzer erst mal nicht,
die sind nur für jemanden zu sehen,
der wirklich den Blick nach innen hat
Und diese Merkmale sind aber auch wichtig für die Funktionen. Also zum Beispiel,
wenn ich mir eine Digitalkamera kaufe, dann kann ich natürlich schauen,
wie viel Pixel hat die, ist sie schön bedienbar,
sieht die schnuckelig aus, macht sie einen stabilen Eindruck.
Es gibt Geräte, die Sachen, die noch viel wichtiger sind,
wie der äußere Eindruck ist, aber ich möchte auch ein paar Sachen wissen, ist das denn intern gut?
Ja, ist die Verarbeitungsgeschwindigkeit schnell? Gut,
das kann ich auch gerade noch so merken, beim neuen Smartphone,
da gibt es so was Nettes, wie heißt Siegner,
die Seite, fix it oder irgend so ähnlich,
wo man nachgucken kann, wie schwierig ist denn das auseinanderzubauen,
wenn ich mal, also wie teuer die Reparaturkosten ungefähr werden,
wenn mir mal was kaputt geht.
Das sind so interne Merkmale, die möchte ich auch wissen. Das reicht noch nicht ganz,
deswegen gibt es noch mehr Merkmale, und zwar diese sechs Spalten,
die Sie hier sehen, sind jetzt so,
dass die Linken, sind die externen Qualitätsmerkmale, das sind die,
die der Benutzer sehen kann und die Rechten sind die Internen,
die nur der Entwickler sieht.
Was hat es damit auf sich? Ich mache das jetzt,
wir sind auch gleich fertig damit und gehen wieder zum Entwurf. Wir möchten Systeme entwerfen,
die genau diese Merkmale erhalten, die der Kunde möchte,
die dem Kunden wichtig sind, dem Auftraggeber wichtig sind,
sonst würde er nämlich zu jemandem anders gehen und sich das entwickeln lassen.
Schauen wir die Dinge einzeln kurz an, Funktionalität meint,
dass die Funktion erbracht wird, die man möchte.
Dazu gehört, es soll korrekt sein, es soll mit anderen zusammenarbeiten können.
Wir wollen auch so etwas wie Datensicherheit haben. Diese Punkte gehören dazu,
dass das System die Funktion erbringt, die es soll.
Die nächste Spalte, Zuverlässigkeit, da geht es auch um die Funktion.
Wo ist meine Maus? Die Funktion, aber im Sinne von,
wird denn diese Funktion auch unter erschwerten Bedingungen erbracht?
Oder erschwerten Bedingungen heißt, es gibt Fehler ringsherum,
irgendetwas anderes funktioniert nicht, wird meine Funktion trotzdem hergestellt?
Kann ich das System wieder anlaufen lassen? Oder wie geht
es denn um, wie häufig sind ein Fehler?
Wie häufig tritt so etwas auf? Der nächste Punkt Benutzbarkeit,
Das wird auch Gegenstand der nächsten Übung sein.
Wäre zum Beispiel, wie gut kommen die Menschen damit zurecht?
Sehe ich immer, wo ich gerade bin? Passt das
von den Aufgaben her zu dem, was ich machen möchte?
Und der vierte Balken hier, Effizienz, da geht es um Ressourcenverbrauch.
Bei Effizienz geht es darum, wie gehe ich mit Ressourcen
um? Und Ressourcen meint jetzt nicht,
CO2 und Sauerstoff und wie wir mit der Umwelt umgehen,
sondern die Ressourcen, die wir hier meinen,
sind Rechenzeit, braucht irgendeine Operation furchtbar viel Rechenzeit,
ist,
ich muss warten
Oder Speicherplatz, braucht etwas furchtbar viel Speicherplatz, obwohl es
eigentlich nur wenig ist. Zum Beispiel kennen sich solche,
vielleicht kennen sie ja auch den Effekt,
man installiert ein Open-Source-System für Umbenennen von Bildern oder Sortieren oder irgendwas und denkt,
ach, nur 120 Kilobyte, wie kriegen die das hin und irgendwas anderes,
was sie sich runterladen, das sind fast zwei Gigabyte und denken,
so viel mehr ist das jetzt auch nicht an Software.
Ja, also das wäre zum Beispiel Ressourcen im Sinne von Speicherplatz
auf der Festplatte. Es gibt auch Programme,
die brauchen furchtbar viele Ressourcen im Arbeitsspeicher.
Und die dritte Gruppe von Ressourcen,
die ich uns nennen möchte,
ist Netzwerkübertragung
Ja, ich bin zum Beispiel jemand,
der viel gern mit der Bahn fährt,
aber ich ärgere mich da immer,
dass diese App von der Bahn irgendwie furchtbar viele Daten braucht,
bevor sie mir mal einen Fahrplan anzeigt und wo ich jetzt bin.
Das könnten die doch auch ein bisschen schlanker bringen,
weil unterwegs gibt es nicht überall so guten Empfang.
Ja, also die gehen mit der Ressource, Netzwerkübertragungskapazität,
relativ schlecht um. Das ist Ressourcenverbrauch. Soweit dazu und
jetzt die zwei Punkte rechts, Wartbarkeit und Portierbarkeit.
Das sind Merkmale, die damit zu tun haben,
Von Eigenschaften, die Software auch haben muss,
die der Benutzer aber nicht sieht.
Das, was wir gerade eben hatten, Effizienz,
das merken Sie sehr deutlich. Es wird langsam. Ja
, es geht irgendwie nicht. Das sind alles Sachen,
die Sie merken können. Aber bei Wartbarkeit geht es darum,
wir gehen den Begriff gleich noch weiter aus.
Hier geht es um Veränderungen. Es geht darum,
dass man Veränderungen an der Software durchführen muss, mit welchem Aufwand.
Und Portierbarkeit, da geht es um den Plattformwechsel.
Beide sind Eigenschaften, die Software gut erfüllen muss und
um die wir uns mit unserer Methode auch kümmern wollen.
Wie gesagt, immer erinnern, wir sprechen immer von dieser Methode.
Zu dieser Veränderung, noch etwas auf der nächsten Folie
Was wollen wir hier mit dieser Veränderung? Software muss fertig
sein, muss gut sein. Leider ist es so,
dass Software ständig Veränderung unterliegen muss, und zwar deswegen,
weil das Umfeld der Software sich verändert. Beispiel,
jedes Mal, kurz vor Jahresende, meistens so September,
Oktober herum, berät der Deutsche Bundestag über Änderungen am Steuerrecht.
Dies betrifft uns mehr oder weniger positiv, das landet vieles davon,
schafft es nicht mal in den Tagesschau, aber Software-Systeme,
die mit solchen Finanztransaktionen Sozialversicherungssachen oder Arbeitsverhältnissen zu tun haben.
Diese Software muss diese gesetzlichen Änderungen unterstützen. Dummerweise ist das so,
dass der Bundestag meistens irgendwie erst im November darüber beschließt und die Firmen,
die Software machen, die sich nach diesen Gesetzen richten muss,
muss das aber bis zum 1. Januar zum Laufen bringen.
Sie können sich also vorstellen, wenn sie bei so einer Firma anheuern,
dass sie über Weihnachten nie Urlaub haben werden.
Ganz einfach, weil die Änderungen, die die Gesetze mit
sich bringen, in die Software rein müssen.
Sonst ist diese Software nicht mehr verwendbar. Das steht hier,
entweder sie wird verwendet, verändert die Software oder sie stirbt.
Sie ist nicht mehr benutzbar
Und nun sind die Gesetze nicht alles. Es gibt auch
noch viele andere Sachen. Eine Firma kauft eine andere Firma
hinzu und sie wollen ihre Warnbuch Warnhaltung gemeinsam zusammenführen.
Oder eine Firma sagt, okay, wir wollen jetzt in
Zukunft unseren Teig für unsere Brötchen nicht mehr selber kneten.
Wir wollen den jetzt kaufen. Und da muss man natürlich
irgendwie eine Schnittstelle haben. Da muss man ein Stück der Software auslagern.
Andere Sachen, die dazukommen, es ändern sich Vorlieben.
Früher wollte ich das alles mit F-Tasten machen.
Die Reihe von F-Tasten haben wir in unserem Computer.
Später kam die Maus. Heute wollen wir das mit Touch machen. Ein Bediener einer Software,
ich bin ein Entwickler einer Software, muss die Änderungen entsprechend machen,
sonst kann er seine Software nicht mehr verkaufen,
weil sie so altmodisch aussieht.
Also, wir müssen Softwareänderungen immer durchführen.
Und hier kommt dieser Begriff Wartung her, dieser Begriff Surftware-Erwartung,
der ist eigentlich ein bisschen verfremdet aus dem Englischen.
Im Englischen heißt das eigentlich, hier ist meine Maus,
heißt das Maintenance. Maintenance heißt auf Deutsch Aufrechterhaltung,
das wäre eigentlich der viel bessere Begriff.
Ich möchte Software aufrechterhalten, ich möchte sie weiter nutzen können
Und von Maintenance ist aber der Englische,
die deutsche Übersetzung, die offizielle Übersetzung ist Wartung.
Das passt aus meiner Sicht nicht so besonders,
deswegen gehe ich hier speziell darauf ein.
Wartung an ihrem Auto, an ihrem Fahrrad bedeutet,
ich muss Verschleißteile ersetzen. Am Fahrrad ist die,
wenn die Kette runter ist, springt die immer.
Beim Auto muss ich die Bremsflüssigkeit immer mal erneuern oder eine Glühbirne geht kaputt.
Verbrauchsgegenstände, Verschleißmaterialien, all das haben wir bei Software nicht.
Deswegen ist der Begriff Wartung bei Software ein bisschen deplatziert.
Maintenance trifft eigentlich viel besser, Aufrechterhaltung.
Wir wollen die Funktion trotz Änderungen aufrechterhalten
Und das ist diese Qualitätseigenschaft Wartbarkeit, die wir eben in
dem vorhergehenden Bild in der zweiten Spalte von rechts haben.
Wartbarkeit ist, kurz gesagt, der Aufwand, den man für Änderungen braucht.
Und wenn wir das wissen, verstehen wir viel besser,
was hier steht. Das ist der erste Punkt,
der erste Unterpunkt, der Aufwand für das Analysieren.
Der zweite Punkt, der Aufwand für das Durchführen der Änderung.
Der dritte Punkt ist, wie stabil ist denn die Änderung über die Zeit?
Ist die fehleranfällig? Und der Aufwand fürs Testen,
wie sie vielleicht schon gehört haben,
Testaufwand ist typischerweise über den Daumen dreimal so hoch wie Entwicklungsaufwand,
ist auch ein wichtiger Punkt.
Und wenn wir Software leicht änderbar machen wollen,
müssen wir alle
diese Punkte beeinflussen
So, soweit zur Qualität. Das sind die Sachen,
kurz gesagt, oder nochmal, ich gehe mal hier,
all diese Ziele wollen wir erreichen und es hängt ein bisschen davon ab,
was es genau für ein System ist.
Zum Beispiel interaktive Systeme, da hat Benutzbarkeit viel damit zu tun,
dass ich, dass der Bildschirm etwas darstellt, was der Mensch versteht.
Effizienz hat etwas damit zu tun, die Datenverarbeitungsgeschwindigkeit ist.
Und es hängt ein bisschen davon ab, welche Systeme,
wofür wichtig sind. Also ein System,
wo keiner ein Handbuch lesen kann, zum Beispiel,
weil ein Fahrkartenautomat an der Straße steht, da spielt Benutzbarkeit,
Erlandbarkeit, dass das intuitiv ist, eine viel größere Rolle,
weil sonst kommt keiner damit zurecht,
als vielleicht Performance
Ja, das darf auch eine Sekunde dauern. Während ein System,
was tausende Transaktionen macht,
um die Rente für die deutsche Bevölkerung zu berechnen,
da kommt es nicht so sehr auf die Performance an,
ja, und vielleicht auch nicht so auf die Bedienbarkeit.
Und da kommt es darauf an, dass es auf jeden Fall ganz korrekt läuft.
Und unter erschwerten Bedingungen mit falschen Datensätzen vielleicht auch noch,
weil weh, die Rente wird mal nicht bezahlt, da bricht eine Revolution los.
Ja, also die Anforderungen sind unterschiedlich. Wichtig ist,
wir müssen bei den Methoden, die wir anwenden,
diese Antwortungen erfüllen können, je nachdem, wo die Schwerpunkte liegen.
Jetzt wieder zurück zu den Methoden, die Methode,
die wir hier in SE2 behandeln, heißt,
kurz gesagt, wann die Langform davon ist, Werkzeugmaterial-Ansatz.
Die Buchstaben-Wand, da steckt Werkzeug und Material drin,
dazwischen das A steht für Automat. Werkzeug, Automat, Material.
Das ist den Texten ein bisschen kurz zu halten, ist es,
es geht darum, dass man hier ein bestimmtes Lösungsverfahren reproduziert.
Wir analysieren die Aufgabenstellung, versuchen diese Aufgabenstellung und sozusagen zu filetieren,
um den Kern zu erkennen, zu erkennen,
worum geht es wirklich,
was für Interaktionen wird dort gebraucht und dann setzen wir diese Interaktion,
die wir erkannt haben,
um in eine technische Lösung
Hier steht der Begriff Muster auf der Folie. Einsatz von Mustern.
Es gibt wiederkehrende Lösungen. Hier umsteht das. Es gibt
wiederkehrende Lösungen, die sogenannten Entwurfsmuster haben sie alle schon gehört.
Die kann ich verwenden für typische Probleme, typische Lösungen zu entwickeln.
Das ist Ingenieurwissen. Kein Maschinenbau würde sich ausdenken,
ein Kugellager neu zu entwickeln. Nein, er nimmt eins
aus dem Katalog. Jemand, der Fandläser entwickelt und Objektive
, da musste ich die Linse neu entwickeln.
Nein, die gibt es schon. Viel vorher hat
die Menschheit das Rad entwickelt und noch vorher das Segel
Es gibt diese Lösungen schon, wir sollten sie verwenden.
Und das geht darum, darum geht es bei so einer Methode.
Die Aufgabenstellung so aufzubereiten, dass solche Muster,
solche wiederkehrenden Lösungen anwendbar sind. Das ist etwas,
was sie dann unterscheiden soll, wenn sie im Beruf stehen,
von Leuten, die das einfach nur irgendwie so machen,
wie sie ihnen halt gerade einfällt.
Sie sind dann in der Lage, reproduzierbare Lösungen aufzuentwickeln,
mit solchen Methoden reproduzierbare Lösungen, die eine reproduzierbare Qualität haben.
Also wenn sie es einmal hingekriegt haben,
sollten sie es beim zweiten, beim dritten,
beim vierten Mal in vergleichbarer Weise hinkriegen,
auch wenn die Aufgabe anders ist.
Und damit unterscheiden wir uns,
weil wir dieses Erfahrungswissen nutzen von jemandem,
der sich das einfach nur ausdenkt
Über diese Konzepte, die jetzt hier auf der Folie stehen oder auf dem Bild stehen
, da gehe ich jetzt nicht weiter drauf ein.
Wie hängt das Ganze zusammen mit Werkzeug und Material?
Gehen wir jetzt im Detailliert und die ganzen nächsten Veranstaltungen drauf ein?
Wir machen das, wir werden das ein bisschen runterkürzen, vereinfachen.
Es kommt mehr davon, wenn wir in der Veranstaltung Softwaretechnik,
die wir im nächsten Jahr für sie anbieten,
da gibt es einen ganzen Drag, der sich nur mit dem Werkzeugmaterialansatz beschäftigt.
Hier werden wir erstmal anfangen mit vereinfachten Entwurfsregeln,
mit einem Teil der Entwurfsregeln
Wir haben das so portioniert,
dass sie das auch in der Übung haben können.
Also in der Übung, in der Übung 3 zum Beispiel,
die sie dann nach Fink nach den Pfingstferien haben werden.
Da geht es um die Gestaltung solcher interaktiven Systeme.
Wie soll die Bildschirmgestaltung aussehen? Ja, wir wollen sie
also im Kleinen mit einzelnen solchen Entwurfsregeln befassen.
Heute beschäftigen wir uns hier allerdings mit Entwurfsregeln.
Wie schneide ich das Ding von innen so eine Software?
Ja, so dieser Wammeinsatz fängt also erstmal,
wir fangen damit an,
ihnen das im Kleinen
zu zeigen
Damit folgen wir so einem ganz etablierten Verfahren.
Wir haben das hier ein bisschen auf diese Folie gezeigt,
dass mit fernöstlichen Weisheiten gespickt. Ja, also dass man stittweise
auch von allen einfachen Sachen zu reiferen Sachen das aufbaut.
Wer von ihnen sich mit für so assiatische Kulturen entwickelt,
interessiert, der kann, ist ja gerade das Japanische,
ist ja eine sehr weit entwickelte Kultur.
Da kommt vieles her, was tatsächlich im Westen dann auch Jahrhunderte später übernommen worden ist.
Nicht nur Porzellan und Papier kommt aus Asien,
sondern auch solche Sachen wie kontinuierlicher Verbesserungsprozess,
den wir in vielen Unternehmen haben,
das ist auch auf so einem Stufenprozess aufgebaut.
Also hier geht es darum, dass man zunächst kopiert,
dann anpasst und dann eine Technik erkennen, ständig anwenden kann.
Wir fangen, ich hatte davon gesprochen,
einfache Regeln zu haben und eine ganz einfache Regel,
mit der fangen wir jetzt erstmal an.
Ich hoffe, ich langweile sie nicht mit sowas einfachen,
nämlich Äpfel und Birnen
zu unterscheiden
Leider ist es so, dass wir in Firmen ganz häufig sehen,
dass die Leute gerade solche einfachen Regeln nicht verstehen, nicht beherrschen.
Wir versuchen, Software so zu entwickeln, dass wir die
in Bereiche teilen. Diese Teilung in Bereiche ist etwas,
das machen wir ganz intuitiv und das ist eine Technik,
die uns hilft, komplexe Probleme zu beherrschen.
Ich hatte schon vorher, wir von Folien
vorher war das so, mit den ganz einfachen Lösungen.
Wir wollen die ganz einfachen Lösungen, um die brauchen wir
uns nicht zu kümmern. Wir müssen uns um Lösungen kümmern,
die etwas komplizierter sind
Und diese komplizierteren Lösungen verlangen zum Beispiel, dass sich die Komplexität beherrsche.
Teile und herrsche ist so ein ganz altes Prinzip, die Römer,
die wir di at Imperra haben das schon gehabt.
Die haben also ihre Feinde, die Kategorie und die Kategorie,
die sind ein bisschen verstritten und schon haben sie die beherrschen können.
Wir wollen nicht, dass die technischen Systeme sich verstreiten,
aber wir wollen die technischen Systeme einteilen.
Und eine Einteilung, mit denen fangen wir jetzt hier an,
die erste unserer Regeln. Wir trennen das Fachliche vom Technischen
. Diese ganz einfache Regel kommt deswegen zuerst,
damit sie sie am häufigsten hören von uns,
damit sie sie am besten behalten
Warum machen wir so etwas? Wir versuchen zu teilen in die Sachen,
die mit der Aufgabenstellung zu tun haben und die Sachen,
die mit der technischen Realisierung zu tun haben.
Das machen wir nicht, weil es schön ist,
rot und grün zu teilen oder schwarz und weiß zu teilen
oder weil wir für Ordnung sind in unseren Systemen,
sondern das machen wir deswegen, damit wir die Arbeit aufteilen können.
Arbeitsteilung, zum Beispiel zwischen Spezialisten, die sich auskennen,
wie funktioniert eine Bank,
das ist die Fachlichkeit zum Beispiel für ein Banksystem und Leute,
die sich damit auskennen,
wie funktioniert Datenspeicherung und Wiederherstellungen,
Robustheit und Sicherheit.
Das ist das Technische
Und die einen beschäftigen sich mit technischen Sachen,
in die anderen sich mit fachlichen Sachen und indem wir unsere Softwarelösung
in beide Teile teilen, können wir sagen, okay,
ihr kümmert euch um die Probleme und ihr kümmert euch um die Probleme.
Und dazwischen machen wir eine schöne Schnittstelle, dass eure Systeme zusammenarbeiten.
Das ist der Hintergrund für diese Aufteilung.
Lassen Sie uns anfangen mit fachlichen Sachen. Das ist das,
womit wir bei dem Warmeinsatz uns zunächst beschäftigen.
Ich kann schon vielleicht schon mal so her sagen,
da den Übergang von Fachlicht zu technisch, da kommen dann die Muster rein.
Zunächst beschäftigen wir uns erstmal den fachlichen Kern zu erkennen
Hier steht nah am Anwendungsbereich. Wir benehmen also die Begriffe,
ob das nun eine Bank ist, wir werden uns mit
der Mediathek wieder beschäftigen, die Sie ja schon kennen,
oder die werden wir hier als Beispiel haben.
Wir beschäftigen uns mit dem fachlichen Ding, was die Aufgabenstellung ist,
was dort sein kann. Und das versuchen wir zu verstehen
, das ist der erste Punkt. Und da hier,
in der zweiten Zeile sehen Sie Abstraktion, Abstraktion heißt,
ich möchte von den Details abstrahieren, indem ich diese Details ausblende.
Ich möchte das Grundlegende verstehen. Dieses Grundlegende hilft uns,
Prinzipien zu erkennen und das hilft uns dann, die Regeln zu anzuwenden.
Und was wir auch erreichen wollen mit der Abstraktion ist,
die stabilen Kern herauszufinden, um dann etwas zu entwickeln,
was bei Änderungen unverändert bleibt. Es nützt uns gar nichts,
ein Softwaresystem zu bauen,
was wunderschön alles erfüllt und da kommt im nächsten November die Steuergesetzänderung
und zwischendurch macht unsere Firma einen Zukauf und dann wollen die Leute
eine andere Nutzerschnittstelle und jedes Mal müssen wir alles umbauen
Wir wollen, dass die Umbauten möglichst klein bleiben,
weil der Kern, das stabile, immer gleich bleibt.
Dazu müssen wir natürlich das Stabile erkennen. Und gleichzeitig wollen wir
auch etwas wiederverwenden. Das steht hier unten. Wiederverwendung wollen wir erreichen,
indem wir eine Lösung, die wir einmal geschaffen haben,
im nächsten System so ähnlich machen können.
Und das hilft uns, wenn wir, wenn es uns gelingt,
fachliche Klassen zu entwickeln. Nun werden Sie vielleicht sagen,
Klassen kenne ich schon, haben wir bei SE1 gehabt.
Klassen ist was mit Java, Public, Private, Attribute,
Methoden, Wunderbar. Wir sprechen hier aber nicht von Java. Wir sprechen davon,
dass wir im Anwendungsbereich, im fachlichen Bereich etwas haben,
was auch für eine Klasse steht,
aber eher so wie eine Klasse von Tieren,
eine Klasse von Dingen, eine Klasse von Phänomenen,
im Sinne von Abstraktionen, im Sinne von Verallgemeinerung.
Sie haben schon von Modellen gehört,
deswegen steht hier über der Folie Wiederholung drüber,
wir wollen etwas modellieren, indem wir den Gegenstandsbereich,
also das Fachliche, analysieren und davon abstrahieren,
also etwas Das gemeinsame Erkennen, das grundlegende Erkennen,
ein Modell bilden.
Und das soll dann ein Anwendungssystem werden. Also hierfür wollen wir
Regeln verwenden. Und diese Regeln hierfür und hierfür werden dann das,
wo wir von Mustern eben gesprochen haben,
wir wollen das trennen in das Muster des fachlichen Bereichs,
das heißt Gegenstandbereich und muss dann das Anwendungsbereichs.
Um diese Sachen werden wir uns kümmern und wir wollen in
dieser Veranstaltung uns vor allen Dingen darum kümmern,
das Modell des Anwendungssystems zu schaffen,
nämlich eine technische Lösung zu bauen,
die dann in Java implementiert werden kann
Wir haben im letzten, in SE1 haben sie die Grundzüge von Java kennengelernt,
hier in SE2, wollen sie die grundlegenden Grundzüge der Modellierung von Anwendungssystemen kennenlernen. So,
und dazu gehört,
dass wir dieses Anwendungssystem versuchen zu erkennen und versuchen zu zielstrebig zu entwickeln,
indem wir zunächst den fachlichen Kern entwickeln,
auf der vorgehenden Folie stand, die fachlichen Klassen,
der fachliche Kern sind die fachlichen Klassen,
fachliche Regeln und dazu gehört noch,
dass wir das anpassen an eine technische Lösung,
das so gestalten,
dass die technische Lösung uns dabei hilft
So, wenn wir da weiterkommen, brauchen wir jetzt,
sehen wir hier die Begriffe zum ersten Mal,
von wann, Material, Werkzeug, fachliche Dienste.
Und die beschäftigen wir uns, mit denen beschäftigen wir uns jetzt etwas genauer.
Die technischen Klassen zunächst, ja, technische Klassen sind Sachen,
die wir, die diesen technischen Kern beschäftigen, betrachten.
Wir hatten eben fachliche Klassen stehen, jetzt technische Klassen sind das,
was wir brauchen, um zu helfen, die Implementierung hinzustellen.
Deswegen steht das hier oben, sowas wie Hilfsklassen, ja,
und wir wollen, und sich an das Bild Äpfel und Birnen,
wir wollen fachlich und technisch voneinander trennen,
wir wollen fachliche und technische Klassen voneinander trennen.
So, nächste Folie zeigt jetzt diese Begriffe noch mal im Zusammenhang.
Und jetzt werden wir auf die einzelnen Punkte eingehen,
damit werden wir heute anfangen, beim nächsten Mal fortsetzen,
zunächst Materialien. Diese Materialien sind fachliche Gegenstände,
es sind Sachen, mit denen man also etwas macht,
Fachwerte sind noch ganz spezielle Sachen,
weil die unveränderlich sind,
aber das Machen passiert mit den Werkzeugen
Das ist der Punkt und die Services spielen noch eine Rolle.
Dieses, das ist sozusagen der Überblick über das,
was sie hier in SE2 an Regeln mitbekommen werden.
Diese Regeln gehören, stehen hier auf der nächsten Folie nochmal im allgemeinen Überblick.
Ja, wir wollen versuchen für jedes Ding,
für jedes, für diesen Strukturelementen Werkzeugmaterial, Servicefachwert,
eigene Pakete zu strukturieren, damit wir das schön gliedern können.
Sie erinnern sich an Arbeitsteilung, von der ich
gesprochen habe und wir wollen den Dingen gut Schnittstellen geben.
Gute Schnittstellen bedeutet, wir packen die Sachen zusammen, die fachlich zusammen gehören.
Und damit wollen wir anfangen. Der erste dieser Begriffe,
die wir eben auf der Überblicksfolie hatten, waren Materialien.
Material klingt nun so, wie ein Stück Holz,
was ich bearbeite, eine Kohle, die ich anbrenne,
ein Stück Fleisch, was ich draufliege auf meinen Grill oder eine Cola,
die ich trinke oder irgendwie das sind Materialien.
Bei uns geht es ja um Datenverarbeitung.
Das ist das,
was Computer können
Und bei Datenverarbeitung sind nun mal die Daten, die Materialien.
Und wir wollen die Daten nehmen für etwas Fachliches,
um das zu repräsentieren für unsere Mediathek,
mit der wir uns hier beschäftigen in dieser Veranstaltung,
wäre das zum Beispiel eine CD, eine DVD, ein Videospiel.
Wenn Sie denken, was macht denn der Kunde hier oben? Ja,
auch der Kunde ist etwas, mit dem ich arbeite,
weil der Kunde zum Beispiel etwas zu bezahlen hat,
der Kunde hat etwas auszuleihen,
dann muss er es wieder zurückbringen.
Der Kunde hat eine Anschrift,
wo ich eben eine Werbung hinschicken möchte oder so etwas
Vielleicht hat der Kunde auch eine Bonität, dass ich eben sage,
okay, du hast heute nicht genug Geld mit,
du kannst das jetzt aber trotzdem mitnehmen, ich vertraue darauf,
dass du das mir beim nächsten Mal wieder bezahlen wirst.
Zum Beispiel. Das sind Dinge, die wir,
wo der Begriff Gegenstände relativ gut passt,
weil das sind Sachen, mit die man wenigstens greifen kann.
Der Mensch wird sich vielleicht nicht so gerne als Gegenstand bezeichnen
lassen, ja. Aber so ungefähr passt das schon,
aber in der nächsten Zeile steht, es kann auch etwas Abstraktes sein.
Es kann etwas sein, was ich ganz schwer anfassen kann.
Ja, so etwas wie eine Versicherungspolize oder ein Konto,
ein Vertragsentwurf, ein Film, etwas Erdachtes,
ein erdachtes Konzept, ein abstraktes Konzept.
Das kann auch etwas Fachliches sein, weil ich damit arbeiten kann.
Das hat nämlich Eigenschaften, die ich in einem Datenverarbeitungssystem bearbeiten möchte.
Und das sind Sachen, die wir am Ende,
jetzt wenn Fred gleich drankommt, uns zeigen wird,
wie er das isoliert aus den, in dem Softwaresystem,
wie das gestaltet passiert.
So, zusätzlich, wir sollen sagen,
die Materialien sind Sachen, mit denen wir arbeiten.
Das heißt, Arbeitsergebnisse sind auch fachliche Dinge.
Was wichtig ist, Es geht nicht um technische Sachen.
Es geht immer um das Fachliche, falls jemand von Ihnen
jetzt gleich an Variablen und Dateien denkt, das liegen Sie falsch.
Wir sprechen jetzt von den fachlichen Konzepten. Und wir wollen
dann dazu kommen, jedes durch eine eigene Klasse zu modellieren,
das sind dann die fachlichen Klassen. In dem Übersichtsbild zwei weiter von,
hatten wir neben dem Materialien auch noch Fachwerte gesehen,
wo Sie sagen, was ist denn da jetzt der Unterschied?
Lassen Sie uns als nächstes zu den Fachwerten kommen.
Fachwerter sind zu uns, hat auch etwas mit Daten zu tun,
mit Informationen zu tun, aber Materialien sind das, was wir bearbeiten.
Fachwerte sind etwas, was unveränderlich bleibt. Das kann zum Beispiel
eine Kontonummer sein. Das ist ein Wert, der hat
den Schnitt etwas Fachlichem zu tun, aber er wird sich nicht verändern.
Klar, sie können sich ein neues Konto zulegen,
aber solange sie dieses Konto haben,
ist die Kontonummer eine fachliche Kennzeichnung für das,
wo ihr Geld liegt.
Und es ist als solches nicht mit Rechenoperationen zu sehen.
Sie brauchen das nicht mit zweimal zu multiplizieren oder nicht den
Vorgängern oder den Nachfolger zu suchen oder so etwas.
Es ist einfach ein Kennzeichen,
ein fachlicher Wert
Und im gleichen Weise kann das auch ein Geldbetrag sein,
wenn er unveränderlich ist oder ein Datum, eine Uhrzeit,
wenn es etwas ist, was eine Kennzeichnung hat, was etwas,
was ja, unveränderlich ist und hat natürlich einen Typ,
ja, so, das sind Konstanten, die wir brauchen,
um fachliche Eigenschaften zu beschreiben.
Der dritte Punkt, den in diesem Übersichtsbild vorhin,
waren die Services. Service hat etwas mit Dienstleistungen
zu tun und tatsächlich geht es hier um Verarbeitungsleistung
Fachliche Dienstleistungen sind etwas, was in einem System zur Verfügung
gestellt werden kann, was für mehrere Materialien gewählt werden kann.
Und es gibt es immer nur einmal. Beispiel,
ich verarbeite Kundendaten, die sogenannten Stammdaten, also Adresse,
Wohnung, alter Personalausweisnummer, Sozialversicherungsnummer, all solche personenbezogenen Daten,
die haben, es gibt zwar viele Personen,
aber nur einmal einen Dienst mit diesen Methoden zu arbeiten.
Den brauchen wir nur einmal, weil er kann für
verschiedenen Materialien arbeiten
Häufig kümmern die sich auch um Persistenz. Gut,
Sie werden sagen, der Rebisch hat vor kurzem gesagt,
Persistenz blenden wir aus, nur zu Ihrer Information.
Darum kümmern sich solche Services häufig auch. Es gibt häufig so,
dass das Material irgendwo liegt und ich nur ein Verweis darauf bekomme,
nicht unbedingt eine Kopie.
Das ist einfach ein häufiger Fall. Und es ist so,
dass Services die Werkzeuge, von denen wir gleich sprechen werden,
nicht kennen, sondern der Service greift auf die Materialien zu,
macht mit den Materialien etwas
Sie wissen jetzt noch, gerade von der vorgehenden Folie,
von zwei vorher Materialien. Das war doch ein Wort für Arbeitsergebnisse.
Vielleicht können Sie es zu Anfang besser merken, mit Arbeitsergebnisse.
Später sollten Sie diese Trennung ganz gut hinkommen. Und wenn ich
es in zwei Wochen wieder frage oder in vier Wochen,
was ist ein Material, sollten Sie gleich wissen, ah,
das ist das Veränderliche, was ich mit den Werkzeugen bearbeite,
wo es um Arbeitsergebnisse geht.
In dieser Veranstaltung sollten Sie die Kategorien Werkzeug, Material,
Fachwert, Service sehr gut kennenlernen.
Das sollten Sie sehr gut wissen
So, das, was hier noch fehlt, waren,
und damit sind die vier erst mal komplett Werkzeuge.
Werkzeuge sind jetzt die Dinge, mit denen wir die Materialien bearbeiten,
mit denen wir wirklich Arbeitsergebnisse erzielen,
indem wir wirklich eine Bestellung ausliefern, indem wir einen Vertrag schließen,
indem wir eine Buchung durchführen oder so etwas.
Werkzeuge arbeiten mit den Metamaterialien und jetzt kommt hier dieser Begriff
auch wieder vor, Benutzerinteraktion, Werkzeuge sind das,
was wirklich die Interaktion darstellt.
Wie viele haben wir noch? Ja,
ich bin gleich zu Ende,
Fred,
das passt doch
Werkzeuge, also haben einen interaktiven Teil und dieser interaktive Teil
teilt auch noch Teil dieses Werkzeug ein. Die fachliche Aufgabe,
die eigentlich die Datenverarbeitung betrifft und die grafische Schnittstelle,
die die Nutzerinteraktion sicherstellt, teilen wir in zwei Teile,
in mindestens zwei Teile, die Werkzeugklasse und die User-Interface-Klasse.
Wenn der Begriff zum ersten Mal fällt, UI,
User-Interface, Benutzerschnittstelle auf Deutsch, das ist das Ding,
wo es darum geht, dass der Nutzer das gut versteht,
Nutzerfreundlichkeit,
Ergonomie hatten wir vorhin
Und diese Werkzeugklasse, die benutzt, die arbeitet einerseits mit der fachlichen Schnittstelle,
mit der grafischen Hinstelle und andererseits mit dem Material.
Das ist der Hauptpunkt, was wir hier sind, die Verarbeitung drin.
Der Service liefert diese Dienstleistung und der Fachwertlieferstellt die Konstanten dar.
Nachdem wir jetzt so die Grundbegriffe besprochen haben und eine Regel kennengelernt haben,
nämlich diese Einteilung in fachliche und technisch,
kommen wir zu einem allerersten Blick auf Schritte,
wie wir dann vorgehen werden und den bekomme ich dann auch für heute schon zum Schluss.
Wir sitzen da beim nächsten Mal fort mit solchen Regeln.
Es geht um Regeln hier, wozu nutze ich diese vier Teile.
Das Material sollte zum Beispiel in einer Werkzeugklasse technisch realisiert sein.
Das sind so die Regeln, ich habe erkannt,
was ist ein Werkzeug, was ist in meiner Anwendung ein Material,
was ist in meiner Anwendung ein Fachwert,
wenn ich das erkannt habe, kommt das Werkzeug,
übernimmt das Material im Konstruktor, ist eine Regel.
Eine weitere Regel, dass sich diese Werkzeuge als Konstruktorparameter zu benötigten Services zuordnen.
Die Erzeugung von solchen Exemplaren passiert in der User in der Face-Klasse.
Und die User-Interface-Klasse, das ist sicherlich unschwer zu erraten,
geht es darum, die Komponenten, die grafischen Komponenten zu erzeugen.
So, das ist etwas, wo wir sagen,
okay, das klingt irgendwie ein bisschen nach Regeln.
Das ist sozusagen der Appetizer für die nächsten zwei,
drei Wochen. Da werden wir nämlich weitermachen,
uns damit beschäftigen, wie sehen Entwurfsmuster aus,
solche hier um die Regeln geben ja nur einen ganz,
ganz groben Eindruck.
Wie gehe ich da vor,
um diese erkannten Sachen in technische Lösungen umzusetzen und
wie gestalte ich
das grafisch
Was haben wir heute gelernt? Was haben Sie heute?
Sollen Sie heute mit nach Hause nehmen?
Sollen das über Pfingsten bewegen? SE2-Entwurfsregeln werden hier kommen.
Die sind bis jetzt mehr oder weniger nur angekündigt.
Aber was heute schon gekommen ist, sind diese vier Grundbegriffe.
Der erste Grundbegriff Materialien, das ist das,
was ich verarbeite, was am Ende Arbeitsergebnisse trägt.
Fachwerte, das sind die Konstanten, die ich dabei brauche.
Services sind die Dienstleistungen, die solche Zugriffe, Verarbeitung,
Speicherung leisten. Und Werkzeuge ist das,
womit der Mensch auf diese Arbeitsergebnisse zugreift,
die erzeugt, das ist das,
was der interaktive Teil darstellt
Und das ist das, was wir als Konstruktionsprinzipien machen.
Damit möchte ich gerne einen Fred übergeben. Eine Sache möchte ich
noch schon mal ankündigen. Sie werden das nächste Woche Donnerstag,
wird es ja die Arbeitsblätter für Aufgabe 3,
für Übung 3 zum Hochladen geben.
Da werden wir schon Sie drum bitten,
beim nächsten Mal zur Übung 3 bitte einen Computer mitzubringen.
Jedenfalls einige von Ihnen, weil wir dort mit gar kafischen Benutzerschnittstelle arbeiten werden.
Und ein paar werden das mit einem Papierentwurf machen und
ein paar werden das auf dem Computer machen.
Deswegen wäre es günstig, wenn einige von Ihnen das mitbringen,
wenn Sie keinen haben, der Sie zugreifen können,
dann ist das auch nicht so schlimm.
Wir haben natürlich, wir können das auch demonstrieren,
oder Sie setzen sich dann einfach bei jemandem mit dazu.
Aber diese Ankündigung kommt nochmal nächste Woche Donnerstag mit den Arbeitsplättern
zu. Dann übergebe ich mal an dich,
vielen Dank
Untertitel der Amara.org-Community Untertitel der Amara.org-Community Und wenn man...
Also war nicht an. Ist es an?
Ja. Ja, leichtes Feedback. Vielleicht müssen wir doch
das andere machen
Ja, jetzt bin ich, nee, das hat das
... Untertitel der Amara.org-Community Ja, hört man mich?
Ja, okay, deutlich besser von der Qualität.
So, dankeschön. Okay. Ja, ihr müsst mich
leider mit diesem Mikrofon ertragen, es tut mir leid.
Manchmal ist der Sound wichtiger als die Optik.
Ich fühle mich gerade, als hätte ich so einen ganz kleinen Interessenkonflikt.
Auf den Folien wurde so enorm stark betont,
oh Gott, Blues, nichts mit Web und so machen.
Und in den letzten Jahren, weiß nicht,
ist das Thema, sag ich mal, nicht weniger wichtig geworden.
Und ich hatte letztes Jahr so ein kleines System gebaut,
wo man Tiernamen eingeben konnte. Und dann wurde übers Web angefragt,
Beschreibungen, was das für ein Tier ist und so.
Und dann wurde damit was gemacht. Das war alles
total super cool. Aber es war auch sehr kompliziert.
Und dann habe ich für letzte Woche,
hatte ich ein System gebaut mit dem Wetter,
das hatte ich euch ja schon angekündigt.
Und dann habe ich gesagt, ach, das war auch zu kompliziert,
dann habe ich das wieder, habe ich das wieder sein lassen.
Und dann bekam ich so ein paar Anfragen per Mail,
ach, ich würde das so gerne sehen, dieses Wettersystem.
Und da habe ich das total komprimiert und zu minimal gemacht,
wie es nur irgendwie geht.
Aber es ist jetzt ein System, was Daten übers
Internet abfragt
Ja, ihr müsst das jetzt bitte ausblenden. Das ist
so ein kleiner Bonus, den ich euch jetzt sozusagen hier biete.
Das sind halt zehn Zeilen Java-Code, die ihr sonst nicht brauchen werdet,
den Übungsbetrieb, aber vielleicht auch mal im späteren Berufsleben.
Okay. Ich wollte euch mal kurz was erzählen.
Ich kann ja nicht davon ausgehen, dass ihr irgendwas wisst,
über das, was hier so steht.
Also wenn ihr auf irgendeine Webseite geht, ja,
ich nehme jetzt mal irgendeine völlig beliebige Webseite,
zum Beispiel die, dann könnt ihr hier sagen,
wenn ihr mit der rechten Masters darauf klickt,
ich möchte mir mal
den Quelltext angucken
Also alles, was ihr so wunderbar schön grafisch im Browser
seht, ist eine Ebene darunter, einfach nur Text.
Man nennt dieses Format HTML. Wer hat schon mal HTML gehört?
Okay. Gut. Und man hat irgendwann mal festgestellt,
naja, Texte übers Internet schicken, das muss man ja
nicht nur für Webseiten machen.
Sondern man kann im Prinzip ja alle möglichen Informationen darüber verschicken.
Ich könnte zum Beispiel Wetterdaten übers Internet verschicken.
Und es gibt einen Anbieter, mit dem man Wetterdaten abfragen kann.
Open Weather Map, ich habe immer so ein paar recherchiert
und der gefiel mir irgendwie am besten.
Da muss man sich irgendwo registrieren.
Ich glaube hier
Und dann kriegt ihr so einen sogenannten Key und diesen Key
braucht man für die Kommunikation mit dem Web-Service.
Das heißt, diesen Key versuche ich jetzt möglichst gut zu verstecken,
dass ihn keiner sieht, sonst benutzt ihr meinen Account.
Also wenn ihr das zu Hause nachvollziehen wollt,
dann müsst ihr euch da so einen kleinen Account holen.
Okay. Und ja, man kann eben Dinge machen,
die Geld kosten und man kann so ein paar kostenlose Dinge machen und das,
was ich gemacht hatte, war dieser fünf Tage Wettervorausschau in drei Stunden Abständen.
Ja, dafür muss man also kein Geld bezahlen.
Gut, das hoffentlich als kleine Einführung dazu. Und jetzt wollen wir
uns mal das System angucken, was ich gebaut habe.
Und das ist so ein System, wo Matthias meinte,
naja, das hätte eigentlich jeder bauen können.
Einfach nur eine riesige Java-Klasse, eine Main-Methode,
ein paar statische Hilfsmethoden, alles irgendwie wild durcheinander.
Funktioniert wunderbar. Aber es ist halt nicht so schön,
wenn man sagt, lass uns das System mal über mehrere
Monate oder Jahre entwickeln mit irgendwie einer Handvoll Entwickler oder vielleicht auch einem Dutzend Entwickler.
Irgendwann steigt man da einfach nicht mehr durch.
Und wir wollen das im Verlauf der Vorlesung.
So viel Zeit haben wir leider nicht mehr.
Umbauen in diesen Werkzeug- und Materialansatz. Okay,
also Ausgangssystem verstehen
Wie gesagt, ich habe es wirklich extrem minimiert,
das müsste eigentlich machbar sein, dass wir uns das angucken und das verstehen.
Genau. Ihr seht, das sind nur drei Klassen.
Diese Klasse werde ich jetzt nicht aufmachen, da steht mein
persönlicher Open Weathermap-Key drin, den sollt ihr ja nicht sehen.
Dann schauen wir uns mal die Main-Klasse an. Ihr seht also,
es gibt hier überhaupt keine Materialien oder Services oder so,
das wollen wir also alles noch schön umstrecken.
Gut. Okay, Main-Methode kennt ihr ja,
das ist ja nichts Besonderes und das Schöne ist,
ich muss jetzt gar nichts mehr über Acceptions erzählen,
das habe ich ja schon letzte Woche erzählt.
Also dieser ganze konzeptionelle Ballast, den kann ich jetzt mal von mir wegschieben.
Ihr wisst ja schon, wie Acceptions funktionieren. Gut. Okay,
ich sage also hier, Ich hätte gerne XML-Daten,
die mir das Wetter in Hamburg beschreiben über die nächsten fünf Tage.
Jetzt fragt ihr euch wahrscheinlich, was kommt denn da zurück?
Das habe ich mal abgespeichert, falls das Internet hier nicht funktionieren sollte,
dass ihr es uns einfach mal sehen könnt.
Tja, das ist also, das sind die XML-Daten,
die man da zurückkommt.
Nee, Bremen ist eine andere Stadt, ist egal.
Hatte ich heute Morgen gespeichert. Und ihr seht,
das ist eine ganze Menge Zeug und das versteht man nicht wirklich,
weil das alles in einer Zeile steht.
Deswegen habe ich das mal für euch ein bisschen hübscher formatiert.
So sieht das dann aus. Kann man das sehen,
wenn ich ein Vollbild mache? Ja. Okay,
solche Daten bekommt man dann also von dem Server zurück.
Nochmal so vorsichtshalber der Stadtname, dass das wirklich der ist,
den man haben wollte.
In welchem Land sind wir und so weiter
Und ich habe mich einfach mal so durchgewühlt per Hand und habe mal geguckt,
was würde mich denn hier mal so interessieren?
Und dann wurde das hier irgendwo interessant. Ich sage,
also hier fängt jetzt der eigentliche, was heißt Forecast eigentlich auf Deutsch?
Vorhersage, Dankeschön, die eigentliche Vorhersage an.
Und dann sind ja immer so kleine Zeitabschnitte,
die jeweils drei Stunden gehen. Hier wird also gesagt,
ist das der heutige Tag, der 5. Mai,
zwischen 6 Uhr und 9 Uhr herrschte also folgendes Wetter in Bremen.
Und zwischen 9 Uhr und 12 Uhr dann folgendes Wetter.
Und die Daten, die ich besonders interessant fand,
war eben natürlich einmal
dieser Zeitraum
Das sind genau sogenannte Attribute von diesem Timetech. Und dann
war hier noch die Temperatur, die fand ich ganz interessant.
Ich will ja vielleicht mal wissen, wie viel Grad es sind.
Und was ich irgendwie auch noch ganz nett fand,
war so eine textuelle Beschreibung, sehe ich die jetzt hier gerade spontan irgendwo.
Möglicherweise ist ja auch nicht überall. Ah, hier,
danke, hier ist sie. Clouds. Genau. Okay
, diese XML-Ton bekomme ich also als Text. Ja,
und ihr seid ja Java-String-Experten. Ihr könnt euch jetzt wahrscheinlich
irgendwie da durchgehen und nach irgendwelchen Substrings suchen und so.
Es geht aber alles viel einfacher. Ich zeige euch einmal,
wie man in Java durch so einen XML-Fall durchgeht
Ja, das ist ja direkte Methode, die da drunter ist.
Ich muss gar nicht großartig scrollen. Das ist also
diese Methode in derselben Klasse. Gut, wir übergeben also
die Stadt, in meinem Fall war das Hamburg oder Bremen.
Ihr könnt ja jede beliebige Stadt übergeben.
Und jetzt basteln wir uns hier so einen String zusammen.
Jetzt müsste man eigentlich noch sagen, oh Gott,
Fred, hier kann ja jeder beliebige String übergeben werden und
du packst ihn hier einfach so rein, ohne irgendwelche Überprüfungen.
Gibt es hier irgendwelche Sicherheitsexperten, die jetzt sagen können,
warum man sowas nicht machen sollte oder wie Attacken heißen
die sowas ausnutzen
Da kennst du dich sogar noch besser aus als mein flaches Wissen.
Möglicherweise geht das auch, ja? Ja, also Injection wäre
das gewesen, woran ich jetzt gedacht hätte, genau.
Also man könnte hier noch diverse andere, ich könnte sagen,
ich will nicht die Stadt Hamburg, sondern die Stadt Hamburg und,
und dann kann ich noch diverse andere Argumente da übergeben.
Ja, das ist jetzt nur für, ja,
Einfachheit halber habe ich jetzt hier keine Überprüfung gemacht.
Also bitte, solche, solche Zeilen codet nicht in echten Systemen schreiben.
Okay, ihr seht also, ich muss hier einfach irgendeine
Serveradresse angeben und hier hinter dem Fragezeichen kommt dann die eigentliche Abfrage.
Und wie die Syntax von diesen Abfragen ist,
das könnt ihr euch eben auf der Open Weather Map Org AP Spezifikation angucken.
Ja, man muss also interessant für uns jetzt,
man muss die Stadt da eintragen und man muss eben diesen Key eintragen,
sonst darf man keine Anfragen stellen
Okay. Gut, dann machen wir aus diesem String,
den wir da jetzt uns erzeugt haben, machen wir eine sogenannte URL.
Und das Tolle daran ist, man kann jetzt eine Verbindung aufmachen zu dieser URL.
Ich kann jetzt also mit diesem Server reden. Ich schicke ihm
jetzt quasi diese Anfrage. Und dann schickt er mir einen,
ja, kann ich anfangen über so einen Input streamen,
das Ergebnis mir abzusaugen.
Ja, und ihr seht hier schon wieder Acception-Behandlungen,
kennt ihr ja von letzter Woche. Es kann also durchaus sein,
dass ich mich zum Beispiel hier vertippe als Programmierer und nicht HTTP hinschreibe,
sondern vielleicht einen Tee vergesse oder statt P schreibe ich einen Q oder so.
Und wenn sowas passiert, dann fliegt eine sogenannte Melformed URL
Acception. Ich wollte das nochmal ganz kurz zeigen,
weil das so ein typisches Symptom ist von alten Java-Bibliotheken
Es gibt ja die Unterscheidung zwischen Checkt-Acceptions und Uncheckt-Acceptions, nicht wahr?
Und man verwendet ja Checkt-Acceptions für Umgebungsfehler. Also zum Beispiel,
ich habe kein Internet oder so. Das ist jetzt ja
nicht die Schuld des Programmierers, sondern höhere Umstände sozusagen.
Aber wenn jetzt der Programmierer sich tatsächlich hier vertippt und da irgendwie
ein Protokoll sich ausdenkt, was es gar nicht gibt,
dann ist das meiner Meinung nach nicht sinnvoll,
auf den Fehler irgendwie reagieren zu müssen.
Aber das System zwingt mich eben dazu. Wenn ich
diesen Catchblock nicht habe, sag mir das System,
hier könnte ja Quatsch stehen.
Tja, okay, das als kleiner Randnotiz.
Dann haben wir dieses Exo aus Input-Stream,
das gucken wir uns mal als nächstes an.
Ihr seht, immerhin sind die Methoden nicht zu lang.
Ich versuche immer, dass eine Methode nicht länger
als ein halber oder ein ganzer Bildschirm ist.
Okay. Ja. Richtig, also URL ist eine Java-Klasse.
Ich kann ganz kurz zeigen, dass es hier oben importiert wird.
Da wird einiges importiert. Hier wird URL zum Beispiel,
hier wird die Connection importiert. Das ist alles Standard-Java-Kram.
Das muss also, man muss keine separaten Bibliotheken auf haben,
das ist alles in Java schon drin.
Ja, das ist ganz praktisch. Und auch
die XML-Verarbeitung ist da auch schon komplett drin
Okay, wo war ich stehen geblieben? Hier. Ja,
ich glaube, es lohnt sich nicht wirklich, euch diese Methode zu erklären.
Diese Methode sorgt einfach nur dafür, dass alle Daten aus
diesem Input-Stream gelesen werden und wir letzten Endes als String geliefert werden.
Ich habe leider keine schönere Lösung gefunden im Java,
als das hier so Zeile für Zeile rauszulesen.
Das werde ich euch jetzt nicht erklären,
das geht so ein bisschen am heutigen Thema vorbei.
Okay, wenn wir jetzt also diesen String dann haben,
dann soll der sicherlich irgendwann auch mal gepasst werden,
das machen wir bis jetzt gar nicht.
Ihr seht, ach, das ist gar nicht
so viel Code,
ja,
nach Anvollzeilen irgendwie
Und auch, ja, wie kommt man jetzt auf sowas?
Ich habe das nicht auswendig gelernt und man sieht sich natürlich
irgendwelche Tutorials an, ja, was die einzelnen Schritte dabei sind.
Man muss da meistens immer so ein paar zusätzliche Klassen in Java erzeugen.
Es ist nun mal so, was ist denn hier der spannende Teil?
Der spannende Teil ist eigentlich, dass ich,
wenn ich diese Pars-Methode aufrufe, muss ich nicht nur übergeben,
ja, hier kriegst du, kriegst du dein XML her,
sondern auch, was soll denn mit dem XML gemacht werden?
Das ist der Teil, wo ihr euch selber einklinken könnt.
Ja, das heißt also, diese Klasse,
die habe ich selber geschrieben.
Diese Klasse reiche ich also sozusagen als Callback oder ein Objekt
dieser Klasse als Callback
rein in diese Pars-Methode
Das heißt, wir sollten uns jetzt vielleicht als nächstes mal diese Klasse angucken.
Da sind wir. Passt auf einen Bildschirm, das ist doch
nett. Okay, wenn wir uns noch mal erinnern,
wie dieses XML aussah, das hatten wir ja hier.
Dann hatte ich ja gesagt, dass mich ein paar Dinge interessieren, nicht wahr?
Ich hatte doch gesagt, mache ich mal wieder Vollbild.
Dass ich dieses Time-Tag sinnvoll fand oder interessant. Und dieses Symbol,
war mich dann der Name interessiert in des Symbols.
Und die Temperatur war mich da der Value interessierte.
Und genau diese Informationen werdet ihr jetzt hier auch wieder finden
Der Parasor wird jedes Mal, wenn er sieht,
dass so ein Tag aufgeht,
also Tag ist einfach nur so ein Ding in den spitzen Klammern,
wird er diese Methode aufrufen.
Ja, wird ja so ein paar Informationen reinstecken.
Die meisten sind gar nicht interessant. Das Interessante ist, dieser Parameter.
Da steht also der Name des Texts quasi drin und ich kann jetzt sagen,
wenn es Time ist, dann führe diesen Code aus,
ihr kennt ja das Switch Case, wenn es Symbol ist,
dann führe diesen Code aus.
Und wenn es Tempriture ist, dann führe doch bitte diesen Code aus.
Ja, und alles, was da gemacht wird,
ist, dass einfach nur auf die Konsole zu schreiben.
Das ist irgendwie auch noch nicht so wirklich schön. Toll wäre es ja,
wenn das irgendwie zumindest im System in irgendwelchen Objekten gespeichert würde,
damit ich vielleicht Testfälle dafür schreiben kann oder eine Minute später noch darauf zugreifen kann,
solange das Programm läuft.
Gut. Genau, man kann hier die Attribute abfangen,
also Attribute sind einfach nur nochmal als Wiederholung,
das sind also Tags und das sind dann jeweils Attribute dieser Text.
Ihr könnt den Namen des Attributs übergeben an diese Get-Value-Methode,
da ist sie. Ja, also ich weiß,
ich bin in dem Tech-Time,
jetzt gerade oder der Parser ist da gerade drin und ich
interessiere mich für den Wert des Attributs from.
Gut. Gibt es dazu erstmal Fragen? Wir haben also
diese Klasse mit dieser magischen Methode Start-Element und die wird
von Parser immer aufgerufen, warum
Weil wir hier ein Objekt dieser Klasse an den Parser übergeben und sagen,
bitte rufe uns immer auf, wenn du ein neues Text siehst.
Das ist halbwegs verständlich. Ich hoffe mal, ja.
Gut. Und das ist eigentlich auch schon die ganze Magie.
So sauge ich also das XML übers Internet.
Das habt ihr hier oben gesehen, ungefähr hier.
Und so kann ich das XML parsen. Noch gar nicht
so viel Code, ist doch irgendwie nett. Okay,
jetzt gucken wir mal ganz kurz, was ich als nächstes
mit euch vorhabe. Genau, die Entwurfsregeln,
die wollte ich mir noch mal ganz kurz anschauen,
dass wir so einen gemeinsamen Fahrplan haben.
Und ich konzentriere mich da aber immer auf diese Darstellung
Jetzt ist es ein bisschen blöd über Werkzeuge,
können wir noch gar nicht so richtig sinnvoll reden,
weil das eben erst später kommt.
Also Werkzeugkonstruktion kommt irgendwie in vier oder fünf Wochen oder so,
wo ich also beibringe,
wie man so Buttons erzeugt und wie man darauf reagiert,
wenn jemand auf den Button draufklickt und so.
Da müssen wir so heute ein bisschen schummeln und einfach so eine kleine Texteingabe machen auf der Konsole.
Das sieht dann nicht ganz so sexy aus. Okay,
aber was ich machen will, ist den bestehenden Code zumindest soweit zu entfernen,
dass ich sagen kann, ich habe hier irgendwie Code,
der sich serviceartig anfühlt und ich habe hier etwas, was Materialien sind.
Ich weiß nicht, ob es da vielleicht Vorschläge von euch gibt,
was da Materialien sein könnten. Das Blöde ist,
diese Wetterdaten, So wie ich das System momentan gebaut habe,
werden ja einfach nur gesogen und irgendwie vielleicht angezeigt. Man könnte sich aber vielleicht vorstellen,
dass wir das System in den nächsten Wochen noch weiter ergänzen,
dass sich entweder diese Wetterdaten selber manipulieren könnte,
dass ich sagen kann, naja, die Wetterdaten haben mir irgendwie gesagt,
es wäre jetzt Sonne so richtig hundertprozentig, stimmt das gar nicht,
ich ändere das mal kurz über einen Buttonklick oder so.
Oder dass wir vielleicht das System erweitern, dass wir sagen können,
ich baue mir irgendwelche Materialien, die irgendwelche Wegrouten sind,
dass ich immer in der Stadt mich befinde,
wo gerade die schönste Sonne scheint oder so.
Okay, also ich werde versuchen, ein Material zu bauen,
jetzt erstmal heute
Ja, was mir irgendwie diese Wetter vorausschaut für eine Stadt,
vielleicht für einen bestimmten Zeitraum, wir schön in ein Objekt reintun,
dann kann ich da vielleicht irgendwelche Anfragen machen.
Und wenn ich das für eine Vorausschau für eine Stadt irgendwie gemacht habe,
dann will ich vielleicht in einem Service diese ganzen Daten irgendwie aggregieren.
Dieser Service aggregiert diese ganzen Daten und kann ich vielleicht den Service später mal fangen,
hey, ich will morgen, habe ich irgendwie frei,
in welcher Stadt soll ich immer fahren, wo sind das beste Wetter?
Und dann kann auf seinen Materialien da rumhühnern und das gucken,
wo er das Maximum findet oder das Minimum, je nachdem,
was man haben will. Das ist also die Aufteilung,
die ich mir so vorstelle, man könnte wahrscheinlich diskutieren,
ob diese Wetterdaten nicht eher so Richtung Fachwert gehen,
aber auch Fachwerte kennen wir noch nicht so richtig gut,
darüber reden wir erst in, ich glaube,
der vorletzten Vorlesung oder so.
Also glaubt mir jetzt erst mal, dass es halbwegs
sinnvoll ist, dass wir uns hier darauf beschränken.
Gut, damit habe ich eigentlich auch schon ein bisschen vorgegriffen.
Ja, hier, in welche Richtung es jetzt quasi gehen soll.
Ich will ein Service bauen und ein Material. Und mal schauen,
wie lange das dauert. Und wenn wir das geschafft haben,
dann würde ich gerne den Service, ja,
so schlau schreiben, wenn ich mehrfach frage,
wie ist eigentlich das Wetter in Hamburg,
dass er nicht immer wieder über das Internet geht.
Es steht sogar extra auf der Website von Open Weathermap.
Bitte frag nicht alle zehn Sekunden ab, wie das Wetter ist.
So oft ändert sich das gar nicht. Ja,
also wenn der Service sich einfach merkt,
welche Daten da zurückkommen, das soll er ja sicherlich machen,
dann macht das keinen Sinn,
ständig immer wieder nachzufragen
Okay, und wenn wir dann noch Zeit haben,
dann bauen wir halt dieses Pseudo-Werkzeug,
wo ich einfach nur auf der Konsole vielleicht eintippe,
Hamburg und dann werden die Wetterdaten von Hamburg angezeigt und wenn
er sie noch nicht hat, saugt er sie halt.
Okay, ich glaube, das ist für 20 Minuten ganz schön viel Zeug.
Aber gut, man muss ja irgendwo anfangen. Mal gucken,
wie weit wir kommen, sonst machen wir halt,
wenn ich das nächste Mal da bin, einfach weiter.
Okay, also wir gehen wieder in den Code zurück.
Und ich habe euch bis jetzt ja noch gar nicht gezeigt,
fällt mir gerade ein, wie dieser XML-Händler tatsächlich in Aktion tritt.
Ja, da können wir einfach mal gucken in meine Main-Methode.
Alles, was ich in meiner Main-Methode mache,
ich sage einfach nur das XML auf die Konsole
zu schreiben
Ich weiß nicht, ob man das noch sieht.
Ich hatte doch jemanden, wann hatte ich das letzte Mal gestartet?
Ich starte es einfach nochmal neu. Ich hoffe,
der Wetterservice ist mir nicht böse,
dass ich schon wieder die Daten von Hamburg abfrage.
Ja, also ich habe diesen XML-String bekommen übers Internet tatsächlich.
Das ist nicht gefaked. Aber ich mache noch nichts wirklich
Sinnvolles damit, außerdem auf die Konsole zu schreiben.
Ich würde jetzt gerne denen auch tatsächlich parsen,
diesen XML-String, mit dieser Methode Pass XML.
Gut, das heißt, ich rufe die einfach auf.
Pass XML. Was muss ich da übergeben, den String
wahrscheinlich? Genau, ich habe es selbst geschrieben.
Ich erinnere mich noch.
Hat jemand eine Ahnung? Warum das nicht geht?
Das ist so eine kleine Wiederholungsfrage von letzter Woche.
Ich habe also hier unten meine Methode Pass XML.
Ich war, also sie gibt nichts zurück,
ich tue einen String rein, dann wird hier irgendwas gemacht.
Warum beschwert sich jetzt der Compiler da oben?
Irgendwie meine Idee? Ja. Richtig, du hast gesagt,
weil Exceptions hier geworfen werden. IO Exception und S-A-X Exception,
also SA-X ist dieses Framework, was in Java eingebaut ist,
womit man halt dieses Pasen machen kann,
ohne das von Hand machen zu müssen
IO-Exception und SAX-Exception. Und was machen wir hier? Wir
kümmern uns nur um die IO-Exception. Was muss ich jetzt
tun? Ja. Ah, das kennst du schon?
Sehr gut. Ja, das Feature gibt es ja erst ja
2011. Genau. Also die Alternative wäre jetzt gewesen,
einen zweiten Catchblock da drunter, aber man hat irgendwann mal festgestellt,
ob wir mal drei, vier oder fünf verschiedene Acception anfangen und immer dasselbe tun.
Das ist doch blöd, dass man das nicht in denselben Catchblock tun kann.
Das ist also eine ganz komische Syntax, die gibt es
nur in diesem Kontext. Ich kann also sagen,
Ja, die Frage ist dann vor allem,
was ist denn jetzt der statische Typ von der Variable X?
Die Frage könnt ihr mit eurem Wissen gar nicht beantworten.
Aber ich glaube, man kann das pragmatisch ganz gut verstehen, oder?
Ich kann IO-Exceptions, oh, das SAX-Exceptions hier fangen. Gut,
das heißt also, wenn der Server mir irgendwie XML liefert,
was nicht richtig formatiert ist,
irgendwo ist eine Klammer auf und die Klammer zu,
dazu fehlt oder so, dann wird diese Acception fliegen.
Damit muss man ja auch mal rechnen. Okay,
jetzt hoffe ich mal, dass dadurch was Spannenderes auf der Konsole passiert,
wollen wir uns mal andere Wetter daten holen,
einfach nur der Abwechslung her bei Flat Berlin.
Ich hoffe, ich mache jetzt nichts kaputt,
ich hoffe, er hat Daten über Berlin.
Ah ja. Kann ich das im Vorbild
einmal anzeigen
Das hat er mir jetzt, also guck mal,
wie viele Daten das sind.
Genau. Also wo fängt denn das jetzt hier an?
12 Uhr. Ja, genau. Also die Vorausschau für heute
Mittag. Das ist ja schon eine halbe Stunde alt.
In Berlin war offenbar vereinzelte Wolken und 22 Grad Celsius.
Okay, und dann halt immer im 3-Stunden-Abstand.
Wie wird das heute Abend erwartungsgemäß immer kühler? Gut. Ja,
das ist jetzt natürlich ein bisschen enttäuschend,
dass es so auf der Konsole landet und dann passiert nichts großartig weiteres mehr.
Ich würde jetzt ja ganz gerne eigentlich mit diesen Daten
irgendwie in Objekten ablegen
Ich habe mal eine Ahnung, wie wir das machen.
Also sicherlich muss ich anstelle dieser System-Outprint-Clients was anderes machen.
Aber die Herausforderung ist jetzt ja,
ich bekomme die Daten ja nur irgendwie so stückweise rein.
Es würde also zum Beispiel keinen Sinn machen,
jetzt hier in Cyber 18 ein Objekt zu erzeugen,
weil ich die anderen Daten ja alle noch gar nicht habe.
Also im Prinzip, ja, zumindest wenn ich mich darauf
verlassen kann, dass die immer in derselben Reihenfolge kommen.
Wenn ich an dieser Stelle angekommen bin,
hat mir der Server die ganzen Daten geschickt.
Aber ich weiß natürlich nicht mehr, was hier mal geschickt wurde,
weil das ja ganz andere Methodenaufrufe waren.
Also diese Methode wird ja für jedes Element neu aufgerufen.
Was machen wir denn jetzt
Guck kurz, ob irgendjemand anderes noch Idee hat oder dass
ihr zumindest die Chance habt, drüber nachzudenken.
Ihr bekommt also irgendwelche Daten rein und wir müssen ein ganz kleines bisschen im Hintergrund uns merken,
weil wir später noch darauf zugreifen wollen,
um so ein schönes Objekt da auszubündeln.
Ah, wir könnten so ein Exemplar verspeichern.
Sehr schön. Dann machen wir das normal.
Bis jetzt ist dieser Weather XML-Händler ja völlig zustandslos.
Was kriegen wir denn da so? Das sind alles Strings
, dann lassen wir uns auch erstmal Strings.
Also zum Beispiel From
Und Tro, das wären quasi diese beiden,
da muss ich jetzt also hier quasi einmal den Typ wegnehmen,
dass er wirklich an meine Variablen zureißt.
Okay. Was brauchen wir noch? Name? Das ist
also, das ist eigentlich der Symbolname, ne?
Ich nenne es mal Symbolname. Gefällt mir besser.
Vielleicht nenne ich das auch mal ein bisschen anders.
Ich mache die Umbenennung gleich. So, ja,
das höchste Mal probieren will ich nicht mehr.
Und da haben wir noch Failure und Unit.
So, ich sammle das erstmal anders
Und ich glaube, ich will es gleich richtig mit euch machen.
Also, ich will es eigentlich ungern jetzt an dieser Stelle
sagen, ich habe jetzt alle Daten.
Ich kann mich ja nicht darauf verlassen,
dass der Server das wirklich immer in der Reihenfolge losschickt.
Ja, vielleicht werden die mal irgendwie in umgekehrter Reihenfolge geschickt,
dann arbeite ich teilweise auf Daten von Datensätzen, die noch davor waren.
Das gefällt mir eigentlich nicht so gut. Es gibt zu
diesem Startelement auch noch ein, ja, eine Schwester-Methode.
Ich zeige euch einmal ganz kurz die Klasse,
von der wir hier erben
Genau, wo ist es? Hier ist Startelement und es
gibt auch noch Entelement. Ja, also jedes Mal,
wenn ein Element komplett abgearbeitet ist, führt eine andere Methode aufgerufen.
Vielleicht sollen wir uns noch einmal kurz das XML angucken,
dass uns das klar ist, welchen Sinn das für uns hat.
Also hier, in diesem Blog stecken ja quasi die Daten drin,
die mich interessieren. Und ich wurde einmal benachrichtigt,
als der Parser hier ankam,
als er hier ankam und als er hier ankam,
wobei ich ja gesagt habe, es könnte durchaus sein,
dass zum Beispiel diese Zeile und diese Zeile vielleicht mal in einer anderen Reihenfolge kommen,
ich weiß es nicht, das ist nirgendwo spezifiziert.
Aber ihr könnt davon ausgehen,
sobald der Parser in dieser Zeile ankommt,
können nicht anschließend noch
solche Zeilen kommen
Hier ist dann definitiv Schloss. Hier ist dann dieser Zeitblock
einmal vorbei. Darauf kann ich also eigentlich genauso reagieren.
Ich kopiere mir einmal ganz kurz diesen Methodenkopf und nenne die
Methode dann einfach nur anders. Ja, ich sollte,
ja, so, dass sie das dann nicht Startelement,
sondern hieß es Stopp oder End?
Stopp. End? Ich gucke noch einmal ganz kurz,
dass ich mich hier nicht vertan habe.
Wie hieß sie? Endelement, String, String, String
. Ich gucke es mir noch mal ganz kurz an.
Genau, hatte ich das nicht so genauso hingeschrieben.
Was will er jetzt schon, ja
Achso, ich habe die Methodendrumpf nicht aufgemacht. Okay.
Okay, dann kann ich über dieses Coo-Name wieder switchen.
Das mache ich also genauso wie da oben. Switch,
Coo-Name, ich will das ja nicht für jedes Tag machen,
sondern nur wenn tatsächlich Time geschlossen wird.
Das hätte ich jetzt auch mit dem Eve machen können.
Okay, das heißt also an dieser Stelle habe ich mich vertippt.
War das ein Endesklein? Genau. An dieser Stelle sind wir jetzt also soweit,
dass wir die ganzen Daten gesammelt haben für diese eine Vorausschau.
Und dass wir jetzt damit irgendwas machen können.
Ich habe aber, was wollen wir denn jetzt damit machen?
Ich will mir jetzt irgendwie ein Material erstellen,
was aus diesen Daten besteht
Ja, so ähnlich wie er in der Mediathek gesagt hat,
es gibt sowas wie Kunden oder DVDs oder CDs oder irgendwelche Verleihkarten oder so.
Würde ich jetzt ganz gerne mir ein Material bauen,
wo diese Daten drin abgelegt werden. Ja. Genau,
machen wir doch eine Neuklasse, sehr gute Idee. Also,
ich klicke hier auf neue Klasse, das seht ihr unter
Umständen nicht, aber ihr müsst es mir wieder glauben.
Nennen wir das doch mal, ich habe hier,
glaube ich, immer englische, genau,
dann nehmen wir das ruhig,
vielleicht Forecast,
das ist ein schöner fachlicher Name
So. Und das wird jetzt, glaube ich,
ziemlich langweilig. Ich muss jetzt, ups,
ich muss jetzt ja im Prinzip, ja, diese Daten,
die ich mir hier so von Hand oder nach und nach gemerkt hatte,
die muss ich jetzt alle gesammelt da einmal reinstecken.
Ich mache das jetzt hier einmal mit Copy und Paste.
Vielleicht fallen euch schönere Möglichkeiten ein. So,
jetzt brauche ich einen Konstruktor. Da kann ich das nicht
von den Clips generieren lassen. Kann ich nicht sagen.
Generate, Constructor Using Fields. Mal gucken,
was jetzt passiert
Ich glaube, das ist genau das,
was wir brauchen, diesen Aufruf bauen wir nicht.
Ihr kennt den ja schon, über den brauchen wir nicht.
Das ist momentan noch ein ziemlich blödes Material. Ich stecke
einfach fünf Strings reins und die werden halt so abgespeichert.
Wir werden noch zugesehen, dass wir da auch sinnvolle,
fachliche Operationen darauf anwenden werden.
Oder um diese Klasse, um fachliche Operationen erweitern werden.
Okay. Aber ich kann mir das jetzt im Prinzip erstmal erzeugen.
Die Frage ist nur, was mache ich denn dann mit dem erzeugten Exemplar?
Also ich erzeuge das jetzt einmal. Wir haben ja gesagt,
hier ist ein guter Zeitpunkt, das zu erzeugen.
You forecast, muss ich das jetzt alles von Hand schreiben?
Okay, also wie waren die Daten from to
Simple Name
Simba, nee, was haben wir noch?
Falue and Unit. So, ich habe jetzt dieses Material,
das kann ich mir auch erstmal eine Variable ablegen.
Aber was mache ich denn jetzt damit?
Also das einfach nur so als lokale Variable zu haben,
dann verpufft das ja gleich wieder, ne?
Irgendjemand eine Idee, was wir jetzt machen mit diesem
schönen Material, was wir gerade erzeugt haben.
Ich habe kein einziges Wort verstanden leider. Du willst einen formatierten String ausgeben lassen.
Ich würde es euch ganz gerne erstmal als Material behalten.
Die Frage ist nur, wo soll das rein?
Also wir haben ja in der Mediathek gesehen,
die Materialien werden immer, meistens in irgendwelchen Collections vorgehalten.
Ah, das wäre eine Möglichkeit. Man könnte also sagen,
eine Möglichkeit ist tatsächlich zu sagen, ich merke mir hier alle Forecasts,
die ich bis jetzt schon eingelesen habe und am Ende hole
ich es mir dann einfach aus.
Das könnte man machen. Was man auch machen könnte,
ist zu sagen, im Konstruktor dieses Händlers,
Könnte ich ja auch übergeben, zum Beispiel eine Sammlung,
in die diese ganzen Forecasts reingeschrieben werden sollen.
Jedes Mal, wenn ich einen finde. Das scheint mir
irgendwie einfacher zu sein. Hätte man aber auch anders machen können.
Ich kann also sagen, pass auf, eine Collection von Forecasts.
Muss ich wahrscheinlich wieder ganz viel importieren. Ciao. Er
kennt ja Collection, nicht? Doch. Und am,
ja, muss ich mir das natürlich auch irgendwie merken.
Ach so, ja
, genau
So, das ist jetzt, leider habe ich ja immer nicht so viel Zeit.
Normalerweise würde man hier noch irgendwelche Sicherheitsabfang machen,
ist da wirklich was oder ist das nahe?
Das könnt ihr dann ja überarbeiten, das Projekt,
wenn ihr dazu Lust habt. Kann ich das nicht mal
irgendwie klarer machen? Das nervt mich so ein bisschen,
ja. Okay, also, ich weiß,
also ich kriege also einen Konstruktor übergeben, eine vermutlich leere Sammlung.
Nach dem Motto, bitte in diese Leeresammlung,
die Forecasts reinstecken, die du findest.
Oder machen wir das doch einfach mal. Also ich habe hier
meinen Forecast und ich stelle ihn da einfach mal rein.
Das ist jetzt also die Aufgabe des Klienten von Weather XML-Händler
Eine Collection da rein zu liefern. Ich würde jetzt also erwarten,
dass mein Programm gar nicht mehr übersetzbar ist,
denn ich habe jetzt hier auf einmal diesen Konstruktorparameter,
den es vorher gar nicht gab.
Okay. Ja, und schon sieht ihr, ist hier
ein rotes Kreuz. Das müsste beim Parsen sein irgendwo.
Hier unten, ne? Da fehlt jetzt dieser Parameter. Okay,
wir können uns jetzt davon nochmal überlegen,
dass wir hier gleich mal gucken,
welchen Code wir jetzt in diesen Service reinpacken im Prinzip,
sieht mir das alles danach aus, dass das da reingehört.
Wir werden wahrscheinlich nur diese Static rausnehmen müssen.
Ich kann dir vielleicht mal Erfolgendes machen,
ich kommentiere einmal ganz kurz die Main-Methode aus,
wenn man will, in Circus ist keine Main-Methode drin haben.
Und ich nenne die Klasse einmal um,
nennen wir sie doch mal Weather Service. So. Kommt halt
in Ennos. Achso, das ist wegen dieser Zeile.
Kann ich die nicht umbenennen, wenn dieser Fehler ist?
Ich versuche es einfach trotzdem. Eclipse hat mich ja gewarnt,
aber ich versuche es mal, ob das,
wenn ich es richtig tippe.
Ja,
ist mir egal
Okay. Gut, da ist mein Quertext noch.
Dann nehme ich mal diese ganzen Statics da raus. Also Services,
von denen erzeugt man die Exemplar,
das habt ihr bei dem Verleihservice ja auch gesehen,
in dem realen System wurde ich jetzt sogar noch ein Interface über den Service rüberhängen,
das Zeitgründen lasse ich das jetzt erstmal alles.
Also dieser Service wird sicherlich irgendwo erstellt werden müssen in
einer Start-up-Klasse und entsprechend verdrahtet werden müssen.
So. Okay, jetzt müssen wir uns mal Gedanken machen über
diese Collection
Genau, also wir sind jetzt in dieser Service-Klasse und wir hatten ja gesagt,
oder heute gelernt, ein Service verwaltet Materialien.
Man könnte jetzt also irgendeine Art von Collection nehmen von
diesen Forecasts und die hier einfach als Exemplarvariable nehmen.
Also nehmen wir mal, was nehmen wir da mal?
Eine Liste. Vielleicht werden wir sehen, wenn wir später
interessante Operationen haben, dass da eine Map möglicherweise besser geeignet ist.
So, machen wir mal gleich eine neue Air-Realist und
dann brauche ich den Konstruktor an dieser Stelle nicht.
Ja. Okay. Und jetzt kann ich das hier
Entsprechend übergeben diese Liste. So. Okay, jetzt ist Java
wieder zufrieden. Ich gucke mal ganz kurz,
ob hier noch irgendwas drin ist, was hier nicht reingehört.
Also, der Service verwaltet diese Forecats in einer Airlist.
Jetzt sollten wir uns mal überlegen, jetzt haben wir ja ganz viele Public-Methoden.
Was ist denn für den Klienten wirklich relevant? Ein Klient
will ja zum Beispiel nicht irgendwie XML haben oder so.
Exorced Inputstream, das ist ja alles sehr, sehr technisch.
Also das will ich eigentlich alles dem Klienten gar nicht zeigen,
dass es diese Methoden gibt.
Ich mache die mal alle private wups
Und sag. Okay. So. Und wir können mal gucken,
das, was vorher in der Main-Methode stand,
ob man dafür eine sinnvolle öffentliche Methode schreiben kann.
Genau. Also, wir haben ja hier momentan gesagt,
wir wollen immer von Berlin die Wetterdaten haben.
In einem echten Service ist es wahrscheinlich sinnvoller,
es gibt eine Methode, wo ich den Namen der Stadt reinstecke,
die mich gerade interessiert.
Also, nennen wir die doch mal,
Get Weather Forecast Four Street
Ring City. Das ist schon ein halbwegs sinnvoller Name, ich hoffe mal schon.
Okay, dann kann ich mir das hier alles rausnehmen.
So, und dann nehmen wir hier mal, ich stehe,
ich hatte den Rückgabetyp vergessen. Ja, wollen wir da einfach eine Liste zurückgeben? Das ist jetzt interessant,
glaube ich, ihr merkt jetzt die Leute von euch,
die sich mit Layout von Daten beschäftigen oder die Datenbank-Experten,
die merken jetzt, glaube ich, langsam,
wir kommen jetzt schon an die Grenzen unseres Datenmodells,
wir haben einfach nur eine flache Liste,
wo wir Forecasts dann abspeichern,
aber wir haben uns ja nirgendwo gemerkt,
für welche Stadt gilt dieser Forecast eigentlich
Das ist irgendwie nicht so schlau, oder? Da müssen wir
gleich nochmal überlegen, ob uns da was Besseres einfällt.
Okay. So, was habe ich jetzt noch falsch gemacht?
Also die Acceptions. Nee, was will er von mir
? Lieber Compiler. List of Hawkers. Achso,
ich gebe hier nichts zurück, genau. Okay,
das heißt, wenn wir dieses XML parsen,
dann wird ja diese Liste hier oben einfach befüllt.
Und wenn ich jetzt verschiedene Städte abfrage,
erst Hamburg und in Berlin, dann werde ich bei Berlin,
die Forecasts von Berlin und von Hamburg bekommen.
Irgendwie nicht so wahnsinnig sinnvoll, oder? Also ich hoffe,
ihr habt gemerkt, so eine einfache flache Liste,
irgendwie ist es damit nicht getan
Was können wir denn stattdessen nehmen? Also ich will mir
jetzt nicht einfach nur eine flache Liste von allen Forkers,
die ich jemals angefragt habe, sondern ich will mir das
für jede Stadt eine eigene Liste dieser Forecasts quasi haben.
Kennt ihr eine Datenstruktur, wo ich sagen kann,
für Hamburg würde ich diese Liste haben.
Und für Berlin will ich diese Liste haben.
Und für Bremen will ich diese Liste haben, ja.
Eine Map, genau. Ich kann das so sagen.
Ich nehme, oder ich hätte das Liste eigentlich stehen lassen können.
Ich nehme eine Map, die mir für einen Stadtnamen
eine entsprechende Liste speichert. Da muss ich das hier natürlich
auch entsprechend an eine Hashmap nehmen, von Listen von Forecasts.
So,
da muss ich importieren
Ist er nicht zufrieden. Habe ich nicht genug importiert?
Was habe ich falsch gemacht? Oh,
ich habe den Typ, das Typ Argument hier vergessen.
Dankeschön. Ist er jetzt zufrieden, ja.
Was man übrigens auch seit Java 7 machen kann,
ist zu sagen, dieser, ja, dieses Zeug,
was ja hier eigentlich schon steht, diese Typangaben,
die will ich nicht nochmal hinschreiben.
Man nennt das auch den Diamantoperator,
weil diese beiden Klammern hintereinander sehen aus wie so ein Diamant.
Okay. Okay, also als Beispiel für Hamburg will ich
eine Liste mit diesen Forecasts haben.
Und für Bremen würde ich eine Liste mit diesen Forecasts haben.
Also das macht von der reinen Datenaufteilung ja schon mal Sinn.
Jetzt ist die Frage, wie füttern wir
die Daten entsprechend
Okay, das sollten wir uns vielleicht mal hier unten angucken.
Genau, wo paarse ich das denn? Okay,
hier muss ich jetzt die Liste reinstellen, die zu der Stadt gehört.
Das Blöde ist nur, dass diese Methode Paars XML ja
gar nicht weiß, für welche Stadt ich mich interessiere.
Das heißt, hier sollte ich diese Stadt wahrscheinlich noch einmal separat übergeben.
Und wie kann ich jetzt an dieser Stelle sagen,
ich habe eine Map und ich will jetzt die Liste in
der Map haben, die zu dieser City gehört?
Habt ihr schon mal mit Maps
in der Form gearbeitet
Da könnt ihr einfach sagen, Get City. So kriegt
ihr quasi aus dieser mehrdimensionalen Datenstruktur diese eine Liste zurück.
Okay. Okay, das heißt, hier wird das befüllt.
Natürlich kann es sein, dass es diese Liste noch gar nicht gibt.
Ich glaube, wir müssen das vielleicht erst mal da reintun in die Map.
Das sollen wir vielleicht mal als erstes machen.
Also ich erstelle mir eine neue Airrelist von Forecosts.
Forecost. Und nenn die mal, ja
Wenn die jetzt erst mal Liste, einfach gerade halber,
okay. Und ich muss jetzt dafür sorgen,
dass für Hamburg diese Liste in der Map abgelegt wird.
Ihr werdet mit Maps viel in der Übung machen,
deswegen passt es eigentlich total super.
Ich muss also sagen, quasi genau der umgekehrte Weg,
dass diese Liste bitte zu dieser Stadt gehören soll.
Und dann muss ich das hier nicht wieder aus der Map rausholen,
dann kann ich einfach sagen, ich nehme die Liste,
die ich mir da erzeugt habe.
Was will er jetzt von mir?
Nee, es heißt nicht Liste, es heißt Forecasts.
Okay, also ich sage an dieser Stelle,
wahrscheinlich am Anfang ist ja diese Map komplett leer.
Ich sage zu, zum Beispiel der Stadtramburg,
wenn das übergeben wird, soll bitte diese Liste gehören,
die ich mir gerade neu erzeugt habe und die übergebe ich
dann auch an den Parser
Okay, wo rufe ich denn jetzt das Pass XML auf?
Da muss ich ja auch die Stadt übergeben. Das mache ich
ja hier. Dann übergebe ich mal die Stadt. So,
dann ähm, muss ich das jetzt nur noch zurückgeben.
Also jetzt kann ich doch das sagen,
ich kann jetzt sagen, Forecasts an der Stelle City.
Ist er dann zufrieden? Nee, ist noch nicht zufrieden.
Ach so, was passiert, wenn diese Acception fliegt?
Ja, da müsst ihr euch wieder was Schöneres ausdenken.
Okay. Gut. Dann kann ich das hier mal
nach außen
Okay, das heißt, was man jetzt zum Beispiel schon machen kann,
wenn man noch Zeit hätte, wir könnten jetzt Testklassen schreiben.
Ja, ich habe jetzt hier irgendwelche Testdaten,
die könnte ich ja da auch irgendwie rein verdrahten und könnte gucken,
wenn ich für Hamburg das Wetter abfrage,
kommt dann in dieser Liste die Forkers zurück, die ich erwarte.
Ja, das war vorher ein bisschen schwierig,
weil wir hatten eine Main-Methode, die wurde ausgeführt und
nirgendwo wurden ein paar Daten zurückgeliefert oder längerfristig gespeichert.
Jetzt kann man da anfangen, mal hier so ein bisschen
die Fachlichkeit zu testen. Wozu wir jetzt leider nicht gekommen sind,
ich gehe nochmal ganz kurz auf meinen Fahrplan,
da hat leider die Zeit nicht gereicht.
Momentan erzeuge ich mir immer eine neue Liste,
ich sage mal ganz kurz in Code unten
Hier an dieser Stelle. Ja,
also wenn jemand jetzt mehrfach Hamburg abfragt, dann werden die
alten Daten einfach gelöscht und die Daten werden wieder neu angefragt.
Wahrscheinlich wäre es ja schöner, wenn man die einfach dieselben Daten nochmal nimmt.
Dieses Programm wird ja nie länger als ein paar Stunden laufen
und so häufig ändern sich diese Anfragen an den Wetterdienst.
Dazu sind wir jetzt leider nicht gekommen. Und wir haben
auch überhaupt keinen Klienten davon geschrieben. Ich konnte euch das
jetzt gar nicht sinnvoll zeigen, wie das Programm mal läuft.
Das wäre dann quasi hier gewesen. Ich würde gerne tatsächlich
das Programm starten und da kommt eine Eingabe oder ein Prompt,
für welche Stadt willst du denn jetzt die Wetterdaten haben?
Dann gebe ich Hamburg ein und dann wird das geliefert.
Dann gebe ich nochmal Hamburg ein und dann werden dieselben Daten
geliefert und dann kann ich Berlin eingeben und so weiter.
Dazu sind wir jetzt leider nicht gekommen, aber es ist ja nicht schlimm.
Ihr seht mich heute nicht zum letzten Mal.
Ich würde sagen, da machen wir einfach nächstes Mal weiter.
Ja, und dann wünsche ich euch erstmal Frau Pfingsten